Questione : Nuovo utente della posta che non rivela in gallone.

Assomiglia all'ANNUNCIO non è di destra. Una CC che alloggia il catalogo globale non vede gli altri due nella replica del luogo. Stavo pensando a retrocedere quella CC, ma temo il rischio di perdita del network. class= del

Risposta : Nuovo utente della posta che non rivela in gallone.

Ciao,

Ho avuto questo problema ugualmente… in modo da con alcune modifiche ed usando un altro senso accedere alla registrazione di Windows (non using Registry.pas) ho fatto senza i problemi…

Il codice sotto è un rimontaggio del litghtweight per Registry.pas con le modifiche a lavoro con le bandierine di KEY_WOW64_64KEY/KEY_WOW64_32KEY

Uso di base nel vostro caso

Installazione del vostro programma come Shell
[codice] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell„, “YourProgram.exe„, allineano); [/code]

se mettete “un Blackslash„ alla chiave come (“SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") genererà una nuova “chiave„ Shell denominato… senza blackslash che accederà ad un valore denominato Shell… lo stessi per tutte le funzioni

Rinviare a Windows Shell
[codice] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell„, “Explorer.exe„, allineano); [/code]

Lettura delle coperture correnti
[codice] varietà
 szBuff: Stringa;
cominciare
 WinRegGetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell„, szBuff, allineano);
  ShowMessage (““„ + szBuff + ““"); [/code]

Speranza esso aiuto voi!
Riguardi,
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:

unità UTILS_Reg;

interfaccia

usi
  Windows,
  SysUtils,
  Codici categoria;

  funzione WinRegConnect (MachineName: Stringa; RootKey: HKEY; varietà RemoteKey: HKEY): booleano;
  funzione WinRegDisconnect (RemoteKey: HKEY): booleano;
  funzione WinRegValueExists (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
  funzione WinRegGetValueType (RootKey: HKEY; Nome: Stringa; valore di varietà: Cardinale; Wow64: Booleano): booleano;
  funzione WinRegKeyExists (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
  funzione WinRegDelValue (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
  funzione WinRegDelKey (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
  funzione WinRegEnum (hRootKey: HKEY; szKey: Stringa; Amplificatore: TStringList; bKeys: Booleano; Wow64: Booleano): Booleano;
  funzione WinRegSetString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
  funzione WinRegSetMultiString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
  funzione WinRegSetExpandString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
  funzione WinRegSetDword (RootKey: HKEY; Nome: Stringa; Valore: Cardinale; Wow64: Booleano): booleano;
  funzione WinRegSetBinary (RootKey: HKEY; Nome: Stringa; Valore: Allineamento del byte; Wow64: Booleano): booleano;
  funzione WinRegGetString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
  funzione WinRegGetMultiString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
  funzione WinRegGetExpandString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
  funzione WinRegGetDWORD (RootKey: HKEY; Nome: Stringa; Valore di varietà: Cardinale; Wow64: Booleano): booleano;
  funzione WinRegGetBinary (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
  funzione Binary2DateTime (RootKey: HKEY; Nome: Stringa; valore di varietà: TDateTime; Wow64: Booleano): Booleano;
  funzione DateTime2Binary (RootKey: HKEY; Nome: Stringa; valore di varietà: TDateTime; Wow64: Booleano): Booleano;
  funzione Binary2Integer (RootKey: HKEY; Nome: Stringa; valore di varietà: Numero intero; Wow64: Booleano): Booleano;
  funzione Integer2Binary (RootKey: HKEY; Nome: Stringa; valore di varietà: Numero intero; Wow64: Booleano): Booleano;

esecuzione

funzione IsWow64: Booleano;
tipo
  TIsWow64Process = funzione (tipo di // di IsWow64Process api F-N
    Maniglia: Windows.THandle; ricerca di varietà: Windows.BOOL
  ): Windows.BOOL; stdcall;
varietà
  IsWow64Result: Windows.BOOL;      Risultato di // da IsWow64Process
  IsWow64Process: TIsWow64Process;  Riferimento di // IsWow64Process F-N
cominciare
  Prova di // per caricare funzione required da kernel32
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle (“kernel32.dll "), “IsWow64Process„
  );
  se allora assegnato (IsWow64Process)
  cominciare
    La funzione di // è realizzata: denominarla
    se non IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) allora
      aumento SysUtils.Exception.Create (“IsWow64: maniglia trattata difettosa ");
    Risultato di ritorno di // della funzione
    Risultato: = IsWow64Result;
  estremità
  altrimenti
    Funzione di // d'applicazione: non può funzionare su Wow64
    Risultato: = falso;
estremità;

funzione Binary2DateTime (RootKey: HKEY; Nome: Stringa; valore di varietà: TDateTime; Wow64: Booleano): Booleano;
varietà
  dtBuff: TDateTime;
  dtBytes: allineamento [1..8] del dtBuff di assoluto di byte;
  szBin: stringa;
  i: numero intero;
cominciare
  Risultato: = WinRegGetBinary (RootKey, nome, szBin, Wow64);

  se risultato allora
  Risultato: = lunghezza (szBin) = 8;

  se risultato allora
  cominciare
    per la i: = 1 - 8 fanno
    dtBytes [i]: = ord (szBin [i]);
    Valore: = dtBuff;
  estremità;
estremità;

funzione DateTime2Binary (RootKey: HKEY; Nome: Stringa; valore di varietà: TDateTime; Wow64: Booleano): Booleano;
varietà
  dtBuff: TDateTime;
  dtBytes: allineamento [1..8] del dtBuff di assoluto di byte;
cominciare
  dtBuff: = valore;
  Risultato: = WinRegSetBinary (RootKey, nome, dtBytes, Wow64);
estremità;

funzione Binary2Integer (RootKey: HKEY; Nome: Stringa; valore di varietà: Numero intero; Wow64: Booleano): Booleano;
varietà
  iBuff: Numero intero;
  dtBytes: allineamento [1..4] del iBuff di assoluto di byte;
  szBin: stringa;
  i: numero intero;
cominciare
  Risultato: = WinRegGetBinary (RootKey, nome, szBin, Wow64);

  se risultato allora
  Risultato: = lunghezza (szBin) = 4;

  se risultato allora
  cominciare
    per la i: = 1 - 4 fanno
    dtBytes [i]: = ord (szBin [i]);
    Valore: = iBuff;
  estremità;
estremità;

funzione Integer2Binary (RootKey: HKEY; Nome: Stringa; valore di varietà: Numero intero; Wow64: Booleano): Booleano;
varietà
  iBuff: Numero intero;
  dtBytes: allineamento [1..4] del iBuff di assoluto di byte;
cominciare
  iBuff: = valore;
  Risultato: = WinRegSetBinary (RootKey, nome, dtBytes, Wow64);
estremità;

funzione LastPos (ago: Carbone; Mucchio di fieno: Stringa): numero intero;
cominciare
  per il risultato: = il downto 1 di lunghezza (mucchio di fieno) fa
  se mucchio di fieno [risultato] = ago allora
  Rottura;
estremità;

funzione WinRegConnect (MachineName: Stringa; RootKey: HKEY; varietà RemoteKey: HKEY): booleano;
cominciare
  Risultato: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
estremità;

funzione WinRegDisconnect (RemoteKey: HKEY): booleano;
cominciare
  Risultato: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
estremità;

funzione RegSetValue (RootKey: HKEY; Nome: Stringa; ValType: Cardinale; PVal: Indicatore; ValSize: Cardinale; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Booleano;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_WRITE;

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

    se bSuccess allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      Risultato: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione RegGetValue (RootKey: HKEY; Nome: Stringa; ValType: Cardinale; varietà PVal: Indicatore;
  varietà ValSize: Cardinale; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Indicatore;
  BufSize: Cardinale;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_READ o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_READ o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      se RegQueryValueEx (hTemp, PChar (SubKey), lo zero, il @MyValType, zero, @BufSize) = ERROR_SUCCESS allora
      cominciare
        GetMem (Buf, BufSize);
        se RegQueryValueEx (hTemp, PChar (SubKey), lo zero, il @MyValType, Buf, @BufSize) = ERROR_SUCCESS allora
        cominciare
          se ValType = MyValType allora
          cominciare
            PVal: = Buf;
            ValSize: = BufSize;
            Risultato: = allineare;
          estremità
          altrimenti
          FreeMem (Buf);
        estremità
        altrimenti
        FreeMem (Buf);
      estremità;
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegValueExists (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  hTemp: HKEY;
  _hKey: Manico a t;
cominciare
  Risultato: = falso;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_READ o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_READ o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      Risultato: = (RegQueryValueEx (hTemp, PChar (SubKey), zero, zero, zero, zero) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegGetValueType (RootKey: HKEY; Nome: Stringa; valore di varietà: Cardinale; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  hTemp: HKEY;
  ValType: Cardinale;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  Valore: = REG_NONE;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_READ o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_READ o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_READ;

    se (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      Risultato: = (RegQueryValueEx (hTemp, PChar (SubKey), zero, @ValType, zero, zero) = ERROR_SUCCESS);
      se risultato allora
      Valore: = ValType;
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegKeyExists (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  hTemp: HKEY;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_READ o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_READ o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
    cominciare
      Risultato: = allineare;
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegDelValue (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  hTemp: HKEY;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_WRITE;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      Risultato: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegDelKey (RootKey: HKEY; Nome: Stringa; Wow64: Booleano): booleano;
varietà
  SubKey: Stringa;
  n: numero intero;
  hTemp: HKEY;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  n: = LastPos (“\„, nome);
  se n > 0 allora
  cominciare
    SubKey: = copia (nome, 1, n - 1);

    se Wow64 e IsWow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY altrimenti
    se IsWow64 e non Wow64 allora
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY altrimenti
    _hKey: = KEY_WRITE;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
    cominciare
      SubKey: = copia (nome, n + 1, lunghezza (nome) - n);
      Risultato: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    estremità;
  estremità;
estremità;

funzione WinRegEnum (hRootKey: HKEY; szKey: Stringa; Amplificatore: TStringList; bKeys: Booleano; Wow64: Booleano): Booleano;
varietà
  i: numero intero;
  ire: numero intero;
  s: Stringa;
  hTemp: HKEY;
  Buf: Indicatore;
  BufSize: Cardinale;
  _hKey: Cardinale;
cominciare
  Risultato: = falso;
  Buffer.Clear;

  se Wow64 e IsWow64 allora
  _hKey: = KEY_READ o KEY_WOW64_64KEY altrimenti
  se IsWow64 e non Wow64 allora
  _hKey: = KEY_READ o KEY_WOW64_32KEY altrimenti
  _hKey: = KEY_READ;

  se RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS allora
  cominciare
    Risultato: = allineare;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    i: = 0;
    ire: = ERROR_SUCCESS;
    mentre le ire = ERROR_SUCCESS fanno
    cominciare
      BufSize: = 1024;
      se bKeys allora
        ire: = RegEnumKeyEx (hTemp, i, buf, BufSize, zero, zero, zero, zero)
      altrimenti
        ire: = RegEnumValue (hTemp, i, buf, BufSize, zero, zero, zero, zero);
      se ire = ERROR_SUCCESS allora
      cominciare
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        inc (i);
      estremità;
    estremità;
    FreeMem (buf);
    RegCloseKey (hTemp);
  estremità;
estremità;

funzione WinRegSetString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
cominciare
  Risultato: = RegSetValue (RootKey, nome, REG_SZ, PChar (valore + #0), lunghezza (valore) + 1, Wow64);
estremità;

funzione WinRegSetMultiString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
cominciare
  Risultato: = RegSetValue (RootKey, nome, REG_MULTI_SZ, PChar (valore + #0#0), lunghezza (valore) + 2, Wow64);
estremità;

funzione WinRegSetExpandString (RootKey: HKEY; Nome: Stringa; Valore: Stringa; Wow64: Booleano): booleano;
cominciare
  Risultato: = RegSetValue (RootKey, nome, REG_EXPAND_SZ, PChar (valore + #0), lunghezza (valore) + 1, Wow64);
estremità;

funzione WinRegSetDword (RootKey: HKEY; Nome: Stringa; Valore: Cardinale; Wow64: Booleano): booleano;
cominciare
  Risultato: = RegSetValue (RootKey, nome, REG_DWORD, @Value, SizeOf (cardinale), Wow64);
estremità;

funzione WinRegSetBinary (RootKey: HKEY; Nome: Stringa; Valore: Allineamento del byte; Wow64: Booleano): booleano;
cominciare
  Risultato: = RegSetValue (RootKey, nome, REG_BINARY, @Value, SizeOf (valore), Wow64);
estremità;

funzione WinRegGetString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
varietà
  Buf: Indicatore;
  BufSize: Cardinale;
cominciare
  Risultato: = falso;
  se RegGetValue (RootKey, nome, REG_SZ, Buf, BufSize, Wow64) allora
  cominciare
    Dicembre (BufSize);
    SetLength (valore, BufSize);
    se BufSize > 0 allora
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Risultato: = allineare;
  estremità;
estremità;

funzione WinRegGetMultiString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
varietà
  Buf: Indicatore;
  BufSize: Cardinale;
cominciare
  Risultato: = falso;
  se RegGetValue (RootKey, nome, REG_MULTI_SZ, Buf, BufSize, Wow64) allora
  cominciare
    Dicembre (BufSize);
    SetLength (valore, BufSize);
    se BufSize > 0 allora
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Risultato: = allineare;
  estremità;
estremità;

funzione WinRegGetExpandString (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
varietà
  Buf: Indicatore;
  BufSize: Cardinale;
cominciare
  Risultato: = falso;
  se RegGetValue (RootKey, nome, REG_EXPAND_SZ, Buf, BufSize, Wow64) allora
  cominciare
    Dicembre (BufSize);
    SetLength (valore, BufSize);
    se BufSize > 0 allora
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Risultato: = allineare;
  estremità;
estremità;

funzione WinRegGetDWORD (RootKey: HKEY; Nome: Stringa; Valore di varietà: Cardinale; Wow64: Booleano): booleano;
varietà
  Buf: Indicatore;
  BufSize: Cardinale;
cominciare
  Risultato: = falso;
  se RegGetValue (RootKey, nome, REG_DWORD, Buf, BufSize, Wow64) allora
  cominciare
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Risultato: = allineare;
  estremità;
estremità;

funzione WinRegGetBinary (RootKey: HKEY; Nome: Stringa; Valore di varietà: Stringa; Wow64: Booleano): booleano;
varietà
  Buf: Indicatore;
  BufSize: Cardinale;
cominciare
  Risultato: = falso;
  se RegGetValue (RootKey, nome, REG_BINARY, Buf, BufSize, Wow64) allora
  cominciare
    SetLength (valore, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Risultato: = allineare;
  estremità;
estremità;

estremità.
Altre soluzioni  
 
programming4us programming4us