Frage : Maschinen-und Benutzer-Konten in Windows speichern 2008 SBS

Wir taten ursprünglich ein Update von Windows 2003 SBS mit Windows 2008 SBS. Jetzt haben wir Kreuz verbundene Verzeichnisse und eine Myriade anderer Probleme einige von ihnen verursachte durch ändernde Erlaubnis etc. verschiedenen FernTechnologiestützvölker. Wir werden ein sauberes tun, heutigen Tag von 2008 SBS anzubringen. Ich habe Hauptarbeitskräfte, die sich dem Gebiet angeschlossen haben und ich mich wunderte, wenn es eine Weise gibt, ihre Benutzer- und Maschinenkonten zu konservieren, also ich sie später neu laden kann, wenn das neue OS angebracht ist. Ich möchte auch ihre Austausch-eMail neu laden und in Verbindung stehendes Info, das sie gespeichert haben. Kann dieses getan werden? Ist auch die beste Weise, unsere SQL-Datenbank 2005 wieder zu installieren, zum es abzutrennen und sie befestigen es wieder, wenn wir SQL 2008 angebracht auf das frische SBS2008 anbringen erhalten?
Thanks

Antwort : Maschinen-und Benutzer-Konten in Windows speichern 2008 SBS

Hallo,

Ich hatte dieses Problem auch…, also mit etwas Änderungen und der Anwendung einer anderen Weise, auf das Windows-Register zurückzugreifen (nicht using Registry.pas) getan ich ohne Probleme…

Der folgende Code ist ein litghtweight Wiedereinbau für Registry.pas mit Änderungen an der Arbeit mit KEY_WOW64_64KEY/KEY_WOW64_32KEY Markierungsfahnen

Grundlegender Gebrauch in Ihrem Fall

Gründen Ihres Programms als Shell
[Code] WinRegSetString (HKEY_LOCAL_MACHINE, „SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell“, „YourProgram.exe“, ausrichten); [/code]

wenn Sie ein „Blackslash“ am Schlüssel wie setzen („SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") verursacht es einen neuen „Schlüssel“ angerufenes Shell… ohne blackslash, das er auf einen Wert zurückgreift, der Shell… die selben für alle Funktionen angerufen

Zu Windows Shell zurückgehen
[Code] WinRegSetString (HKEY_LOCAL_MACHINE, „SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell“, „Explorer.exe“, ausrichten); [/code]

Ablesen des gegenwärtigen Oberteils
[Code] var
szBuff: Schnur;
anfangen
WinRegGetString (HKEY_LOCAL_MACHINE, „SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell“, szBuff, ausrichten);
ShowMessage („„“ + szBuff + „„"); [/code]

Hoffnung es Hilfe Sie!
Respekt,
Carlos

                       
         
           
             1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
6:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:

           
           
             Maßeinheit UTILS_Reg;

Schnittstelle

Gebrauch
  Windows,
  SysUtils,
  Kategorien;

  Funktion WinRegConnect (MachineName: Schnur; RootKey: HKEY; var RemoteKey: HKEY): Boolesch;
  Funktion WinRegDisconnect (RemoteKey: HKEY): Boolesch;
  Funktion WinRegValueExists (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetValueType (RootKey: HKEY; Name: Schnur; var-Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
  Funktion WinRegKeyExists (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegDelValue (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegDelKey (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegEnum (hRootKey: HKEY; szKey: Schnur; Puffer: TStringList; bKeys: Boolesch; Wow64: Boolesch): Boolesch;
  Funktion WinRegSetString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegSetMultiString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegSetExpandString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegSetDword (RootKey: HKEY; Name: Schnur; Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
  Funktion WinRegSetBinary (RootKey: HKEY; Name: Schnur; Wert: Reihe des Bytes; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetMultiString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetExpandString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetDWORD (RootKey: HKEY; Name: Schnur; Var-Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
  Funktion WinRegGetBinary (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
  Funktion Binary2DateTime (RootKey: HKEY; Name: Schnur; var-Wert: TDateTime; Wow64: Boolesch): Boolesch;
  Funktion DateTime2Binary (RootKey: HKEY; Name: Schnur; var-Wert: TDateTime; Wow64: Boolesch): Boolesch;
  Funktion Binary2Integer (RootKey: HKEY; Name: Schnur; var-Wert: Ganze Zahl; Wow64: Boolesch): Boolesch;
  Funktion Integer2Binary (RootKey: HKEY; Name: Schnur; var-Wert: Ganze Zahl; Wow64: Boolesch): Boolesch;

Implementierung

Funktion IsWow64: Boolesch;
Art
  TIsWow64Process = Funktion (//-Art von IsWow64Process API F-N
    Handgriff: Windows.THandle; var Res: Windows.BOOL
  ): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      //-Resultat von IsWow64Process
  IsWow64Process: TIsWow64Process;  Hinweis //-IsWow64Process F-N
anfangen
  //-Versuch, zum der erforderlichen Funktion von kernel32 zu laden
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle („kernel32.dll "), „IsWow64Process“
  );
  wenn Sie dann (IsWow64Process) zugewiesen
  anfangen
    //-Funktion eingeführt rt: sie benennen
    wenn nicht IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) dann
      Erhöhung SysUtils.Exception.Create („IsWow64: schlechter Prozesshandgriff ");
    //-Rückholresultat der Funktion
    Resultat: = IsWow64Result;
  Ende
  sonst
    //-Funktion nicht eingeführt: kann nicht auf Wow64 laufen
    Resultat: = falsch;
Ende;

Funktion Binary2DateTime (RootKey: HKEY; Name: Schnur; var-Wert: TDateTime; Wow64: Boolesch): Boolesch;
var
  dtBuff: TDateTime;
  dtBytes: Reihe [1..8] Byteabsolutes dtBuff;
  szBin: Schnur;
  I: ganze Zahl;
anfangen
  Resultat: = WinRegGetBinary (RootKey, Name, szBin, Wow64);

  wenn Resultat dann
  Resultat: = Länge (szBin) = 8;

  wenn Resultat dann
  anfangen
    für i: = tun 1 bis 8
    dtBytes [i]: = ord (szBin [i]);
    Wert: = dtBuff;
  Ende;
Ende;

Funktion DateTime2Binary (RootKey: HKEY; Name: Schnur; var-Wert: TDateTime; Wow64: Boolesch): Boolesch;
var
  dtBuff: TDateTime;
  dtBytes: Reihe [1..8] Byteabsolutes dtBuff;
anfangen
  dtBuff: = Wert;
  Resultat: = WinRegSetBinary (RootKey, Name, dtBytes, Wow64);
Ende;

Funktion Binary2Integer (RootKey: HKEY; Name: Schnur; var-Wert: Ganze Zahl; Wow64: Boolesch): Boolesch;
var
  iBuff: Ganze Zahl;
  dtBytes: Reihe [1..4] Byteabsolutes iBuff;
  szBin: Schnur;
  I: ganze Zahl;
anfangen
  Resultat: = WinRegGetBinary (RootKey, Name, szBin, Wow64);

  wenn Resultat dann
  Resultat: = Länge (szBin) = 4;

  wenn Resultat dann
  anfangen
    für i: = tun 1 bis 4
    dtBytes [i]: = ord (szBin [i]);
    Wert: = iBuff;
  Ende;
Ende;

Funktion Integer2Binary (RootKey: HKEY; Name: Schnur; var-Wert: Ganze Zahl; Wow64: Boolesch): Boolesch;
var
  iBuff: Ganze Zahl;
  dtBytes: Reihe [1..4] Byteabsolutes iBuff;
anfangen
  iBuff: = Wert;
  Resultat: = WinRegSetBinary (RootKey, Name, dtBytes, Wow64);
Ende;

Funktion LastPos (Nadel: Putzfrau; Heuschober: Schnur): ganze Zahl;
anfangen
  für Resultat: = Länge (Heuschober) tun downto 1
  wenn Heuschober [Resultat] = Nadel dann
  Bruch;
Ende;

Funktion WinRegConnect (MachineName: Schnur; RootKey: HKEY; var RemoteKey: HKEY): Boolesch;
anfangen
  Resultat: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
Ende;

Funktion WinRegDisconnect (RemoteKey: HKEY): Boolesch;
anfangen
  Resultat: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
Ende;

Funktion RegSetValue (RootKey: HKEY; Name: Schnur; ValType: Hauptsächlich; PVal: Zeiger; ValSize: Hauptsächlich; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Boolesch;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_WRITE;

    bSuccess: = RegCreateKeyEx (RootKey, PChar (SubKey), 0, Null, REG_OPTION_NON_VOLATILE, _hKey, Null, hTemp, @dispo) = ERROR_SUCCESS;

    wenn bSuccess dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      Resultat: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion RegGetValue (RootKey: HKEY; Name: Schnur; ValType: Hauptsächlich; var PVal: Zeiger;
  var ValSize: Hauptsächlich; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Zeiger;
  BufSize: Hauptsächlich;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_READ;

    wenn RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      wenn RegQueryValueEx (hTemp, PChar (SubKey), Null, @MyValType, Null, @BufSize), = ERROR_SUCCESS dann
      anfangen
        GetMem (Buf, BufSize);
        wenn RegQueryValueEx (hTemp, PChar (SubKey), Null, @MyValType, Buf, @BufSize), = ERROR_SUCCESS dann
        anfangen
          wenn ValType = MyValType dann
          anfangen
            PVal: = Buf;
            ValSize: = BufSize;
            Resultat: = ausrichten;
          Ende
          sonst
          FreeMem (Buf);
        Ende
        sonst
        FreeMem (Buf);
      Ende;
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegValueExists (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  hTemp: HKEY;
  _hKey: Quergriff;
anfangen
  Resultat: = falsch;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_READ;

    wenn RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      Resultat: = (RegQueryValueEx (hTemp, PChar (SubKey), Null, Null, Null, Null) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegGetValueType (RootKey: HKEY; Name: Schnur; var-Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  hTemp: HKEY;
  ValType: Hauptsächlich;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  Wert: = REG_NONE;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_READ;

    wenn (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      Resultat: = (RegQueryValueEx (hTemp, PChar (SubKey), Null, @ValType, Null, Null) = ERROR_SUCCESS);
      wenn Resultat dann
      Wert: = ValType;
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegKeyExists (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  hTemp: HKEY;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_READ oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_READ;

    wenn RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
    anfangen
      Resultat: = ausrichten;
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegDelValue (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  hTemp: HKEY;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_WRITE;

    wenn RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      Resultat: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegDelKey (RootKey: HKEY; Name: Schnur; Wow64: Boolesch): Boolesch;
var
  SubKey: Schnur;
  n: ganze Zahl;
  hTemp: HKEY;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  n: = LastPos („\“, Name);
  wenn n > 0 dann
  anfangen
    SubKey: = Kopie (Name, 1, n - 1);

    wenn Wow64 und IsWow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_64KEY sonst
    wenn IsWow64 und nicht Wow64 dann
    _hKey: = KEY_WRITE oder KEY_WOW64_32KEY sonst
    _hKey: = KEY_WRITE;

    wenn RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
    anfangen
      SubKey: = Kopie (Name, n + 1, Länge (Name) - N);
      Resultat: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    Ende;
  Ende;
Ende;

Funktion WinRegEnum (hRootKey: HKEY; szKey: Schnur; Puffer: TStringList; bKeys: Boolesch; Wow64: Boolesch): Boolesch;
var
  I: ganze Zahl;
  Zorn: ganze Zahl;
  s: Schnur;
  hTemp: HKEY;
  Buf: Zeiger;
  BufSize: Hauptsächlich;
  _hKey: Hauptsächlich;
anfangen
  Resultat: = falsch;
  Buffer.Clear;

  wenn Wow64 und IsWow64 dann
  _hKey: = KEY_READ oder KEY_WOW64_64KEY sonst
  wenn IsWow64 und nicht Wow64 dann
  _hKey: = KEY_READ oder KEY_WOW64_32KEY sonst
  _hKey: = KEY_READ;

  wenn RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS dann
  anfangen
    Resultat: = ausrichten;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    I: = 0;
    Zorn: = ERROR_SUCCESS;
    während Zorn = ERROR_SUCCESS tun
    anfangen
      BufSize: = 1024;
      wenn bKeys dann
        Zorn: = RegEnumKeyEx (hTemp, i, buf, BufSize, Null, Null, Null, Null)
      sonst
        Zorn: = RegEnumValue (hTemp, i, buf, BufSize, Null, Null, Null, Null);
      wenn Zorn = ERROR_SUCCESS dann
      anfangen
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        Inc. (i);
      Ende;
    Ende;
    FreeMem (buf);
    RegCloseKey (hTemp);
  Ende;
Ende;

Funktion WinRegSetString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
anfangen
  Resultat: = RegSetValue (RootKey, Name, REG_SZ, PChar (Wert + #0), Länge (Wert) + 1, Wow64);
Ende;

Funktion WinRegSetMultiString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
anfangen
  Resultat: = RegSetValue (RootKey, Name, REG_MULTI_SZ, PChar (Wert + #0#0), Länge (Wert) + 2, Wow64);
Ende;

Funktion WinRegSetExpandString (RootKey: HKEY; Name: Schnur; Wert: Schnur; Wow64: Boolesch): Boolesch;
anfangen
  Resultat: = RegSetValue (RootKey, Name, REG_EXPAND_SZ, PChar (Wert + #0), Länge (Wert) + 1, Wow64);
Ende;

Funktion WinRegSetDword (RootKey: HKEY; Name: Schnur; Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
anfangen
  Resultat: = RegSetValue (RootKey, Name, REG_DWORD, @Value, SizeOf (hauptsächlich), Wow64);
Ende;

Funktion WinRegSetBinary (RootKey: HKEY; Name: Schnur; Wert: Reihe des Bytes; Wow64: Boolesch): Boolesch;
anfangen
  Resultat: = RegSetValue (RootKey, Name, REG_BINARY, @Value, SizeOf (Wert), Wow64);
Ende;

Funktion WinRegGetString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
var
  Buf: Zeiger;
  BufSize: Hauptsächlich;
anfangen
  Resultat: = falsch;
  wenn RegGetValue (RootKey, Name, REG_SZ, Buf, BufSize, Wow64) dann
  anfangen
    Dezember (BufSize);
    SetLength (Wert, BufSize);
    wenn BufSize > 0 dann
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = ausrichten;
  Ende;
Ende;

Funktion WinRegGetMultiString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
var
  Buf: Zeiger;
  BufSize: Hauptsächlich;
anfangen
  Resultat: = falsch;
  wenn RegGetValue (RootKey, Name, REG_MULTI_SZ, Buf, BufSize, Wow64) dann
  anfangen
    Dezember (BufSize);
    SetLength (Wert, BufSize);
    wenn BufSize > 0 dann
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = ausrichten;
  Ende;
Ende;

Funktion WinRegGetExpandString (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
var
  Buf: Zeiger;
  BufSize: Hauptsächlich;
anfangen
  Resultat: = falsch;
  wenn RegGetValue (RootKey, Name, REG_EXPAND_SZ, Buf, BufSize, Wow64) dann
  anfangen
    Dezember (BufSize);
    SetLength (Wert, BufSize);
    wenn BufSize > 0 dann
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = ausrichten;
  Ende;
Ende;

Funktion WinRegGetDWORD (RootKey: HKEY; Name: Schnur; Var-Wert: Hauptsächlich; Wow64: Boolesch): Boolesch;
var
  Buf: Zeiger;
  BufSize: Hauptsächlich;
anfangen
  Resultat: = falsch;
  wenn RegGetValue (RootKey, Name, REG_DWORD, Buf, BufSize, Wow64) dann
  anfangen
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Resultat: = ausrichten;
  Ende;
Ende;

Funktion WinRegGetBinary (RootKey: HKEY; Name: Schnur; Var-Wert: Schnur; Wow64: Boolesch): Boolesch;
var
  Buf: Zeiger;
  BufSize: Hauptsächlich;
anfangen
  Resultat: = falsch;
  wenn RegGetValue (RootKey, Name, REG_BINARY, Buf, BufSize, Wow64) dann
  anfangen
    SetLength (Wert, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = ausrichten;
  Ende;
Ende;

Ende.

           
         

Weitere Lösungen

Wort-Presse, die Frage bewirtet

asp.net: Mein Problem ist, benutze ich einen ajax Ergänzung Kalender, um BeginDate u. EndDate Werte einzutragen

Silverlight 4 UI Ereignisse

wie kann ich irgendeine Bildentschließung online ändern und sie zum lokalen PC dann innen sparen??

ZFS Sicherungshilfe Ubuntu 10.0.4 LTS

Form-Frage für Kristallreports

Betreffend INOTES in Lotos 8.5

Mühen, die ZWISCHEN Logik erhalten zu arbeiten

Spannungs-Sensor ermittelte einen Ausfall auf Bediener DELL-PowerEdge 2650

broadcom NIC teaming