Cuestión : Ahorrar las cuentas de la máquina y de usuario en Windows 2008 SBS

Hicimos original una actualización de Windows 2003 SBS con Windows 2008 SBS. Ahora tenemos directorios ligados cruz y una miríada de otros problemas algunos de ellos causó por los permisos cambiantes etc. de una varia de tecnología gente alejada de la ayuda. Vamos a hacer un limpio para instalar el hoy de 2008 SBS. Tengo los trabajadores caseros que han ensamblado el dominio y me preguntaba si hay una manera de preservar sus cuentas del usuario y de máquina así que puedo recargarlas más adelante cuando el nuevo OS está instalado. También quisiera recargar sus email del intercambio e Info relacionado que han almacenado. ¿Puede esto ser hecha? ¿También está la mejor manera de reinstalar nuestra base de datos 2005 del SQL para separarlo y lo reatan cuando conseguimos SQL 2008 instalado en el SBS2008 fresco instalamos?
Thanks
class= del

Respuesta : Ahorrar las cuentas de la máquina y de usuario en Windows 2008 SBS

Hola,

Tenía este problema también… así que con algunas modificaciones y usar otra manera de tener acceso al registro de Windows (no usar Registry.pas) he hecho sin problemas…

El código abajo es un reemplazo del litghtweight para Registry.pas con modificaciones al trabajo con las banderas de KEY_WOW64_64KEY/KEY_WOW64_32KEY

Uso básico en su caso

Determinación de su programa como Shell
[código] WinRegSetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, “YourProgram.exe”, verdad); [/code]

si usted pone un “Blackslash” en la llave como (“SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell \ ") creará una nueva “llave” Shell llamado… sin blackslash que tendrá acceso a un valor llamado Shell… iguales para todas las funciones

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

Lectura de la cáscara actual
[código] var
szBuff: Secuencia;
comenzar
WinRegGetString (HKEY_LOCAL_MACHINE, “SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion \ Winlogon \ Shell”, szBuff, verdad);
ShowMessage (““” + szBuff + ““"); [/code]

¡Esperanza él ayuda usted!
Respetos,
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:

           
           
             unidad UTILS_Reg;

interfaz

aplicaciones
  Windows,
  SysUtils,
  Clases;

  función WinRegConnect (MachineName: Secuencia; RootKey: HKEY; var RemoteKey: HKEY): boleano;
  función WinRegDisconnect (RemoteKey: HKEY): boleano;
  función WinRegValueExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetValueType (RootKey: HKEY; Nombre: Secuencia; valor del var: Cardinal; Wow64: Boleano): boleano;
  función WinRegKeyExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegDelValue (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegDelKey (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
  función WinRegEnum (hRootKey: HKEY; szKey: Secuencia; Almacenador intermediario: TStringList; bKeys: Boleano; Wow64: Boleano): Boleano;
  función WinRegSetString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
  función WinRegSetDword (RootKey: HKEY; Nombre: Secuencia; Valor: Cardinal; Wow64: Boleano): boleano;
  función WinRegSetBinary (RootKey: HKEY; Nombre: Secuencia; Valor: Arsenal del octeto; Wow64: Boleano): boleano;
  función WinRegGetString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función WinRegGetDWORD (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Cardinal; Wow64: Boleano): boleano;
  función WinRegGetBinary (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
  función Binary2DateTime (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
  función DateTime2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
  función Binary2Integer (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
  función Integer2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;

puesta en práctica

función IsWow64: Boleano;
tipo
  TIsWow64Process = función (tipo de // de IsWow64Process API fn
    Manija: Windows.THandle; var Res: Windows.BOOL
  ): Windows.BOOL; stdcall;
var
  IsWow64Result: Windows.BOOL;      Resultado de // de IsWow64Process
  IsWow64Process: TIsWow64Process;  Referencia de // IsWow64Process fn
comenzar
  Intento de // para cargar la función required de kernel32
  IsWow64Process: = Windows.GetProcAddress (
    Windows.GetModuleHandle (“kernel32.dll "), “IsWow64Process”
  );
  si entonces está asignado (IsWow64Process)
  comenzar
    Se ejecuta la función de //: llamarla
    si no IsWow64Process (
      Windows.GetCurrentProcess, IsWow64Result
    ) entonces
      aumento SysUtils.Exception.Create (“IsWow64: mala manija de proceso ");
    Resultado de vuelta de // de la función
    Resultado: = IsWow64Result;
  extremo
  
    Función de // no ejecutada: no puede funcionar en Wow64
    Resultado: = falso;
extremo;

función Binary2DateTime (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
var
  dtBuff: TDateTime;
  dtBytes: arsenal [1..8] de dtBuff del absoluto del octeto;
  szBin: secuencia;
  i: número entero;
comenzar
  Resultado: = WinRegGetBinary (RootKey, nombre, szBin, Wow64);

  si resultado entonces
  Resultado: = longitud (szBin) = 8;

  si resultado entonces
  comenzar
    para i: = 1 a 8 hace
    dtBytes [i]: = ord (szBin [i]);
    Valor: = dtBuff;
  extremo;
extremo;

función DateTime2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: TDateTime; Wow64: Boleano): Boleano;
var
  dtBuff: TDateTime;
  dtBytes: arsenal [1..8] de dtBuff del absoluto del octeto;
comenzar
  dtBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nombre, dtBytes, Wow64);
extremo;

función Binary2Integer (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
var
  iBuff: Número entero;
  dtBytes: arsenal [1..4] de iBuff del absoluto del octeto;
  szBin: secuencia;
  i: número entero;
comenzar
  Resultado: = WinRegGetBinary (RootKey, nombre, szBin, Wow64);

  si resultado entonces
  Resultado: = longitud (szBin) = 4;

  si resultado entonces
  comenzar
    para i: = 1 a 4 hace
    dtBytes [i]: = ord (szBin [i]);
    Valor: = iBuff;
  extremo;
extremo;

función Integer2Binary (RootKey: HKEY; Nombre: Secuencia; valor del var: Número entero; Wow64: Boleano): Boleano;
var
  iBuff: Número entero;
  dtBytes: arsenal [1..4] de iBuff del absoluto del octeto;
comenzar
  iBuff: = valor;
  Resultado: = WinRegSetBinary (RootKey, nombre, dtBytes, Wow64);
extremo;

función LastPos (aguja: Carbón de leña; Haystack: Secuencia): número entero;
comenzar
  para el resultado: = el downto 1 de la longitud (Haystack) hace
  si Haystack [resultado] = aguja entonces
  Rotura;
extremo;

función WinRegConnect (MachineName: Secuencia; RootKey: HKEY; var RemoteKey: HKEY): boleano;
comenzar
  Resultado: = (RegConnectRegistry (PChar (MachineName), RootKey, RemoteKey) = ERROR_SUCCESS);
extremo;

función WinRegDisconnect (RemoteKey: HKEY): boleano;
comenzar
  Resultado: = (RegCloseKey (RemoteKey) = ERROR_SUCCESS);
extremo;

función RegSetValue (RootKey: HKEY; Nombre: Secuencia; ValType: Cardinal; PVal: Indicador; ValSize: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  dispo: DWORD;
  hTemp: HKEY;
  bSuccess: Boleano;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

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

    si bSuccess entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegSetValueEx (hTemp, PChar (SubKey), 0, ValType, PVal, ValSize) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función RegGetValue (RootKey: HKEY; Nombre: Secuencia; ValType: Cardinal; var PVal: Indicador;
  var ValSize: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  MyValType: DWORD;
  hTemp: HKEY;
  Buf: Indicador;
  BufSize: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      si RegQueryValueEx (el hTemp, PChar (SubKey), nada, @MyValType, nada, @BufSize) = ERROR_SUCCESS entonces
      comenzar
        GetMem (Buf, BufSize);
        si RegQueryValueEx (el hTemp, PChar (SubKey), nada, @MyValType, Buf, @BufSize) = ERROR_SUCCESS entonces
        comenzar
          si ValType = MyValType después
          comenzar
            PVal: = Buf;
            ValSize: = BufSize;
            Resultado: = verdad;
          extremo
          
          FreeMem (Buf);
        extremo
        
        FreeMem (Buf);
      extremo;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegValueExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Manilla en forma de T;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, nada, nada, nada) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegGetValueType (RootKey: HKEY; Nombre: Secuencia; valor del var: Cardinal; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  ValType: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  Valor: = REG_NONE;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si (RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS) entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegQueryValueEx (hTemp, PChar (SubKey), nada, @ValType, nada, nada) = ERROR_SUCCESS);
      si resultado entonces
      Valor: = ValType;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegKeyExists (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_READ o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_READ o KEY_WOW64_32KEY 
    _hKey: = KEY_READ;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      Resultado: = verdad;
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegDelValue (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegDeleteValue (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegDelKey (RootKey: HKEY; Nombre: Secuencia; Wow64: Boleano): boleano;
var
  SubKey: Secuencia;
  n: número entero;
  hTemp: HKEY;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  n: = LastPos (“\”, nombre);
  si n > 0 entonces
  comenzar
    SubKey: = copia (nombre, 1, n - 1);

    si Wow64 e IsWow64 entonces
    _hKey: = KEY_WRITE o KEY_WOW64_64KEY 
    si IsWow64 y no Wow64 después
    _hKey: = KEY_WRITE o KEY_WOW64_32KEY 
    _hKey: = KEY_WRITE;

    si RegOpenKeyEx (RootKey, PChar (SubKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
    comenzar
      SubKey: = copia (nombre, n + 1, longitud (nombre) - n);
      Resultado: = (RegDeleteKey (hTemp, PChar (SubKey)) = ERROR_SUCCESS);
      RegCloseKey (hTemp);
    extremo;
  extremo;
extremo;

función WinRegEnum (hRootKey: HKEY; szKey: Secuencia; Almacenador intermediario: TStringList; bKeys: Boleano; Wow64: Boleano): Boleano;
var
  i: número entero;
  iras: número entero;
  s: Secuencia;
  hTemp: HKEY;
  Buf: Indicador;
  BufSize: Cardinal;
  _hKey: Cardinal;
comenzar
  Resultado: = falso;
  Buffer.Clear;

  si Wow64 e IsWow64 entonces
  _hKey: = KEY_READ o KEY_WOW64_64KEY 
  si IsWow64 y no Wow64 después
  _hKey: = KEY_READ o KEY_WOW64_32KEY 
  _hKey: = KEY_READ;

  si RegOpenKeyEx (hRootKey, PChar (szKey), 0, _hKey, hTemp) = ERROR_SUCCESS entonces
  comenzar
    Resultado: = verdad;
    BufSize: = 1024;
    GetMem (buf, BufSize);
    i: = 0;
    iras: = ERROR_SUCCESS;
    mientras que hacen las iras = ERROR_SUCCESS
    comenzar
      BufSize: = 1024;
      si bKeys entonces
        iras: = RegEnumKeyEx (hTemp, i, buf, BufSize, nada, nada, nada, nada)
      
        iras: = RegEnumValue (hTemp, i, buf, BufSize, nada, nada, nada, nada);
      si iras = ERROR_SUCCESS después
      comenzar
        SetLength (s, BufSize);
        CopyMemory (@s [1], buf, BufSize);
        Buffer.Add;
        inc. (i);
      extremo;
    extremo;
    FreeMem (buf);
    RegCloseKey (hTemp);
  extremo;
extremo;

función WinRegSetString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_SZ, PChar (valor + #0), longitud (valor) + 1, Wow64);
extremo;

función WinRegSetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_MULTI_SZ, PChar (valor + #0#0), longitud (valor) + 2, Wow64);
extremo;

función WinRegSetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor: Secuencia; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_EXPAND_SZ, PChar (valor + #0), longitud (valor) + 1, Wow64);
extremo;

función WinRegSetDword (RootKey: HKEY; Nombre: Secuencia; Valor: Cardinal; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_DWORD, @Value, SizeOf (cardinal), Wow64);
extremo;

función WinRegSetBinary (RootKey: HKEY; Nombre: Secuencia; Valor: Arsenal del octeto; Wow64: Boleano): boleano;
comenzar
  Resultado: = RegSetValue (RootKey, nombre, REG_BINARY, @Value, SizeOf (valor), Wow64);
extremo;

función WinRegGetString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetMultiString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_MULTI_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetExpandString (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_EXPAND_SZ, Buf, BufSize, Wow64) entonces
  comenzar
    Diciembre (BufSize);
    SetLength (valor, BufSize);
    si BufSize > 0 entonces
      CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetDWORD (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Cardinal; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_DWORD, Buf, BufSize, Wow64) entonces
  comenzar
    CopyMemory (@Value, Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

función WinRegGetBinary (RootKey: HKEY; Nombre: Secuencia; Valor del Var: Secuencia; Wow64: Boleano): boleano;
var
  Buf: Indicador;
  BufSize: Cardinal;
comenzar
  Resultado: = falso;
  si RegGetValue (RootKey, nombre, REG_BINARY, Buf, BufSize, Wow64) entonces
  comenzar
    SetLength (valor, BufSize);
    CopyMemory (@Value [1], Buf, BufSize);
    FreeMem (Buf);
    Resultado: = verdad;
  extremo;
extremo;

extremo.

           
         

Otras soluciones

Cómo fijar un número de líneas en un informe

Cómo fijar extremo del aeropuerto como servidor del DHCP en el LAN con SonicWall

Ediciones del enlace hipertexto

Agregar la fecha a MySQL

Pares de las preguntas de Apple

El DNS reverso no empareja la bandera del smtp

¿Cómo puedo funcionar conmigo PC en modo seguro?

HISTOGRAMA CON EL CP Y EL ANÁLISIS DE CPK

reglas no corrientes de la perspectiva

volver un valor