Portable VB-Programme: Nutzung von ActiveX Komponenten ohne Registrierung und ohne Adminrechte

    • VB6

    Es gibt 2 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

      Hallo!

      Es ist ein häufig vorkommendes Problem, dass man mit VB geschriebene Software auf Rechnern laufen lassen muss, auf denen man keine Adminrechte besitzt. Hierzu benötigt man also "portable" Versionen der eigenen Software, da eine Installation und Registrierung von Komponenten (vorwiegend ActiveX) nicht möglich ist. VB stellt im Projekt-Unterverzeichnis ..\Paket\Support zwar sämtliche nötigen Komponenten für das Projekt zur Verfügung, aber ein einfaches Kopieren dieser Komponenten auf einen USB-Stick oder eine CD reicht meist nicht aus, um eine portable Version zu erzeugen, wenn Komponenten enthalten sind, die eine Registrierung erfordern (z.B. ActiveX-Komponenten - *.OCX). Startet man solch ein Programm, erhält man die Fehlermeldung "Die Komponente 'XYZ' oder eine ihrer Abhängigkeiten ist nicht richtig registriert: Eine Datei fehlt oder ist ungültig." XYZ ist dann der Name der nicht registrierten ActiveX-Komponente. Ohne Administratorrechte ist eine Registrierung (z.B. mit regsvr32) leider nicht möglich, da die Komponenten im Registry-Zweig HKEY_CLASSES_ROOT registriert werden müssen, auf den eingeschränkte Benutzer keinen Schreibzugriff besitzen (auf diese Weise erfährt man aber immerhin, welche Komponenten überhaupt registriert werden müssen).

      Das Problem kann dadurch umgangen werden, dass man die Registrierungs-Informationen nicht in HKEY_CLASSES_ROOT schreibt, sondern in den Registry-Zweig des lokalen Users, auf den er vollen Zugriff besitzt, nämlich HKEY_CURRENT_USER\Software\Classes. Damit die Informationen vom Programm dann auch dort ausgelesen werden und nicht aus dem Standard-Pfad unter HKEY_CLASSES_ROOT, muss dieser Standard-Pfad auf den benutzereigenen Pfad HKEY_CURRENT_USER\Software\Classes quasi "umgebogen" werden. Ein solcher Verweis kann mit der API-Funktion RegOverridePredefKey erstellt werden, die ab Windows 2000 verfügbar ist. Für das laufende Programm ist der Pfad zu den OCX-Registrierungen dann nicht mehr unter HKEY_CLASSES_ROOT zu finden, sondern unter HKEY_CURRENT_USER.

      Zuerst einmal benötigt man also ein eigenständiges VB-Programm (Project1.vbp), das die Registrierung im Pfad des angemeldeten Users vornimmt. Es ersetzt praktisch "regsvr32" und wird zusammen mit den zu registrierenden DLLs und der eigentlichen VB-Software (aus dem Projekt-Unterverzeichnis ..\Paket\Support) z.B. auf einen USB-Stick kopiert. Dieses Programm muss nur einmal aufgerufen werden und nimmt die lokale Registrierung der nötigen Komponenten vor. Danach kann das eigentliche Programm immer wieder direkt gestartet werden.

      Das Programm zur lokalen Registrierung der ActiveX-Komponenten (Aufruf ohne Admin-Rechte)

      Visual Basic-Quellcode

      1. 'Autor: Volker Ulle
      2. 'E-Mail: vulle@web.de
      4. '------------- Anfang Projektdatei Project1.vbp -------------
      5. 'Project1 ist ein eigenständiges Programm und dient nur vorab
      6. 'zur lokalen Registrierung der Komponenten.
      8. '--------- Anfang Formular "Form1" alias Form1.frm ---------
      9. 'Diese Form wird nicht angezeigt, sondern dient lediglicht
      10. 'zur Registrierung von Libraries (ActiveX (OCX), DLL etc.)
      11. 'im Zweig HKEY_CURRENT_USER der Registry, auf die auch
      12. 'eingeschränkte Benutzer Schreibrechte besitzen.
      13. 'In diesem Beispiel werden COMCTL32.OCX und MSCOMM32.OCX
      14. 'registriert.
      16. Private Sub Form_Load()
      17. Dim sRet As String
      19. If Register_DLL("COMCTL32.OCX") = 0 Then
      20. sRet = sRet + vbCrLf + "COMCTL32.OCX"
      21. End If
      23. If Register_DLL("MSCOMM32.OCX") = 0 Then
      24. sRet = sRet + vbCrLf + "MSCOMM32.OCX"
      25. End If
      27. If sRet <> "" Then
      28. MsgBox "Folgende DLLs wurden erfolgreich im lokalen Benutzerkonto registriert: " + vbCrLf + sRet
      29. End If
      30. End
      32. End Sub
      33. '---------- Ende Formular "Form1" alias Form1.frm ----------
      35. '--------- Anfang Modul "Module1" alias Module1.bas ---------
      36. 'Registrierung einer (ActiveX-)Komponente
      37. Option Explicit
      39. Private Const ERROR_SUCCESS As Long = 0
      40. Private Const HKEY_CLASSES_ROOT As Long = &H80000000
      41. Private Const HKEY_CURRENT_USER As Long = &H80000001
      43. 'Registry-Keys
      44. Private Declare Function RegOpenKey Lib "advapi32.dll" Alias "RegOpenKeyA" ( _
      45. ByVal hKey As Long, _
      46. ByVal lpSubKey As String, _
      47. phkResult As Long) As Long
      49. Private Declare Function RegOverridePredefKey Lib "advapi32" ( _
      50. ByVal hKey As Long, _
      51. ByVal hNewHKey As Long) As Long
      53. Private Declare Function RegCloseKey Lib "advapi32.dll" ( _
      54. ByVal hKey As Long) As Long
      56. 'DLL-Registrierung
      57. Private Declare Function LoadLibrary Lib "kernel32.dll" Alias "LoadLibraryA" ( _
      58. ByVal lpLibFileName As String) As Long
      60. Private Declare Function FreeLibrary Lib "kernel32.dll" ( _
      61. ByVal hLibModule As Long) As Long
      63. Private Declare Function GetProcAddress Lib "kernel32.dll" ( _
      64. ByVal hModule As Long, _
      65. ByVal lpProcName As String) As Long
      67. Private Declare Function CallWindowProc Lib "user32.dll" Alias "CallWindowProcA" ( _
      68. ByVal lpPrevWndFunc As Long, _
      69. ByVal hwnd As Long, _
      70. ByVal msg As Long, _
      71. ByVal wParam As Long, _
      72. ByVal lParam As Long) As Long
      74. Public Function Register_DLL(DLLName As String) As Integer
      75. Dim lRet As Long
      76. Dim hKey As Long
      78. Dim hModule As Long
      79. Dim pAdr As Long
      80. Dim S As String
      82. Register_DLL = 0
      84. S = App.Path
      85. If Right(S, 1) <> "\" Then S = S & "\"
      86. S = S & DLLName
      88. 'Override HKEY_CLASSES_ROOT:
      89. If RegOpenKey(HKEY_CURRENT_USER, "Software\\Classes", hKey) = ERROR_SUCCESS Then
      90. lRet = RegOverridePredefKey(HKEY_CLASSES_ROOT, hKey)
      91. RegCloseKey hKey
      92. If lRet = ERROR_SUCCESS Then
      93. 'Call the normal registration entry:
      94. hModule = LoadLibrary(S)
      96. If hModule Then
      97. pAdr = GetProcAddress(hModule, "DllRegisterServer")
      98. If pAdr Then
      99. CallWindowProc pAdr, 0, 0, 0, ByVal 0
      100. Else
      101. Register_DLL = 4
      102. End If
      103. Else
      104. MsgBox "DLL-Error " + CStr(Err.LastDllError) + " beim Registrieren von " + DLLName
      105. Register_DLL = 1
      106. End If
      108. FreeLibrary hModule
      109. Else
      110. Register_DLL = 2
      111. End If
      112. Else
      113. Register_DLL = 3
      114. End If
      116. End Function
      117. '--------- Ende Modul "Module1" alias Module1.bas ---------
      118. '-------------- Ende Projektdatei Project1.vbp --------------


      In der eigentlichen VB-Software (Project2.vbp), die die zuvor registrierten Komponenten benutzt, muss der Registry-Pfad natürlich ebenfalls auf HKEY_CURRENT_USER "umgebogen" werden. Und zwar BEVOR die entsprechende Komponente angesprochen wird. Also am besten im Load-Ereignis der Haupt-Form. Der "umgebogene" Key hat nur innerhalb des Programms Gültigkeit. Außerhalb wird weiterhin der originale Key verwendet. Wenn das Programm beendet wird, sollte (am besten im Unload-Ereignis) dennoch die Funktion RestoreOverrideKey() aufgerufen werden. Denn innerhalb der VB-Entwicklungsumgebung wird der "umgebogene" Key beim Beenden des Programms nicht automatisch zurückgesetzt, was dazu führen würde, dass die Entwicklungsumgebung auf falsche Keys zugreift und es u.U. zu Fehlermeldungen kommt.

      Das eigentliche Benutzerprogramm, das Komponenten benutzt, die registriert werden müssen

      Visual Basic-Quellcode

      1. '------------- Anfang Projektdatei Project2.vbp -------------
      2. '--------- Anfang Formular "Form1" alias Form1.frm ---------
      3. Private Sub Form_Load()
      5. If OverrideKey Then
      6. MsgBox "Key override failed!"
      7. End
      8. End If
      10. End Sub
      12. Private Sub Form_Unload(Cancel As Integer)
      14. RestoreOverrideKey
      16. End Sub
      17. '--------- Ende Formular "Form1" alias Form1.frm ---------
      19. '--------- Anfang Modul "Module1" alias Module1.bas ---------
      20. Option Explicit
      22. Private Const ERROR_SUCCESS As Long = 0
      23. Private Const HKEY_CLASSES_ROOT As Long = &H80000000
      24. Private Const HKEY_CURRENT_USER As Long = &H80000001
      26. 'Registry-Keys
      27. Private Declare Function RegOpenKey Lib "advapi32.dll" Alias "RegOpenKeyA" ( _
      28. ByVal hKey As Long, _
      29. ByVal lpSubKey As String, _
      30. phkResult As Long) As Long
      32. Private Declare Function RegOverridePredefKey Lib "advapi32" ( _
      33. ByVal hKey As Long, _
      34. ByVal hNewHKey As Long) As Long
      36. Private Declare Function RegCloseKey Lib "advapi32.dll" ( _
      37. ByVal hKey As Long) As Long
      39. Public Function OverrideKey() As Integer
      40. Dim lRet As Long
      41. Dim hKey As Long
      43. OverrideKey = 1
      44. 'Override HKEY_CLASSES_ROOT:
      45. If RegOpenKey(HKEY_CURRENT_USER, "Software\\Classes", hKey) = ERROR_SUCCESS Then
      46. lRet = RegOverridePredefKey(HKEY_CLASSES_ROOT, hKey)
      47. RegCloseKey hKey
      48. If lRet = ERROR_SUCCESS Then
      49. OverrideKey = 0
      50. End If
      51. End If
      53. End Function
      55. Public Function RestoreOverrideKey() As Integer
      56. Dim lRet As Long
      58. RestoreOverrideKey = 1
      59. 'Restore Override of HKEY_CLASSES_ROOT:
      60. lRet = RegOverridePredefKey(HKEY_CLASSES_ROOT, 0&)
      61. If lRet = ERROR_SUCCESS Then
      62. RestoreOverrideKey = 0
      63. End If
      65. End Function
      66. '--------- Ende Modul "Module1" alias Module1.bas ---------
      67. '-------------- Ende Projektdatei Project2.vbp --------------


      Werden nun die Programmdateien zusammen mit den benötigten ActiveX-Komponenten und dem Registrierungs-Programm in ein Verzeichnis auf CD oder USB-Stick kopiert, kann man jedes VB-Programm auch ohne Registrierung und ohne Admin-Rechte starten. Erfolgreich getestet mit Windows XP und Windows 7.

      Gruß, Volker

      Edit by hal2000:
      - Code-Tags in VB-Tags geändert
      Edit by volkeru:
      - Deklaration der unbenutzten Variablen "TempPath" entfernt
      - Funktion RestoreOverrideKey eingeführt
      Edit by LaMa5:
      - die Farbe ROT ist ausschließlich für moderative Zwecke vorbehalten (Boardregeln §4.3c)
      --> Farbgebung angepasst

      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „LaMa5“ ()

      Erweiterung des Codes

      Nach einigen Anfragen habe ich den oben vorgestellten Code etwas erweitert:
      • Der Code funktioniert erst ab Windows 2000 (und aufwärts). Daher wurde eine Versionsabfrage und ein entsprechender Hinweis bei ungeeigneten Windows-Versionen eingebaut.
      • Die unter HKEY_CURRENT_USER\Software\Classes\CLSID erzeugten Keys können nun auch "unregistriert" werden. In diesem Fall werden sie wieder aus der Registry des angemeldeten Benutzers entfernt. Dazu wird das Programm mit dem Parameter /u aufgerufen (Start -> Ausführen). Dazu wurde die Funktion "Register_DLL" um einen zusätzlichen, optionalen Parameter "Unregister" erweitert.
      • Der bei der Registrierung des Moduls "umgebogene" Registry-Key wird nach der Registrierung wieder auf den originalen Registrierungspfad zurückgesetzt.
      Das Programm zur lokalen Registrierung der ActiveX-Komponenten (Aufruf ohne Admin-Rechte)

      Visual Basic-Quellcode

      1. 'Autor: Volker Ulle
      2. 'E-Mail: vulle@web.de
      4. '------------- Anfang Projektdatei Project1.vbp -------------
      5. 'Project1 ist ein eigenständiges Programm und dient nur vorab
      6. 'zur lokalen Registrierung der Komponenten.
      8. '--------- Anfang Formular "Form1" alias Form1.frm ---------
      9. 'Diese Form wird nicht angezeigt, sondern dient lediglich
      10. 'zur Registrierung von Libraries (ActiveX (OCX), DLL etc.)
      11. 'im Zweig HKEY_CURRENT_USER der Registry, auf die auch
      12. 'eingeschränkte Benutzer Schreibrechte besitzen.
      13. 'In diesem Beispiel werden COMCTL32.OCX und MSCOMM32.OCX
      14. 'registriert.
      15. Private Sub Form_Load()
      16. Dim sRet As String
      17. Dim UnregParam As Boolean
      18. Dim WindowsVersion As String
      19. Dim Platform As Integer
      20. Dim Major As Integer
      21. Dim Minor As Integer
      23. WindowsVersion = GetWindowsVersion(Platform, Major, Minor)
      24. If Not MinWin2000() Then
      25. MsgBox "Diese Funktion ist erst ab Windows 2000 verfügbar!", vbExclamation
      26. Unload Me
      27. End
      28. End If
      30. If LCase(Command) = "/u" Then
      31. UnregParam = True
      32. Else
      33. UnregParam = False
      34. End If
      35. If Register_DLL("MSCOMCTL.OCX", UnregParam) = 0 Then
      36. sRet = sRet + vbCrLf + "MSCOMCTL.OCX"
      37. End If
      39. If Register_DLL("MSCOMM32.OCX", UnregParam) = 0 Then
      40. sRet = sRet + vbCrLf + "MSCOMM32.OCX"
      41. End If
      43. If Register_DLL("RICHTX32.OCX", UnregParam) = 0 Then
      44. sRet = sRet + vbCrLf + "RICHTX32.OCX"
      45. End If
      47. If sRet <> "" Then
      48. If UnregParam Then
      49. MsgBox "Sie nutzen " + WindowsVersion + " (" + CStr(Platform) + "." + CStr(Major) + "." + CStr(Minor) + ")" + vbCrLf + _
      50. "Folgende DLLs wurden erfolgreich im lokalen Benutzerkonto unregistriert: " + vbCrLf + sRet, vbInformation
      51. Else
      52. MsgBox "Sie nutzen " + WindowsVersion + " (" + CStr(Platform) + "." + CStr(Major) + "." + CStr(Minor) + ")" + vbCrLf + _
      53. "Folgende DLLs wurden erfolgreich im lokalen Benutzerkonto registriert: " + vbCrLf + sRet, vbInformation
      54. End If
      55. Else
      56. MsgBox "Sie nutzen " + WindowsVersion + " (" + CStr(Platform) + "." + CStr(Major) + "." + CStr(Minor) + ")" + vbCrLf + _
      57. "Es konnte keine DLL erfolgreich im lokalen Benutzerkonto un/registriert werden!", vbExclamation
      58. End If
      59. Unload Me
      60. End
      62. End Sub
      63. '---------- Ende Formular "Form1" alias Form1.frm ----------
      65. '--------- Anfang Modul "Module1" alias Module1.bas ---------
      66. Option Explicit
      68. Private Const ERROR_SUCCESS As Long = 0
      69. Private Const HKEY_CLASSES_ROOT As Long = &H80000000
      70. Private Const HKEY_CURRENT_USER As Long = &H80000001
      72. 'Datei-Existenz
      73. Private Declare Function GetFileAttributes Lib "kernel32.dll" Alias "GetFileAttributesA" ( _
      74. ByVal lpFileName As String) As Long
      76. 'Registry-Keys
      77. Private Declare Function RegOpenKey Lib "advapi32.dll" Alias "RegOpenKeyA" ( _
      78. ByVal hKey As Long, _
      79. ByVal lpSubKey As String, _
      80. phkResult As Long) As Long
      82. Private Declare Function RegOverridePredefKey Lib "advapi32" ( _
      83. ByVal hKey As Long, _
      84. ByVal hNewHKey As Long) As Long
      86. Private Declare Function RegCloseKey Lib "advapi32.dll" ( _
      87. ByVal hKey As Long) As Long
      89. 'DLL-Registrierung
      90. Private Declare Function LoadLibrary Lib "kernel32.dll" Alias "LoadLibraryA" ( _
      91. ByVal lpLibFileName As String) As Long
      93. Private Declare Function FreeLibrary Lib "kernel32.dll" ( _
      94. ByVal hLibModule As Long) As Long
      96. Private Declare Function GetProcAddress Lib "kernel32.dll" ( _
      97. ByVal hModule As Long, _
      98. ByVal lpProcName As String) As Long
      100. Private Declare Function CallWindowProc Lib "user32.dll" Alias "CallWindowProcA" ( _
      101. ByVal lpPrevWndFunc As Long, _
      102. ByVal hwnd As Long, _
      103. ByVal msg As Long, _
      104. ByVal wParam As Long, _
      105. ByVal lParam As Long) As Long
      107. Private Function DoesFileExist(Path) As Boolean
      108. DoesFileExist = ((GetFileAttributes(Path)) <> -1)
      109. End Function
      111. Public Function Register_DLL(DLLName As String, Optional Unregister As Boolean = False) As Integer
      112. Dim lRet As Long
      113. Dim hKey As Long
      115. Dim hModule As Long
      116. Dim pAdr As Long
      117. Dim S As String
      119. Register_DLL = 0
      121. S = App.Path
      122. If Right(S, 1) <> "\" Then S = S & "\"
      123. S = S & DLLName
      125. If Not DoesFileExist(S) Then
      126. MsgBox "Datei " + S + " nicht vorhanden!", vbExclamation
      127. Register_DLL = 5
      128. Exit Function
      129. End If
      131. 'Override HKEY_CLASSES_ROOT:
      132. If RegOpenKey(HKEY_CURRENT_USER, "Software\\Classes", hKey) = ERROR_SUCCESS Then
      133. lRet = RegOverridePredefKey(HKEY_CLASSES_ROOT, hKey)
      134. RegCloseKey hKey
      135. If lRet = ERROR_SUCCESS Then
      136. 'Call the normal registration entry:
      137. hModule = LoadLibrary(S)
      139. If hModule Then
      140. If Unregister Then
      141. pAdr = GetProcAddress(hModule, "DllUnregisterServer")
      142. Else
      143. pAdr = GetProcAddress(hModule, "DllRegisterServer")
      144. End If
      145. If pAdr Then
      146. 'Modul unter dem Schlüssel HKEY_CURRENT_USER\Software\Classes\CLSID registrieren bzw. unregistrieren
      147. CallWindowProc pAdr, 0, 0, 0, ByVal 0
      148. Else
      149. Register_DLL = 4
      150. End If
      151. Else
      152. MsgBox "DLL-Error " + CStr(Err.LastDllError) + " beim Registrieren von " + DLLName
      153. Register_DLL = 1
      154. End If
      156. FreeLibrary hModule
      157. 'Restore Override of HKEY_CLASSES_ROOT:
      158. lRet = RegOverridePredefKey(HKEY_CLASSES_ROOT, 0&)
      159. If lRet <> ERROR_SUCCESS Then
      160. Register_DLL = 6
      161. End If
      162. Else
      163. Register_DLL = 2
      164. End If
      165. Else
      166. Register_DLL = 3
      167. End If
      169. End Function
      170. '--------- Ende Modul "Module1" alias Module1.bas ---------
      172. '--------- Anfang Modul "GetWinVers" alias GetWinVers.bas ---------
      173. ' Werte für dwPlatformId von OSVERSIONINFO
      174. Private Const VER_PLATFORM_WIN32s As Long = 0&
      175. Private Const VER_PLATFORM_WIN32_WINDOWS As Long = 1&
      176. Private Const VER_PLATFORM_WIN32_NT As Long = 2&
      177. Private Type OSVERSIONINFO
      178. dwOSVersionInfoSize As Long ' Größe der Struktur
      179. dwMajorVersion As Long ' Major-Versionsnummer
      180. dwMinorVersion As Long ' Minor-Versionsnummer
      181. dwBuildNumber As Long ' Build-Versionsnummer
      182. dwPlatformId As Long ' Plattform-Kennzeichner
      183. szCSDVersion As String * 128 ' Service Pack (Klartext)
      184. End Type
      185. ' Abrufen der Windows-Versionsinformationen:
      186. Private Declare Function GetVersionEx _
      187. Lib "kernel32" Alias "GetVersionExA" ( _
      188. ByRef VersionInformation As OSVERSIONINFO _
      189. ) As Long
      191. Public Function MinWin2000() As Boolean
      192. Dim OSVI As OSVERSIONINFO
      193. Dim lSuccess As Long
      195. MinWin2000 = False
      196. ' Größe der OSVERSIONINFO-Struktur angeben
      197. OSVI.dwOSVersionInfoSize = Len(OSVI)
      198. ' Abruf der Windows-Versionsinformationen
      199. lSuccess = GetVersionEx(OSVI)
      200. If lSuccess = 0 Then
      201. Exit Function
      202. End If
      203. If OSVI.dwPlatformId > 1 And OSVI.dwMajorVersion > 4 Then
      204. MinWin2000 = True
      205. End If
      207. End Function
      209. Public Function GetWindowsVersion(Platform As Integer, Major As Integer, Minor As Integer) As String
      210. Dim OSVI As OSVERSIONINFO
      211. Dim lSuccess As Long
      212. ' Größe der OSVERSIONINFO-Struktur angeben
      213. OSVI.dwOSVersionInfoSize = Len(OSVI)
      214. ' Abruf der Windows-Versionsinformationen
      215. lSuccess = GetVersionEx(OSVI)
      216. ' Erfolgreiche Abarbeitung überprüfen
      217. If lSuccess = 0 Then
      218. Exit Function
      219. End If
      220. ' Auswertung der Versionsnummern:
      221. Select Case OSVI.dwPlatformId ' Plattform-Kennzeichner
      222. Case VER_PLATFORM_WIN32s ' Win32s-Erweiterung
      223. GetWindowsVersion = "Win32s für Windows 3.x"
      224. Case VER_PLATFORM_WIN32_WINDOWS ' Windows 9x/Me
      225. Select Case OSVI.dwMinorVersion
      226. Case 0
      227. GetWindowsVersion = "Windows 95"
      228. Case 10
      229. GetWindowsVersion = "Windows 98"
      230. Case 90
      231. GetWindowsVersion = "Windows Me"
      232. End Select
      233. Case VER_PLATFORM_WIN32_NT ' Windows NT/2000/XP
      234. Select Case OSVI.dwMajorVersion
      235. Case 3
      236. GetWindowsVersion = "Windows NT 3." & CStr(OSVI.dwMinorVersion)
      237. Case 4
      238. GetWindowsVersion = "Windows NT 4.0"
      239. Case 5
      240. Select Case OSVI.dwMinorVersion
      241. Case 0
      242. GetWindowsVersion = "Windows 2000"
      243. Case 1
      244. GetWindowsVersion = "Windows XP"
      245. Case 2
      246. GetWindowsVersion = "Windows XP / Server 2003"
      247. End Select
      248. Case 6
      249. Select Case OSVI.dwMinorVersion
      250. Case 0
      251. GetWindowsVersion = "Windows Vista / Server 2008"
      252. Case 1
      253. GetWindowsVersion = "Windows 7"
      254. Case Else ' zukünftige Versionen von Windows 7
      255. GetWindowsVersion = "Windows 7 / Folgeversion"
      256. End Select
      257. Case Else ' zukünftige Versionen von Windows 7
      258. GetWindowsVersion = "Windows 7 / Folgeversion"
      259. End Select
      260. End Select
      261. Platform = OSVI.dwPlatformId
      262. Major = OSVI.dwMajorVersion
      263. Minor = OSVI.dwMinorVersion
      264. End Function
      265. '--------- Ende Modul "GetWinVers" alias GetWinVers.bas ---------
      266. '-------------- Ende Projektdatei Project1.vbp --------------

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „volkeru“ ()

      volkeru schrieb:

      Dieses Programm muss nur einmal aufgerufen werden und nimmt die lokale Registrierung der nötigen Komponenten vor. Danach kann das eigentliche Programm immer wieder direkt gestartet werden.
      Ich denke mal, dies ist nur dann richtig, solange sich kein anderer User unter seinem Account einloggt, denn der Part HKEY_CURRENT_USER wird jedes Mal vom System, so erforderlich, aus dem Bereich HKEY_USERS nach HKEY_CURRENT_USER kopiert.
      Dahingehend ist es sicherer, den Registrierungspart jedes mal mit aufzurufen, zumal dies keine Performance kostet.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

    Facebook
    Telefonspende