Pergunta : Conservar clientes da máquina e de usuário em Windows 2008 SBS

Nós fizemos original uma atualização de Windows 2003 SBS com Windows 2008 SBS. Agora nós temos diretórios lig cruz e uma miríade de outros problemas alguns deles causou pelas permissões em mudança etc. de um vário pessoa remoto da sustentação de tecnologia. Nós estamos indo fazer um limpo para instalar hoje de 2008 SBS. Eu tenho os trabalhadores home que se juntaram ao domínio e eu queria saber se há uma maneira de preservar seus clientes do usuário e de máquina assim que eu posso os recarregar mais tarde quando o ósmio novo está instalado. Eu igualmente gostaria de recarregar seus email da troca e informação que relacionada armazenaram. Pode isto ser feito? Igualmente é a melhor maneira de reinstalar nossa base de dados 2005 do SQL para destacá-lo e reatam-no quando nós começ SQL 2008 instalado no SBS2008 fresco instalamos?
Thanks
class= do

Resposta : Conservar clientes da máquina e de usuário em Windows 2008 SBS

Olá!,

Eu tive este problema demasiado… assim que com algumas modificações e utilização de uma outra maneira de alcançar o registro de Windows (não using Registry.pas) eu fiz sem problemas…

O código abaixo é uma recolocação do litghtweight para Registry.pas com modificações ao trabalho com bandeiras de KEY_WOW64_64KEY/KEY_WOW64_32KEY

Uso básico em seu caso

Setting-up seu programa como Shell
[código] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, “YourProgram.exe”, retificam); [/code]

se você põr um “Blackslash” na chave como (“SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") criará “uma chave nova” Shell chamado… sem o blackslash que alcance um valor chamado Shell… o mesmos para todas as funções

Retornar a Windows Shell
[código] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, “Explorer.exe”, retificam); [/code]

Lendo o escudo atual
[código] var
szBuff: Corda;
começar
WinRegGetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, szBuff, retificam);
ShowMessage (““” + szBuff + ““"); [/code]

Esperança ele ajuda você!
Considerações,
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:

           
           
             unidade UTILS_Reg;

relação

usos
  Windows,
  SysUtils,
  Classes;

  função WinRegConnect (MachineName: Corda; RootKey: HKEY; var RemoteKey: HKEY): bôoleano;
  função WinRegDisconnect (RemoteKey: HKEY): bôoleano;
  função WinRegValueExists (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegGetValueType (RootKey: HKEY; Nome: Corda; valor do var: Cardinal; Wow64: Bôoleano): bôoleano;
  função WinRegKeyExists (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegDelValue (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegDelKey (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegEnum (hRootKey: HKEY; szKey: Corda; Amortecedor: TStringList; bKeys: Bôoleano; Wow64: Bôoleano): Bôoleano;
  função WinRegSetString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegSetMultiString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegSetExpandString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegSetDword (RootKey: HKEY; Nome: Corda; Valor: Cardinal; Wow64: Bôoleano): bôoleano;
  função WinRegSetBinary (RootKey: HKEY; Nome: Corda; Valor: Disposição de byte; Wow64: Bôoleano): bôoleano;
  função WinRegGetString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegGetMultiString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegGetExpandString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
  função WinRegGetDWORD (RootKey: HKEY; Nome: Corda; Valor do Var: Cardinal; Wow64: Bôoleano): bôoleano;
  função WinRegGetBinary (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
  função Binary2DateTime (RootKey: HKEY; Nome: Corda; valor do var: TDateTime; Wow64: Bôoleano): Bôoleano;
  função DateTime2Binary (RootKey: HKEY; Nome: Corda; valor do var: TDateTime; Wow64: Bôoleano): Bôoleano;
  função Binary2Integer (RootKey: HKEY; Nome: Corda; valor do var: Inteiro; Wow64: Bôoleano): Bôoleano;
  função Integer2Binary (RootKey: HKEY; Nome: Corda; valor do var: Inteiro; Wow64: Bôoleano): Bôoleano;

execução

função IsWow64: Bôoleano;
tipo
  TIsWow64Process = função (tipo de // de IsWow64Process API fn
    Punho: Windows.THandle; var Res: Windows.BOOL
  ): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      Resultado de // de IsWow64Process
  IsWow64Process: TIsWow64Process;  Referência de // IsWow64Process fn
começar
  Tentativa de // para carregar função required de kernel32
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle (“kernel32.dll "), “IsWow64Process”
  );
  se atribuído (IsWow64Process) então
  começar
    A função de // é executada: chamá-la
    se não IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) então
      aumento SysUtils.Exception.Create (“IsWow64: punho process mau ");
    Resultado do retorno de // da função
    Resultado: = IsWow64Result;
  extremidade
  mais
    Função de // não executada: não pode funcionar em Wow64
    Resultado: = falso;
extremidade;

função Binary2DateTime (RootKey: HKEY; Nome: Corda; valor do var: TDateTime; Wow64: Bôoleano): Bôoleano;
var
  dtBuff: TDateTime;
  dtBytes: disposição [1..8] de dtBuff do absolute do byte;
  szBin: corda;
  i: inteiro;
começar
  Resultado: = WinRegGetBinary (RootKey, nome, szBin, Wow64);

  se resultado então
  Resultado: = comprimento (szBin) = 8;

  se resultado então
  começar
    para i: = 1 a 8 faz
    dtBytes [i]: = ord (szBin [i]);
    Valor: = dtBuff;
  extremidade;
extremidade;

função DateTime2Binary (RootKey: HKEY; Nome: Corda; valor do var: TDateTime; Wow64: Bôoleano): Bôoleano;
var
  dtBuff: TDateTime;
  dtBytes: disposição [1..8] de dtBuff do absolute do byte;
começar
  dtBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nome, dtBytes, Wow64);
extremidade;

função Binary2Integer (RootKey: HKEY; Nome: Corda; valor do var: Inteiro; Wow64: Bôoleano): Bôoleano;
var
  iBuff: Inteiro;
  dtBytes: disposição [1..4] de iBuff do absolute do byte;
  szBin: corda;
  i: inteiro;
começar
  Resultado: = WinRegGetBinary (RootKey, nome, szBin, Wow64);

  se resultado então
  Resultado: = comprimento (szBin) = 4;

  se resultado então
  começar
    para i: = 1 a 4 faz
    dtBytes [i]: = ord (szBin [i]);
    Valor: = iBuff;
  extremidade;
extremidade;

função Integer2Binary (RootKey: HKEY; Nome: Corda; valor do var: Inteiro; Wow64: Bôoleano): Bôoleano;
var
  iBuff: Inteiro;
  dtBytes: disposição [1..4] de iBuff do absolute do byte;
começar
  iBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nome, dtBytes, Wow64);
extremidade;

função LastPos (agulha: Carvão animal; Monte de feno: Corda): inteiro;
começar
  para o resultado: = o downto 1 do comprimento (monte de feno) faz
  se monte de feno [resultado] = agulha então
  Ruptura;
extremidade;

função WinRegConnect (MachineName: Corda; RootKey: HKEY; var RemoteKey: HKEY): bôoleano;
começar
  Resultado: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
extremidade;

função WinRegDisconnect (RemoteKey: HKEY): bôoleano;
começar
  Resultado: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
extremidade;

função RegSetValue (RootKey: HKEY; Nome: Corda; ValType: Cardinal; PVal: Ponteiro; ValSize: Cardinal; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Bôoleano;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_32KEY mais
    _hKey: = KEY_WRITE;

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

    se bSuccess então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      Resultado: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função RegGetValue (RootKey: HKEY; Nome: Corda; ValType: Cardinal; var PVal: Ponteiro;
  var ValSize: Cardinal; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Ponteiro;
  BufSize: Cardinal;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_READ ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_READ ou KEY_WOW64_32KEY mais
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      se RegQueryValueEx (o hTemp, PChar (SubKey), nada, @MyValType, nada, @BufSize) = ERROR_SUCCESS então
      começar
        GetMem (Buf, BufSize);
        se RegQueryValueEx (o hTemp, PChar (SubKey), nada, @MyValType, Buf, @BufSize) = ERROR_SUCCESS então
        começar
          se ValType = MyValType então
          começar
            PVal: = Buf;
            ValSize: = BufSize;
            Resultado: = retificar;
          extremidade
          mais
          FreeMem (Buf);
        extremidade
        mais
        FreeMem (Buf);
      extremidade;
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegValueExists (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  hTemp: HKEY;
  _hKey: THandle;
começar
  Resultado: = falso;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_READ ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_READ ou KEY_WOW64_32KEY mais
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, nada, nada, nada) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegGetValueType (RootKey: HKEY; Nome: Corda; valor do var: Cardinal; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  hTemp: HKEY;
  ValType: Cardinal;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  Valor: = REG_NONE;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_READ ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_READ ou KEY_WOW64_32KEY mais
    _hKey: = KEY_READ;

    se (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, @ValType, nada, nada) = ERROR_SUCCESS);
      se resultado então
      Valor: = ValType;
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegKeyExists (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  hTemp: HKEY;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_READ ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_READ ou KEY_WOW64_32KEY mais
    _hKey: = KEY_READ;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
    começar
      Resultado: = retificar;
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegDelValue (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  hTemp: HKEY;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_32KEY mais
    _hKey: = KEY_WRITE;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      Resultado: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegDelKey (RootKey: HKEY; Nome: Corda; Wow64: Bôoleano): bôoleano;
var
  SubKey: Corda;
  n: inteiro;
  hTemp: HKEY;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  n: = LastPos (“\”, nome);
  se n > 0 então
  começar
    SubKey: = cópia (nome, 1, n - 1);

    se Wow64 e IsWow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_64KEY mais
    se IsWow64 e não Wow64 então
    _hKey: = KEY_WRITE ou KEY_WOW64_32KEY mais
    _hKey: = KEY_WRITE;

    se RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
    começar
      SubKey: = cópia (nome, n + 1, comprimento (nome) - n);
      Resultado: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremidade;
  extremidade;
extremidade;

função WinRegEnum (hRootKey: HKEY; szKey: Corda; Amortecedor: TStringList; bKeys: Bôoleano; Wow64: Bôoleano): Bôoleano;
var
  i: inteiro;
  ira: inteiro;
  s: Corda;
  hTemp: HKEY;
  Buf: Ponteiro;
  BufSize: Cardinal;
  _hKey: Cardinal;
começar
  Resultado: = falso;
  Buffer.Clear;

  se Wow64 e IsWow64 então
  _hKey: = KEY_READ ou KEY_WOW64_64KEY mais
  se IsWow64 e não Wow64 então
  _hKey: = KEY_READ ou KEY_WOW64_32KEY mais
  _hKey: = KEY_READ;

  se RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS então
  começar
    Resultado: = retificar;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    i: = 0;
    ira: = ERROR_SUCCESS;
    quando os ira = ERROR_SUCCESS fizerem
    começar
      BufSize: = 1024;
      se bKeys então
        ira: = RegEnumKeyEx (hTemp, i, buf, BufSize, nada, nada, nada, nada)
      mais
        ira: = RegEnumValue (hTemp, i, buf, BufSize, nada, nada, nada, nada);
      se ira = ERROR_SUCCESS então
      começar
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        inc (i);
      extremidade;
    extremidade;
    FreeMem (buf);
    RegCloseKey (hTemp);
  extremidade;
extremidade;

função WinRegSetString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
começar
  Resultado: = RegSetValue (RootKey, nome, REG_SZ, PChar (valor + #0), comprimento (valor) + 1, Wow64);
extremidade;

função WinRegSetMultiString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
começar
  Resultado: = RegSetValue (RootKey, nome, REG_MULTI_SZ, PChar (valor + #0#0), comprimento (valor) + 2, Wow64);
extremidade;

função WinRegSetExpandString (RootKey: HKEY; Nome: Corda; Valor: Corda; Wow64: Bôoleano): bôoleano;
começar
  Resultado: = RegSetValue (RootKey, nome, REG_EXPAND_SZ, PChar (valor + #0), comprimento (valor) + 1, Wow64);
extremidade;

função WinRegSetDword (RootKey: HKEY; Nome: Corda; Valor: Cardinal; Wow64: Bôoleano): bôoleano;
começar
  Resultado: = RegSetValue (RootKey, nome, REG_DWORD, @Value, SizeOf (cardinal), Wow64);
extremidade;

função WinRegSetBinary (RootKey: HKEY; Nome: Corda; Valor: Disposição de byte; Wow64: Bôoleano): bôoleano;
começar
  Resultado: = RegSetValue (RootKey, nome, REG_BINARY, @Value, SizeOf (valor), Wow64);
extremidade;

função WinRegGetString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
var
  Buf: Ponteiro;
  BufSize: Cardinal;
começar
  Resultado: = falso;
  se RegGetValue (RootKey, nome, REG_SZ, Buf, BufSize, Wow64) então
  começar
    Dezembro (BufSize);
    SetLength (valor, BufSize);
    se BufSize > 0 então
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = retificar;
  extremidade;
extremidade;

função WinRegGetMultiString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
var
  Buf: Ponteiro;
  BufSize: Cardinal;
começar
  Resultado: = falso;
  se RegGetValue (RootKey, nome, REG_MULTI_SZ, Buf, BufSize, Wow64) então
  começar
    Dezembro (BufSize);
    SetLength (valor, BufSize);
    se BufSize > 0 então
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = retificar;
  extremidade;
extremidade;

função WinRegGetExpandString (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
var
  Buf: Ponteiro;
  BufSize: Cardinal;
começar
  Resultado: = falso;
  se RegGetValue (RootKey, nome, REG_EXPAND_SZ, Buf, BufSize, Wow64) então
  começar
    Dezembro (BufSize);
    SetLength (valor, BufSize);
    se BufSize > 0 então
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = retificar;
  extremidade;
extremidade;

função WinRegGetDWORD (RootKey: HKEY; Nome: Corda; Valor do Var: Cardinal; Wow64: Bôoleano): bôoleano;
var
  Buf: Ponteiro;
  BufSize: Cardinal;
começar
  Resultado: = falso;
  se RegGetValue (RootKey, nome, REG_DWORD, Buf, BufSize, Wow64) então
  começar
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Resultado: = retificar;
  extremidade;
extremidade;

função WinRegGetBinary (RootKey: HKEY; Nome: Corda; Valor do Var: Corda; Wow64: Bôoleano): bôoleano;
var
  Buf: Ponteiro;
  BufSize: Cardinal;
começar
  Resultado: = falso;
  se RegGetValue (RootKey, nome, REG_BINARY, Buf, BufSize, Wow64) então
  começar
    SetLength (valor, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = retificar;
  extremidade;
extremidade;

extremidade.

           
         

Outras soluções

Perguntas da entrevista do certificado de Shell da festança

lima de .vmdk

Como encontrar a contagem da fileira em Oracle DataReader em ASP.NET?

Excitador do bluetooth BCM2045 do inspiron 1720 de Dell para o profissional de Windows Xp.

Como conseguir o lightbox mostrar sobre a bandeira instantânea?

Fora do escritório o assistente que não trabalha w/Forwarding configurou

Redistribuindo o RASGO em subnets non-contiguous do OSPF.

líquidos de corpo após a sessão da natação

SQL0952N

Criando um vbscript para a chave do registro - IRPStackSize