Fråga : Räddningen bearbetar med maskin och användarekonton i Windows 2008 SBS

Vi gjorde ursprungligen en uppdatering av Windows 2003 SBS med Windows 2008 SBS. Nu vi har arga anknöt arkiv, och en myriad av andra problem några av dem som orsakas av olikt avlägset folk för en techservice som ändrar tillåtelser Etc. som, vi går att göra en rengöring, installerar today av 2008 SBS. Jag har hem- arbetare som har sammanfogat området, och jag undrade, om det finns a långt till sylten deras användare och bearbetar med maskin konton, så jag kan lägga tillbaka dem som är mer sistnämnd, när det nya OSet installeras. Jag skulle också något liknande för att lägga tillbaka deras utbytese-post, och släkt info har de lagrat. Kan detta göras? Är också det bäst långt som återinstallerar vår SQL-databas 2005 som avriver det, och de re-attach det, när vi får SQL 2008 installerad på den nya SBS2008EN installerar?
Thanks
" klar "

Svar : Räddningen bearbetar med maskin och användarekonton i Windows 2008 SBS

Hälsningar,

Jag hade detta problem för…, så med några ändringar och att använda another långt för att ta fram den Windows registreringen (inte using Registry.pas) har jag gjort med inga problem…,

Den nedanföra kodifiera är ett litghtweightutbyte för Registry.pas med ändringar till arbete med KEY_WOW64_64KEY/KEY_WOW64_32KEY sjunker

Grundläggande bruk i ditt fall

Inställning - upp ditt program som Shell
[kodifiera], WinRegSetString (HKEY_LOCAL_MACHINE, ”PROGRAMVARA \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, ”YourProgram.exe”, True); [/code]

om du satte ”en Blackslash” på den nyckel- något liknande (”PROGRAMVARA \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \”) den ska skapar en nya ”nyckel-” kallade Shell… med ingen blackslash som den ska tar fram en värdera som kallades Shell,… alla samma för fungerar

Gå tillbaka till Windows Shell
[kodifiera], WinRegSetString (HKEY_LOCAL_MACHINE, ”PROGRAMVARA \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, ”Explorer.exe”, True); [/code]

Läsning som strömmen beskjuter
[kodifiera], var
szBuff: Stränga;
börja
WinRegGetString (HKEY_LOCAL_MACHINE, ”PROGRAMVARA \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, szBuff, True);
ShowMessage (””” + szBuff + ”””); [/code]

Hopp det hjälp dig!
Hälsningar,
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:
36:
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:

           
           
             enhet UTILS_Reg;

ha kontakt

bruk
  Windows,
  SysUtils,
  Klassificerar;

  fungera WinRegConnect (MachineName: Stränga; RootKey: HKEY; var RemoteKey: HKEY): boolean;
  fungera WinRegDisconnect (RemoteKey: HKEY): boolean;
  fungera WinRegValueExists (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
  fungera WinRegGetValueType (RootKey: HKEY; Namnge: Stränga; var värderar: Kardinal; Wow64: Boolean): boolean;
  fungera WinRegKeyExists (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
  fungera WinRegDelValue (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
  fungera WinRegDelKey (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
  fungera WinRegEnum (hRootKey: HKEY; szKey: Stränga; Fungera som buffert: TStringList; bKeys: Boolean; Wow64: Boolean): Boolean;
  fungera WinRegSetString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
  fungera WinRegSetMultiString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
  fungera WinRegSetExpandString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
  fungera WinRegSetDword (RootKey: HKEY; Namnge: Stränga; Värdera: Kardinal; Wow64: Boolean): boolean;
  fungera WinRegSetBinary (RootKey: HKEY; Namnge: Stränga; Värdera: Samling av byten; Wow64: Boolean): boolean;
  fungera WinRegGetString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
  fungera WinRegGetMultiString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
  fungera WinRegGetExpandString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
  fungera WinRegGetDWORD (RootKey: HKEY; Namnge: Stränga; Var värderar: Kardinal; Wow64: Boolean): boolean;
  fungera WinRegGetBinary (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
  fungera Binary2DateTime (RootKey: HKEY; Namnge: Stränga; var värderar: TDateTime; Wow64: Boolean): Boolean;
  fungera DateTime2Binary (RootKey: HKEY; Namnge: Stränga; var värderar: TDateTime; Wow64: Boolean): Boolean;
  fungera Binary2Integer (RootKey: HKEY; Namnge: Stränga; var värderar: Heltal; Wow64: Boolean): Boolean;
  fungera Integer2Binary (RootKey: HKEY; Namnge: Stränga; var värderar: Heltal; Wow64: Boolean): Boolean;

genomförande

fungera IsWow64: Boolean;
typ
  TIsWow64Process = fungerar (// typ av IsWow64Process API fn
    Handtag: Windows.THandle; var Res: Windows.BOOL
  ): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      // resultat från IsWow64Process
  IsWow64Process: TIsWow64Process;  // IsWow64Process fn hänvisar till
börja
  Det // försök att ladda required fungerar från kernel32
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle (”kernel32.dll”), ”IsWow64Process”,
  );
  om tilldelat (IsWow64Process) därefter
  börja
    // fungerar genomföras: appell det
    om inte IsWow64Process (
      Windows.GetCurrentProcess IsWow64Result
    ) därefter
      lönelyft SysUtils.Exception.Create (”IsWow64: processaa handtag för dåliga”);
    // det återgång resultatet av fungerar
    Resultat: = IsWow64Result;
  avsluta
  annars
    // fungerar inte genomfört: kan inte vara rinnande på Wow64
    Resultat: = falskt;
avsluta;

fungera Binary2DateTime (RootKey: HKEY; Namnge: Stränga; var värderar: TDateTime; Wow64: Boolean): Boolean;
var
  dtBuff: TDateTime;
  dtBytes: samling [1..8] av byteevig sanningdtBuff;
  szBin: stränga;
  i: heltal;
börja
  Resultat: = WinRegGetBinary (RootKey, känt, szBin, Wow64);

  om resultat därefter
  Resultat: = längd (szBin) = 8;

  om resultat därefter
  börja
    för I: = 1 till 8 gör
    dtBytes [I]: = ord (szBin [I]);
    Värdera: = dtBuff;
  avsluta;
avsluta;

fungera DateTime2Binary (RootKey: HKEY; Namnge: Stränga; var värderar: TDateTime; Wow64: Boolean): Boolean;
var
  dtBuff: TDateTime;
  dtBytes: samling [1..8] av byteevig sanningdtBuff;
börja
  dtBuff: = värdera;
  Resultat: = WinRegSetBinary (RootKey, känt, dtBytes, Wow64);
avsluta;

fungera Binary2Integer (RootKey: HKEY; Namnge: Stränga; var värderar: Heltal; Wow64: Boolean): Boolean;
var
  iBuff: Heltal;
  dtBytes: samling [1..4] av byteevig sanningiBuff;
  szBin: stränga;
  i: heltal;
börja
  Resultat: = WinRegGetBinary (RootKey, känt, szBin, Wow64);

  om resultat därefter
  Resultat: = längd (szBin) = 4;

  om resultat därefter
  börja
    för I: = 1 till 4 gör
    dtBytes [I]: = ord (szBin [I]);
    Värdera: = iBuff;
  avsluta;
avsluta;

fungera Integer2Binary (RootKey: HKEY; Namnge: Stränga; var värderar: Heltal; Wow64: Boolean): Boolean;
var
  iBuff: Heltal;
  dtBytes: samling [1..4] av byteevig sanningiBuff;
börja
  iBuff: = värdera;
  Resultat: = WinRegSetBinary (RootKey, känt, dtBytes, Wow64);
avsluta;

fungera LastPos (visare: Röding; Höstack: Stränga): heltal;
börja
  för resultat: = downto 1 för längden (höstack) gör
  om höstack [resultat] = visare därefter
  Avbrott;
avsluta;

fungera WinRegConnect (MachineName: Stränga; RootKey: HKEY; var RemoteKey: HKEY): boolean;
börja
  Resultat: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
avsluta;

fungera WinRegDisconnect (RemoteKey: HKEY): boolean;
börja
  Resultat: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
avsluta;

fungera RegSetValue (RootKey: HKEY; Namnge: Stränga; ValType: Kardinal; PVal: Pekare; ValSize: Kardinal; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Boolean;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_32KEY annars
    _hKey: = KEY_WRITE;

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

    om bSuccess därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      Resultat: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera RegGetValue (RootKey: HKEY; Namnge: Stränga; ValType: Kardinal; var PVal: Pekare;
  var ValSize: Kardinal; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Pekare;
  BufSize: Kardinal;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_32KEY annars
    _hKey: = KEY_READ;

    om RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      om RegQueryValueEx (hTemp, PChar (SubKey), noll, @MyValType, noll, @BufSize), = ERROR_SUCCESS därefter
      börja
        GetMem (Buf, BufSize);
        om RegQueryValueEx (hTemp, PChar (SubKey), noll, @MyValType, Buf, @BufSize), = ERROR_SUCCESS därefter
        börja
          om ValType = MyValType därefter
          börja
            PVal: = Buf;
            ValSize: = BufSize;
            Resultat: = True;
          avsluta
          annars
          FreeMem (Buf);
        avsluta
        annars
        FreeMem (Buf);
      avsluta;
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegValueExists (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  hTemp: HKEY;
  _hKey: THandle;
börja
  Resultat: = falskt;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_32KEY annars
    _hKey: = KEY_READ;

    om RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      Resultat: = (RegQueryValueEx (hTemp, PChar (SubKey), noll, noll, noll, noll) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegGetValueType (RootKey: HKEY; Namnge: Stränga; var värderar: Kardinal; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  hTemp: HKEY;
  ValType: Kardinal;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  Värdera: = REG_NONE;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_32KEY annars
    _hKey: = KEY_READ;

    om (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      Resultat: = (RegQueryValueEx (hTemp, PChar (SubKey), noll, @ValType, noll, noll) = ERROR_SUCCESS);
      om resultat därefter
      Värdera: = ValType;
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegKeyExists (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  hTemp: HKEY;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_READ eller KEY_WOW64_32KEY annars
    _hKey: = KEY_READ;

    om RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
    börja
      Resultat: = True;
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegDelValue (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  hTemp: HKEY;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_32KEY annars
    _hKey: = KEY_WRITE;

    om RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      Resultat: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegDelKey (RootKey: HKEY; Namnge: Stränga; Wow64: Boolean): boolean;
var
  SubKey: Stränga;
  n: heltal;
  hTemp: HKEY;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  n: = LastPos (”\”, namnger);
  om n > 0 därefter
  börja
    SubKey: = kopiera (namnge, 1, n - 1);

    om Wow64 och IsWow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_64KEY annars
    om IsWow64 och inte Wow64 därefter
    _hKey: = KEY_WRITE eller KEY_WOW64_32KEY annars
    _hKey: = KEY_WRITE;

    om RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
    börja
      SubKey: = kopiera (känt, n + 1, längd (namnge) - n);
      Resultat: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    avsluta;
  avsluta;
avsluta;

fungera WinRegEnum (hRootKey: HKEY; szKey: Stränga; Fungera som buffert: TStringList; bKeys: Boolean; Wow64: Boolean): Boolean;
var
  i: heltal;
  iRes: heltal;
  s: Stränga;
  hTemp: HKEY;
  Buf: Pekare;
  BufSize: Kardinal;
  _hKey: Kardinal;
börja
  Resultat: = falskt;
  Buffer.Clear;

  om Wow64 och IsWow64 därefter
  _hKey: = KEY_READ eller KEY_WOW64_64KEY annars
  om IsWow64 och inte Wow64 därefter
  _hKey: = KEY_READ eller KEY_WOW64_32KEY annars
  _hKey: = KEY_READ;

  om RegOpenKeyEx (hRootKeyen, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS därefter
  börja
    Resultat: = True;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    i: = 0;
    iRes: = ERROR_SUCCESS;
    stundiRes = ERROR_SUCCESS gör
    börja
      BufSize: = 1024;
      om bKeys därefter
        iRes: = RegEnumKeyEx (hTemp, I, buf, BufSize, noll, noll, noll, noll)
      annars
        iRes: = RegEnumValue (hTemp, I, buf, BufSize, noll, noll, noll, noll);
      om iRes = ERROR_SUCCESS därefter
      börja
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        inc (I);
      avsluta;
    avsluta;
    FreeMem (buf);
    RegCloseKey (hTemp);
  avsluta;
avsluta;

fungera WinRegSetString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
börja
  Resultat: = RegSetValue (RootKey, känt, REG_SZ, PChar (värdera + #0), längd (värdera), + 1, Wow64);
avsluta;

fungera WinRegSetMultiString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
börja
  Resultat: = RegSetValue (RootKey, känt, REG_MULTI_SZ, PChar (värdera + #0#0), längd (värdera), + 2, Wow64);
avsluta;

fungera WinRegSetExpandString (RootKey: HKEY; Namnge: Stränga; Värdera: Stränga; Wow64: Boolean): boolean;
börja
  Resultat: = RegSetValue (RootKey, känt, REG_EXPAND_SZ, PChar (värdera + #0), längd (värdera), + 1, Wow64);
avsluta;

fungera WinRegSetDword (RootKey: HKEY; Namnge: Stränga; Värdera: Kardinal; Wow64: Boolean): boolean;
börja
  Resultat: = RegSetValue (RootKey, känt, REG_DWORD, @Value, SizeOf (kardinalen), Wow64);
avsluta;

fungera WinRegSetBinary (RootKey: HKEY; Namnge: Stränga; Värdera: Samling av byten; Wow64: Boolean): boolean;
börja
  Resultat: = RegSetValue (RootKey, känt, REG_BINARY, @Value, SizeOf (värdera), Wow64);
avsluta;

fungera WinRegGetString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
var
  Buf: Pekare;
  BufSize: Kardinal;
börja
  Resultat: = falskt;
  om RegGetValue (RootKey, känt, REG_SZ, Buf, BufSize, Wow64) därefter
  börja
    December (BufSize);
    SetLength (värdera, BufSize);
    om BufSize > 0 därefter
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = True;
  avsluta;
avsluta;

fungera WinRegGetMultiString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
var
  Buf: Pekare;
  BufSize: Kardinal;
börja
  Resultat: = falskt;
  om RegGetValue (RootKey, känt, REG_MULTI_SZ, Buf, BufSize, Wow64) därefter
  börja
    December (BufSize);
    SetLength (värdera, BufSize);
    om BufSize > 0 därefter
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = True;
  avsluta;
avsluta;

fungera WinRegGetExpandString (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
var
  Buf: Pekare;
  BufSize: Kardinal;
börja
  Resultat: = falskt;
  om RegGetValue (RootKey, känt, REG_EXPAND_SZ, Buf, BufSize, Wow64) därefter
  börja
    December (BufSize);
    SetLength (värdera, BufSize);
    om BufSize > 0 därefter
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = True;
  avsluta;
avsluta;

fungera WinRegGetDWORD (RootKey: HKEY; Namnge: Stränga; Var värderar: Kardinal; Wow64: Boolean): boolean;
var
  Buf: Pekare;
  BufSize: Kardinal;
börja
  Resultat: = falskt;
  om RegGetValue (RootKey, känt, REG_DWORD, Buf, BufSize, Wow64) därefter
  börja
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Resultat: = True;
  avsluta;
avsluta;

fungera WinRegGetBinary (RootKey: HKEY; Namnge: Stränga; Var värderar: Stränga; Wow64: Boolean): boolean;
var
  Buf: Pekare;
  BufSize: Kardinal;
börja
  Resultat: = falskt;
  om RegGetValue (RootKey, känt, REG_BINARY, Buf, BufSize, Wow64) därefter
  börja
    SetLength (värdera, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultat: = True;
  avsluta;
avsluta;

avsluta.

           
         

Andra lösningar

Hur många skrivar av sidor r där i SQL-server?

OMA och OWA

Missa över mellan GLÅMIGA anslutningar för aktiv/för aktiv på en Cisco Router

ASP.Net tappar skuggar verkställer

Vad är ämna av ”den MAKEFILE” makroen i en makefile?

Ett rengöringsdukundantag uppstod därför att en HTTP 401 - det obehöriga svaret mottogs från okända

Funktionen måste använda en Updateable Query

PHP passerar parametrar till den on-line aktiveringssidan

Ethernetövergångskabel förbinder

döda ett processaa vid styrka, hur kan jag