ACCESSdelphi 注册表操作(读取、添加、删除、修改)完全手册

33人Delphi程序中可利用TRegistry对象来存取注册表文件中的音讯。 

  ① 、创立和假释TRegistry对象 

  1.开立TRegistry对象。为了操作注册表,要成立一个TRegistry对象:ARegistry
:= TRegistry.Create; 

  2.获释TRegistry对象。对注册表操作甘休后,应释放TRegistry对象所占内部存款和储蓄器:ARegistry.Destroy。 

  二 、钦命要操作的键 

  操作注册表时,首先应内定操作的主键:先给属性RootKey赋值以钦点根键,然后用艺术OpenKey来钦命要操作的主键名。 

  1.点名根键(RootKey)。 
  根键是注册表的进口,也注册表音讯的归类,其值可为: 
  HKEY—CLASSES—ROOT:存款和储蓄整个系统对象类新闻,如ActiveX对象注册、文件涉及等音信。 
  HKEY—CULacrosseRENT—USE翼虎:存款和储蓄当前用户的陈设音讯。为属性RootKey的暗许值。 
  HKEY—LOCAL—MACHINE:存款和储蓄当前系统的软硬件配置音信。应用程序自个儿的音讯方可储存在该根键下。
 HKEY—USE路虎极光S:存款和储蓄全数用户通用的陈设新闻。 
  还是能是HKEY—CU宝马7系RENT—CONFIG、HKEY—DYN—DATA。 

  2.点名要操作的主键。 
  Function OpenKey(const Key: string; CanCreate: Boolean): Boolean; 
  Key:主键名,是键名全名中除去根键的有的,如Software\Borland\Delphi。 
  CanCreate:在钦赐的主键名不设有时,是或不是同意创造该主键,True表示同意。 
  再次回到值True表示操作成功。 

  3.关门当前主键。 
  在读取或存款和储蓄音信之后,应登时将关闭当前主键:procedure CloseKey。 

  叁 、从注册表中读取信息 
  Read体系措施从注册表读取钦命的音讯(字符串、二进制和十六进制),并转换为钦定的花色。 

  1.Read多级措施。 
  function ReadString(const Name: string): string; 
  读取3个字符串值,Name为字符串名称。 
  function ReadInteger(const Name: string): Integer; 
  读取一个平头值,Name为整数名称。 
  function ReadBinaryData(const Name: string; var Buffer; BufSize:
Integer):Integer; 
  读取二进制值,Name为二进制值名称,Buffer为接收缓冲区,BufSize为缓冲区大小,再次回到为实在读取的字节数。 
  别的措施还有:ReadBool、ReadCurrency、ReadDate、ReadDate提姆e、ReadFloat、ReadTime。 

  2.读取新闻一例(显示Windows的本子)。 
 在HKEY—LOCAL—MACHINE\Software\Microsoft\Windows\CurrentVersion下,有八个字符串值Version、VersionNumber和SubVersionNumber,用于记录当前Windows的版本号。 

  {请在Uses中包含Registry单元} 
  procedure TForm1.Button1Click(Sender:TObject); 
  var 
   ARegistry : TRegistry; 
  begin 
   ARegistry := TRegistry.Create; 
  //建立三个TRegistry实例 
   with ARegistry do 
    begin 
   RootKey := HKEY—LOCAL—MACHINE;//钦点根键为HKEY—LOCAL—MACHINE 
   //打开主键Software\Microsoft\Windows\CurrentVersion 
   if OpenKey( ′Software\Microsoft\Windows\CurrentVersion′,false )
then 
   begin 
   memo1.lines.add(‘Windows版本:′+ ReadString(′Version′)); 
   memo1.lines.add(‘Windows版本号:′+
ReadString(′VersionNumber′)); 
   memo1.lines.add(′Windows子版本号:′+
ReadString(′SubVersionNumber′)); 
   end; 
   CloseKey;//关闭主键 
   Destroy;//释放内部存款和储蓄器 
   end; 
  end; 

  肆 、向注册表中写入新闻 
  Write类别措施将音讯转化为内定的品类,并写入注册表。 

  1.Write多级措施。 
  procedure WriteString(const Name, Value: string); 
  写入二个字符串值,Name为字符串的名目,Value为字符串值。 
  procedure WriteInteger(const Name: string; Value: Integer); 
  写入八个整数值。 
  procedure WriteBinaryData(const Name: string; var Buffer; BufSize:
Integer); 
  写入二进制值,Name为二进制值的名目,Buffer为含有二进制值的缓冲区,BufSize为缓冲区大小。 
  其余格局还有:WriteBool、WriteCurrency、WriteDate、WriteDate提姆e、WriteFloat、WriteTime。 

  2.写入音信一例。 
  上边程序使Delphi随Windows运转而活动运维。 

  var 
   ARegistry : TRegistry; 
  begin 
   ARegistry := TRegistry.Create; 
  //建立一个TRegistry实例 
   with ARegistry do 
   begin 
   RootKey:=HKEY—LOCAL—MACHINE; 
    if
OpenKey(′Software\Microsoft\Windows\CurrentVersion\Run′,True)
then 
   WriteString(′delphi′,′C:\Program
Files\borland\delphi3\bin\delphi32.exe′); 
   CloseKey; 
   Destroy; 
   end; 
  end; 

  ⑤ 、键值维护 
  除了在注册表中读取、存款和储蓄外,程序也许还须求扩充主键、删除主键、主键改名、数据值改名等。 

  1.创立新主键:function CreateKey(const Key: string): Boolean。 
  Key即为主键名,重临值True表示操作成功。 

  2.去除主键:function DeleteKey(const Key: string): Boolean。 
  Key即为主键名,再次回到值True表示操作成功。 

  3.复制或活动主键:procedure MoveKey(const OldName, NewName: string;
Delete: Boolean)。 
  OldName、NewName分别代表源主键名和目的主键名;Delete表示是还是不是删除源主键,True表示删除,False表示保留。 
  复制或移动二个主键将复制或运动该子键下的拥有数据值和子键内容。 

  4.论断钦赐主键是或不是留存,其下是还是不是有主键,并获得主键名称。 
  KeyExists用于判断钦点主键是还是不是留存: 
  function KeyExists(const Key: string):
Boolean;//再次来到值为True表示主键存在。 
  HasSubKeys用于判断钦定主键下是不是有子键:function HasSubKeys:
Boolean; 
  重临值为True表示主键下有子键。 
 GetKeyNames用于获取子键名称:procedure GetKeyNames(Strings:
TStrings); 
 Strings用于重回当前主键下各子键的称号。 

  5.拿走主键下的数据值名称:procedure GetValueNames(Strings:
TStrings)。 
  Strings用于重返当前主键下各数值名称。 
  如要获取当前系统中的拨号连接名称,可应用取得主键HKEY—USE科雷傲S
\.DEFAULT\RemoteAccess\Addresses下的数值名称的艺术来拓展。 

  6.论断数值名称存在、数值名称改名。 
  ValueExists用于判断数值名称是不是存在: 
  function ValueExists(const Name: string): Boolean; 
  再次来到值为True表示数值名称存在。 
  RenameValue用于数值名称改名: 
  procedure RenameValue(const OldName, NewName: string); 

 以上是登记表常用操作所对应的TRegistry的不二法门和属性,其余措施和属性请参见Delphi联机协理文件。 
如上程序在PWIN 98+Delphi 3.0下调节和测试通过。 

2003-11-20 11:53:00 
翻看评语»»» 
贰零零肆-11-20 11:59:20
注册表中对编制程序常用的几项(ODBC/BDE/Internet/Windows) 

本身用的是 WINDOWS 两千, WIN两千 的 REGEDIT 提供了近似 IE
中储藏夹的效益,作者的贮藏夹中有多少个也许对大家编制程序时会有帮扶(那是自己在编制程序进程中的探索出来的,请大师指教): 

1。关于 ODBC 和 DBE: 
HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI\ODBC File DSN 
有你的 COMPUTE奔驰M级 上 ODBC 的 FILE DSN 的存放的缺省路径,如若您建立 FILE
DSN
的时候选取了自个儿的路子,这你就得小心了,系统不会为您保存该路线,你的融洽记住它,:-(; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI\ODBC Drivers 
列出了您的具有 ODBC D昂科雷IVE凯雷德, 
有关 ODBC DTucsonIVE福特Explorer的名目,有三个比较好玩的地方:不知大家又从不用TSession.GetDriverNames
取过系统 ODBC D牧马人IVEOdyssey 名,小编用的时候 D奥迪Q5IVETiguan 名最长只可以取到 三十几个字符,剩下的就被截掉了,不知是本人编制程序有毛病要么 DELPHI 的 BUG; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI 
列出了您的具有 ODBC DSportageIVEHighlander 的事无巨细安顿; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI 
列出了你的具备 SYSTEM DSN 以及它们的布署意况; 

HKEY_CURRENT_USER\Software\ODBC\ODBC.INI 
列出了您的有着 USERAV4 DSN 以及它们的配置情形; 

精晓了以上的多少个主键后,你就足以在先后中贯彻
%SystemRoot%\system32\odbcad32.exe 的多数效应了。 

HKEY_LOCAL_MACHINE\SOFTWARE\Borland\Database Engine 
下边是你的 DBE 的布局,小编就不多说了,大家拿它和 BDE
用户界面一比较就掌握了。 

2。关于 INTERNET 编程: 

HKEY_CLASSES_ROOT\htmlfile 
系统对 HTMLFILE 的处理定义; 

HKEY_LOCAL_MACHINE\SOFTWARE\Clients 
INTE大切诺基NET Option 中 INTE帕杰罗NET PROGRAM 的设定,尤其关键的是里面的 

HKEY_LOCAL_MACHINE\SOFTWARE\Clients\Mail。 

3。关于 WINDOWS 编程 

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run 
历次该用户运行 WINDOWS 必定执行下边包车型大巴吩咐(要是有,当然一般都有), 

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Runonce 
该用户运营 WINDOWS 必定执行下边包车型地铁通令(若是有),执行完后由 WINDOWS
把命令删掉,安装软件的时候特别有用, 

上述两处是针对性特定用户的,在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion
下还有相近的地方,是本着全部用户的,作者就不罗嗦了。 

二零零零-11-20 12:16:38 Delphi 中注册表构件TRegistry 的利用 

在Delphi3.0
及以上版本中,提供了一个构件TRegistry。在先后中得以接纳它来兑现对WIN95/98/NT
注册表的操作,能够很便宜地在注册表中加进、修改和删除键值。那样能够在程序中达成都部队分卓绝的效应。 

—- TRegistry 常用的属性和艺术有(具体效果和用法请参考Delphi 帮 
助): 
RootKey、CreateKey、OpenKey、CloseKey、DeleteKey、ReadXXXX、WriteXXXX 
(XXXX表示数据类型如String、Integer等) 
咱俩用到的属性和艺术有: 

RootKey:注册表的根键名( 如HKEY_LOCAL_MACHINE等) 

OpenKey( KeyName:string; CanCreate:boolean ): 
使当前键为KeyName,CanCreate 表示当内定的键不设有时是或不是创设,True
代表创制 

SetKey( KeyName,KeyValue : string ):使键KeyName的值为KeyValue 

—- 应用之一:让投机的次第随WIN95/98/NT 的起步而运作 
自然,你能够在"运营"程序组中进入程序的连忙格局,但诸如此类做好象一点都不大明智,因为多数程序在设置时不会如此做,而是在经过在注册表增添键值,让WIN95/98/NT
在运转时运营本身的先后。假诺打开注册表,找到HKEY_LOCAL_MACHINE
\Software \Microsoft\Windows \CurrentVersion
\Run,就会发现那些秘密了,原来洋洋自行运转的主次都在此处。你也能够在那里扩充贰个键,让你的次第也乘机
WIN95/98/NT 的启航而团结运营,成为WINDOWS 下的TS兰德本田UR-V程序。达成情势如下: 

首先,在Uses 中加上Registry 单元 

然后,写上边代码。 

{将顺序strExeFileName置为活动运营 } 
function StartUpMyProgram ( strPrompt,strExeFileName : string ) :
boolean; 
var 
registerTemp : TRegistry; 
begin 
registerTemp := TRegistry.Create; 
//建立三个Registry实例 
with registerTemp do 
begin 
RootKey:=HKEY_LOCAL_MACHINE; 
//设置根键值为HKEY_LOCAL_MACHINE 
//找到Software\Microsoft\Windows\CurrentVersion\Run 
if OpenKey(‘Software\Microsoft\Windows\CurrentVersion\Run’,True)
then 
//写入自身程序的快速格局消息 
begin 
WriteString( strPrompt, strExeFileName ); 
result := true; 
end 
else result := false; 
//善后处理 
CloseKey; 
Free; 
end; 
end; 

{调用StartUpMyProgram, 
使Delphi随WINDOWS运转而活动运转 } 
procedure TForm1.Button1Click(Sender: TObject); 
begin 
memo1.lines.add(‘开始’); 
if StartUpMyProgram(‘delphi’,’C:\Program
Files\borland\delphi3\bin\delphi32.exe’) then 
memo1.lines.add(‘成功’) 
else 
memo1.lines.add(‘失败’) 
end; 

—- 应用之二:实现公文关联 
当MS WO卡宴D 安装在你的系统中时,它会把.DOC 文件与和谐涉嫌,当您双击三个DOC
文件,就会运营MS
WO奥迪Q7D,打开你钦点的DOC文件。你也能够把一个文件类型与贰个先后关联起来,其心腹依然在注册表中。即使打开注册表,找到HKEY_CLASSES_ROOT,就会发现那里已经有许多文件类型。 
您也得以在此地扩张三个键,建立友好的文件涉及。 

树立文件涉及,一般应有八个步骤: 

(1)依据文件类型的恢弘名,内定相应的键名(如doc
文件对应的键为doc_auto_file) 
该键及其子键的值,将定义该类型的文本的花色表明和操作(如打开、编辑)表明 

(2)在钦赐的键名下,建立子键,指明文件类型表明和操作对应的主次新闻 
譬如,大家能够为.DBF 文件建立文件涉及,其文件类型表明为"xBase
数据表",使其开拓(Open)文件的操作对应程序C:\ProgramFiles\Borland\DBD\DBD32.EXE。首先,应在注册表的根键HKEY_CLASSES_ROOT
下建立二个键,键名为.DBF,暗中同意值为DBF_Auto_File,表示DBF
类型文件的涉及操作音信记录在键HKEY_CLASSES_ROOT\DBF_Auto_File
下;然后,建立键 
HKEY_CLASSES_ROOT\DBF_Auto_File,并设其私下认可值为"xBase
数据表",表示文件类型表明;再建立键HKEY_CLASSES_ROOT\DBF_Auto_File\Shell\open\command,设置其私下认可值为C:\Program
Files\Borland\DBD\DBD32.EXE  %1(在那之中"%1
"为命令行参数),表示打开操作对应的先后消息。 

具体贯彻如下:同样,在Uses 中丰盛Registry 单元,  然后,写上面代码。 

{将文件类型strFileExtension与程序 
strExeFileName相关联,strDiscription为文件类型表达 } 
function AssignToProgram(strFileExtension,strDiscription,strExeFileName
: string ) : boolean; 
var 
registerTemp : TRegistry; 
begin 
registerTemp := TRegistry.Create; 
//建立3个Registry实例 
with registerTemp do 
begin 
RootKey:=HKEY_CLASSES_ROOT; 
//设置根键值为HKEY_CLASSES_ROOT 
//依照文件类型的扩大名,成立或打开对应的键名.FileExt,如DBF对应’.DBF’ 
if OpenKey( ‘.’ + strFileExtension, true ) then 
begin 
result := false; 
exit; 
end; 
//设置键.FileExt暗中同意值为FileExt_Auto_File,如’.DBF’对应’DBF_Auto_File’ 
WriteString(”,strFileExtension + ‘_Auto_File’); 
CloseKey; 
//写入自个儿程序的消息 
//根据文件类型的扩充名,创立或打开对应的键名 
FileExt_Auto_File 
//’.DBF’对应’DBF_Auto_File’ 
if OpenKey(strFileExtension + ‘_Auto_File’, true ) then 
begin 
result := false; 
exit; 
end; 
//设置暗许值文件类型表明,如DBF可对应’xBase数据表’ 
WriteString(”,strDiscription); 
CloseKey; 
//成立或打开键名FileExt_Auto_File\Shell\open\command,该键为代表操作为’打开’ 
//’.DBF’对应’DBF_Auto_File\shell\open\command’ 
if OpenKey(strFileExtension + ‘_Auto_File\shell\open\command’, true
) then 
begin 
result := false; 
exit; 
end; 
//设置该键的暗中同意值为开辟操作对应的次序新闻 
//如DBF可对应’C:\Program Files\Borland\DBD\DBD32.EXE’ 
WriteString(”,strExeFileName + ‘ %1’); 
CloseKey; 
Free; 
end; 
end; 

{调用AssignToProgram,使DBF文件与DBD32.EXE关联 } 
procedure TForm1.Button3Click(Sender: TObject); 
begin 
memo1.lines.add(‘开始’); 
if AssignToProgram(‘DBF’,’xBase数据表’,’C:\Program
Files\borland\dbd\dbd32.exe’) then 
memo1.lines.add(‘成功’) 
else 
memo1.lines.add(‘失败’) 
end; 

—- 应用之三:检查和测试Win95/98/NT 系统中是不是安装了Borland Database
Engine 
当您的应用程序是3个遵照BDE
的数据库应用程序时,如若运维在2个尚未设置BDE 的Win95/98/NT
中,会产出让用户迷惑不解的荒谬。你大概要求在先后不荒谬化运作在此以前,检查系统中是否安装了BDE。由于
BDE
安装后会在注册表进行登记,你能够透过查询注册表来鲜明系统中是否安装了BDE,然后决定下一步选择什么样行动。BDE
在注册表中的地点为: 
HKEY_LOCAL_MACHINE\Software\Borland\Database Engine,该键存在表明BDE 已经安装。 

切实的事例如下。 

同样,在Uses 中加上Registry 单元 

然后,写下边代码。 

{检查和测试系统中是或不是安装了BDE } 
function IsBDEInstalled : boolean; 
var 
registerTemp : TRegistry; 
begin 
registerTemp := TRegistry.Create; 
//建立3个Registry实例 
with registerTemp do 
begin 
RootKey:=HKEY_LOCAL_MACHINE; 
//设置根键值为HKEY_LOCAL_MACHINE 
//查询Software\Borland\Database Engine 
result := OpenKey(‘Software\Borland\Database Engine’,false); 
//善后甩卖 
CloseKey; 
Free; 
end; 
end; 

{调用IsBDEInstalled,检查和测试系统中是否安装了BDE } 
procedure TForm1.Button4Click(Sender: TObject); 
begin 
memo1.lines.add(‘开始’); 
if IsBDEInstalled then 
memo1.lines.add(‘已设置了BDE’) 
else 
memo1.lines.add(‘未安装BDE’) 
end; 

—- 应用之四:在桌面建立程序的快速情势 
当您的WIN95/98/NT
桌面上整齐地排列着各样程序的连忙情势时,或许你会体会到连忙形式的便利。你也可将协调统一筹划的次序的快速格局放在外人的桌面上。 

桌面上的一个神速格局,对应Windows 目录下Destop 子目录中的三个ShellLink
文件(.LNK),你假诺在那个目录下增添1个.LNK 文件就足以了。 
大家的天职,重若是利用TRegistry 从注册表中获得Desktop
的莫过于路径,默许为Windows 目录下的Desktop
子目录,如C:\PWIN98\Desktop。在注册表中Desktop
的实际上路径对应的键为HKEY_CURRENT_USER \Software\MicroSoft \Windows
\CurrentVersion \Explorer \Shell Folders \Desktop。 

同样,在Uses 中加上Registry 单元 

然后,写上边代码。 

{为顺序strExeFileName在桌面建立迅速格局,运维参数为strParameters } 
function CreateShortcutOnDesktop( strExeFileName, strParameters : string
) : boolean; 
var 
registerTemp : TRegistry; 
strDesktopDirectory : widestring; 
shelllinkTemp : IShellLink; 
persistfileTemp : IPersistFile; 
begin 
registerTemp := TRegistry.Create; 
//建立三个Registry实例 
with registerTemp do 
begin 
RootKey:=HKEY_CURRENT_USER; 
//设置根键值为HKEY_CURRENT_USER 
//找到Software\MicroSoft\Windows\CurrentVersion\Explorer\Shell
Folders 
if not
OpenKey(‘Software\MicroSoft\Windows\CurrentVersion\Explorer\Shell
Folders’,True) then 
//写入自个儿程序的音讯 
begin 
result := false; 
exit; 
end; 
//读取项目Desktop的值,即Desktop的莫过于路径 
strDesktopDirectory := ReadString(‘Desktop’); 
//善后甩卖 
CloseKey; 
Free; 
end; 

//设置快速方式的参数 
shelllinkTemp := IShellLink( CreateComObject(CLSID_ShellLink)); 
with shelllinkTemp do 
begin 
SetPath( PChar( strExeFileName ) ); 
//设置程序文件全名 
SetArguments( PChar( strParameters) ); 
//设置程序的命令行参数 
//设置程序的劳作目录 
SetWorkingDirectory( Pchar( ExtractFilePath( strExeFileName ) ) ); 
end; 

//构造飞速格局的文件名(.LNK) 
strDesktopDirectory := strDesktopDirectory + ‘\’ + ExtractFileName(
strExeFileName ); 
strDesktopDirectory := copy( strDesktopDirectory, 1, length(
strDesktopDirectory ) – length( ExtractFileExt( strExeFileName ) ) ) +
‘.LNK’; 

//保存火速情势的文本 
persistfileTemp := shelllinkTemp as IPersistFile; 
if S_OK = persistfileTemp.Save( PWChar( strDesktopDirectory ) , false )
then 
result := true //保存成功,重临True 
else result := false; 
end; 

{调用CreateShortcutOnDesktop,为Delphi在桌面上建立快速方式 } 
procedure TForm1.Button2Click(Sender: TObject); 
begin 
memo1.lines.add(‘开始’); 
if CreateShortcutOnDesktop(‘C:\Program
Files\borland\delphi3\bin\delphi32.exe’,’%1′) then 
memo1.lines.add(‘成功’) 
else 
memo1.lines.add(‘失败’) 
end; 

【结语】:下边多少个应用只是TRegistry
一些简练的采纳,有了那么些文化,你就足以依据自身的必要来定制和创新Winodws
系统了。 

—- 以上程序在PWin98+Delphi3.0 下调节和测试和通过。 

二〇〇〇-11-20 12:21:25 备份部分注册表的代码 

Procedure ExportRegistryBranch (rootsection : Integer; regroot:String;
filename:String); 

implementation 

Function dblBackSlash(t:string):string; 
var k:longint; 
begin 
result:=t; {Strings are not allowed to have} 
for k:=length(t) downto 1 do {single backslashes} 
if result[k]=’\’ then insert(‘\’,result,k); 
end; 

Procedure ExportRegistryBranch (rootsection : Integer; regroot:String;
filename:String); 
var 
reg:tregistry; 
f:textfile; 
p:PCHAR; 

Procedure ProcessBranch(root:string); {recursive sub-procedure} 
var 
values, 
keys:tstringlist; 
i,j,k:longint; 
s,t:string; {longstrings are on the heap, not on the stack!} 
begin 
writeln(f); {write blank line} 
case rootsection of 
HKEY_CLASSES_ROOT : s := ‘HKEY_CLASSES_ROOT’; 
HKEY_CURRENT_USER : s := ‘HKEY_CURRENT_USER’; 
HKEY_LOCAL_MACHINE : s := ‘HKEY_LOCAL_MACHINE’; 
HKEY_USERS : s := ‘HKEY_USERS’; 
HKEY_PERFORMANCE_DATA: s := ‘HKEY_PERFORMANCE_DATA’; 
HKEY_CURRENT_CONFIG : s := ‘HKEY_CURRENT_CONFIG’; 
HKEY_DYN_DATA : s := ‘HKEY_DYN_DATA’; 
end; 

Writeln(f,'[‘+s+’\’+root+’]’); {write section name in brackets} 
reg.OpenKey(root,false); 
values := tstringlist.create; 
keys:=tstringlist.create; 
reg.getvaluenames (values); {get all value names} 
reg.getkeynames (keys); {get all sub-branches} 
for i:=0 to values.count-1 do {write all the values first} 
begin 
s := values[i]; 
t := s; {s=value name} 
if s= ”then 
s:=’@’ {empty means “default value”, write as @} 
else 
s:='”‘ + s + ‘”‘; {else put in quotes} 
write(f,dblbackslash(s)+ ‘=’ ); {write the name of the key to the
file} 
Case reg.Getdatatype(t) of {What type of data is it?} 
rdString, 
rdExpandString: {String-type} 
Writeln(f,'”‘ + dblbackslash(reg.readstring(t) + ‘”‘)); 
rdInteger: {32-bit unsigned long integer} 
Writeln(f,’dword:’ + inttohex(reg.readinteger(t),8)); 
{ write an array of hex bytes if data is “binary.” Perform a line feed
after approx. 25 numbers so the line length stays within limits } 
rdBinary : 
begin 
write(f,’hex:’); 
j := reg.getdatasize(t); {determine size} 
getmem(p,j); {Allocate memory} 
reg.ReadBinaryData(t,p^,J); {read in the data, treat as pchar} 
for k:=0 to j-1 do begin 
Write(f,inttohex(byte(p[k]),2)); {Write byte as hex} 
if k<>j-1 then {not yet last byte?} 
begin 
write(f,’,’); {then write Comma} 
if (k>0) and ((k mod 25)=0) then {line too long?} 
writeln(f,’\’); {then write Backslash + lf} 
end; {if} 
end; {for} 
freemem(p,j); {free the memory} 
writeln(f); {Linefeed} 
end; 
ELSE 
writeln(f,'””‘); {write an empty string if datatype illegal/unknown} 
end; {case} 
end; {for} 
reg.closekey; 

{value names all done, no longer needed} 
values.free; 

{Now al values are written, we process all subkeys} 
{Perform this process RECURSIVELY…} 
for i := 0 to keys.count -1 do 
ProcessBranch(root+’\’+keys[i]); 
keys.free; {this branch is ready} 
end; 

begin 
if regroot[length(regroot)]=’\’ then {No trailing backslash} 
setlength(regroot,length(regroot)-1); 
Assignfile(f,filename); {create a text file} 
rewrite(f); 
IF ioresult<>0 then 
EXIT; 
Writeln(f,’REGEDIT4′); {“magic key” for regedit} 
reg:=tregistry.create; 
try 
reg.rootkey:=rootsection; 
ProcessBranch(regroot); {Call the function that writes the branch and
all subbranches} 
finally 
reg.free; {ready} 
close(f); 
end; 
end; 

end. 

二〇〇一-11-20 12:22:54 读写互连网上其它计算机注册表的代码 

procedure NetReg; 
var 
R: TRegistry; 
S: TStringList; 
begin 
R:=TRegistry.Create; 
S:=TStringList.Create; 
WriteLn(R.RegistryConnect(‘\\OtherPC’)); 
WriteLn(R.OpenKeyReadOnly(‘Software’)); 
R.GetKeyNames(S); 
WriteLn(S.CommaText); 
S.Free; 
R.Free; 
end; 

二〇〇〇-11-20 12:27:06 关于查看注册表的程序 

unit regform; 
interface 
uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Registry; 
type 
TForm1 = class(TForm) 
ListSub: TListBox; 
ListValues: TListBox; 
ComboKey: TComboBox; 
Label1: TLabel; 
Label2: TLabel; 
Label3: TLabel; 
Label4: TLabel; 
ComboLast: TComboBox; 
procedure FormCreate(Sender: TObject); 
procedure FormDestroy(Sender: TObject); 
procedure ListSubClick(Sender: TObject); 
procedure ComboKeyChange(Sender: TObject); 
procedure ComboLastChange(Sender: TObject); 
private 
Reg: TRegistry; 
public 
procedure UpdateAll; 
end; 
var 
Form1: TForm1; 
implementation 

{$R *.DFM} 

procedure TForm1.FormCreate(Sender: TObject); 
begin 
Reg := TRegistry.Create; 
Reg.OpenKey (‘\’, False); 
UpdateAll; 
// select the current root(选拔当前的根目录) 
ComboKey.ItemIndex := 1; 
ComboLast.Items.Add(‘\’); /////// 
ComboLast.ItemIndex := 0; 
end; 

//更新 
procedure TForm1.UpdateAll; 
begin 
Caption := Reg.CurrentPath; 
if Caption = ‘ then 
Caption := ‘[Root]’; 
if Reg.HasSubKeys then 
Reg.GetKeyNames(ListSub.Items) 
else 
ListSub.Clear; 
Reg.GetValueNames(ListValues.Items); 
end; 

procedure TForm1.FormDestroy(Sender: TObject); 
begin 
Reg.CloseKey; 
Reg.Free; 
end; 

procedure TForm1.ListSubClick(Sender: TObject); 
var 
NewKey, Path: string; 
nItem: Integer; 
begin 
// get the selection(获取选取项) 
NewKey := ListSub.Items [ListSub.ItemIndex]; 
Reg.OpenKey (NewKey, False); 
// save the current path (eventually adding a
\)(在不列出于列表时保留路径) 
// only if the it is not already listed 
Path := Reg.CurrentPath; 
if Path < ‘\’ then 
Path := ‘\’ + Path; 
nItem := ComboLast.Items.IndexOf (Path); 
if nItem < 0 then 
begin 
ComboLast.Items.Insert (0, Path); 
ComboLast.ItemIndex := 0; 
end 
else 
ComboLast.ItemIndex := nItem; 
UpdateAll; 
end; 

procedure TForm1.ComboKeyChange(Sender: TObject); 
begin 
case ComboKey.ItemIndex of 
0: Reg.RootKey := HKEY_CLASSES_ROOT; 
1: Reg.RootKey := HKEY_CURRENT_USER; 
2: Reg.RootKey := HKEY_LOCAL_MACHINE; 
3: Reg.RootKey := HKEY_USERS; 
4: Reg.RootKey := HKEY_CURRENT_CONFIG; 
5: Reg.RootKey := HKEY_DYN_DATA; 
end; 
Reg.OpenKey (‘\’, False); 
UpdateAll; 
ComboLast.Items.Clear; 
end; 

procedure TForm1.ComboLastChange(Sender: TObject); 
begin 
Reg.OpenKey (ComboLast.Text, False); 
UpdateAll; 
end; 

end. 

二零零一-11-20 13:30:00 获得注册表项下的拥有值 

Var 
Reg : TRegistry; 
list : TStrings; 
i : Integer; 

Begin 
Reg:=TRegistry.Create; 
Reg.RootKey:=’HKEY_LOCAL_MACHINE’; 
If Reg.OpenKey(‘\Software\Microsoft\CurrentVersion\Run’, false)
then 
Begin 
List:=TStringList.Create; 
Reg.GetValueNames(List); 
For i:=0 to list.Count-1 do 
If Reg.ValueExists(List[i]) then 
Begin 
Case Reg.GetDataType(List[i]) of rdInteger:
Reg.ReadInteger(List[i]); 
rdBinary: Reg.ReadBinaryData(List[i]); 
else 
Reg.ReadString(List[i]); 
End; 
End; 
End; 

二零零四-11-20 13:38:19 采取Windows API 函数和注册表获取系统消息 

在付出应用程序时,增添一项呈现总计机种类消息的职能,例如已安装的软盘、硬盘、光驱、网络驱动器,硬盘的容积和剩下空间,显示器分辨率、键盘类型、鼠标的键数,内部存款和储蓄器大小、CPU
类型,Windows
的本子号、产品标识、注册用户单位名和用户名、当前操功效户名等(
见运维图示),当然还有更多的音信,这样会使你的次第更要好。其实,有为数不少应用程序正是这样做的。 

经过调用Windows 的API 函数和走访Windows
注册表,能够获得多量的系统音讯。Delphi 为绝大部分Windows API
函数提供了调用接口( 可参见DELPHI3\SOURCE\RTL\WIN\windows.pas
文件),并提供了3个功效健全的TRegistry 类,使大家能够一本万利的调用Windows
API 函数和做客注册表,例如: 

一 、function GetDriveType(lpRootPathName: PChar): UINT;
重回钦点驱动器的类型。 

二 、function GetDiskFreeSpace(lpRoot帕特hName: PChar; var
lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters,
lpTotalNumberOfClusters: DWOLacrosseD): BOOL;
再次回到钦定驱动器的总簇数、剩余簇数及每簇扇区数、每扇区字节数,从而得以测算出总体量和剩 
余空间。 

3、function GetSystemMetrics(SM_CXSCREEN或 SM_CYSCREEN): Integer;
重回显示器分辨率。 

4、function GetSystemMetrics(SM_CMOUSEBUTTONS): Integer;
再次回到鼠标的按键数目。 

伍 、在windows
注册表的HKEY_LOCAL_MACHINE\software\microsoft\windows\currentversion
\RegisteredOwner 主键下存放着Windows 安装时输入的用户名,
可用以下语句读取。 

myreg:=Tregistry.Create; 
//必须在先后单元的uses部分加入Registry 
myreg.RootKey:=HKEY_LOCAL_MACHINE; 
if myreg.openkey(‘software\microsoft\windows\currentversion’,false)
then 
memo1.lines.add(‘ 注册用户名:’+myreg.readstring(‘RegisteredOwner’)); 
myreg.closekey; 
以上仅举几例,获取别的一些音讯的措施与此类似,详见源程序。 

本程序在Pwin9五 、Delphi3 下调节和测试通过。 

【附】: 源程序清单。 

unit Unit1; 

interface 

uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, 
StdCtrls,Registry; 

type 
TForm1 = class(TForm) 
Button1: TButton; 
Memo1: TMemo; 
procedure Button1Click(Sender: TObject); 

private 
{ Private declarations } 

public 
{ Public declarations } 
end; 

var 
Form1: TForm1; 

implementation 

{$R *.DFM} 

procedure TForm1.Button1Click(Sender: TObject); 
var i,x,y:integer; 
ch:char; 
//驱动器字符’A’~’Z’ 
buffer:string; 
cpuinfo:TSYSTEMINFO; 
//存放系统音讯的笔录类型,在Windows.pas中查到详细内容。 
meminfo:TMemoryStatus; 
//存放系统内部存款和储蓄器新闻的记录类型。 
computername,username:pchar; 
//计算机名称、用户名 
spc,bps,nofc,tnoc:longint; 
//用于存放磁盘体量的变量 
myreg:Tregistry; 
//用于访问注册表的TRegistry变量 

begin 
memo1.Lines.Clear; 
for ch:=’A’ to ‘Z’ do begin 
i:=getdrivetype(pchar(ch+’:\’)); 
buffer:=’ ‘+ch+’: ‘; 
case i of 
DRIVE_UNKNOWN : buffer:=buffer+’未知类型’; 
DRIVE_REMOVABLE: buffer:=buffer+’软盘’; 
DRIVE_FIXED : begin 
buffer:=buffer+’硬盘’; 
if getdiskfreespace(pchar(ch+’:\’),spc,bps,nofc,tnoc) then begin 
buffer:=buffer+’总容量:’+inttostr((spc*bps*tnoc) div
(1024*1024))+’MB’; 
buffer:=buffer+’剩余:’+inttostr((spc*bps*nofc) div
(1024*1024))+’MB’; 
end; 
end; 
DRIVE_REMOTE : buffer:=buffer+’互联网驱动器’; 
DRIVE_CDROM :buffer:=buffer+’CD-ROM驱动器’; 
DRIVE_逍客速龙ISK:buffer:=buffer+’RAM虚拟驱动器’; 
end; 
if (ch >’D’) and (i=1) then break; 
if i< >1 then memo1.Lines.Add(buffer); 
end; 

case getkeyboardtype(0) of //获取键盘类型 
1: buffer:=’ 键盘: IBM PC/XT或包容类型(83键)’; 
2: buffer:=’ 键盘: Olivetti “ICO”(102键)’; 
3: buffer:=’ 键盘: IBM PC/AT(84键)’; 
4: buffer:=’ 键盘: IBM增强型(101或102键)’; 
5: buffer:=’ 键盘: Nokia 1050′; 
6: buffer:=’ 键盘: Nokia 9140′; 
7: buffer:=’ 键盘: Japanese’; 
end; 
memo1.lines.add(buffer); 

//获取键盘作用键数目 
memo1.lines.add(‘ 功效键数目:’+inttostr(getkeyboardtype(2))); 
memo1.Lines.add(‘显示屏分辨率:’+inttostr(getsystemmetrics(SM_CXSCREEN)) 
+’x’+inttostr(getsystemmetrics(SM_CYSCREEN))); 

//获取鼠标按键数目 
memo1.Lines.add(‘
鼠标:’+inttostr(getsystemmetrics(SM_CMOUSEBUTTONS))+’键’); 

globalmemorystatus(meminfo); //获取系统内部存款和储蓄器数量 
memo1.lines.add(‘ 物理内存:’+inttostr(meminfo.dwTotalPhys div 1024)+’
KB’); 
i:=getsystemmetrics(SM_CLEANBOOT); 
case i of 
0:buffer:=’系统运行格局:正常形式’; 
1:buffer:=’系统运转形式:尊崇方式’; 
2:buffer:=’系统运维形式:互联网尊崇形式’; 
end; 
memo1.lines.add(buffer); 
x:=getsystemmetrics(SM_ARRANGE); 

//获取系统最小化窗口的序幕地点和排列格局 
y:=x; 
x:=x and 3; 
y:=y and 12; 
case x of 
ARW_BOTTOMLEFT : buffer:=’ 最小化窗口:自左下角’; 
ARW_BOTTOM中华VIGHT : buffer:=’ 最小化窗口:自右下角’; 
ARW_TOPLEFT : buffer:=’ 最小化窗口:自左上角’; 
ARW_TOP帕杰罗IGHT : buffer:=’ 最小化窗口:自右上角’; 
end; 
case y of 
ARW_LEFT : buffer:=buffer+’横向排列’; 
ARW_UP : buffer:=buffer+’纵向排列’; 
ARW_HIDE : buffer:=buffer+’隐藏’; 
end; 
memo1.lines.add(buffer); 

getmem(computername,255); //获取总计机名称和用户名 
getmem(username,255); 
i:=255; 
getcomputername(computername,i); 
memo1.lines.add(‘ 计算机名称: ‘+computername); 
getusername(username,i); 
memo1.lines.add(‘ 用户名: ‘+username); 
freemem(computername); 
freemem(username); 

getsysteminfo(cpuinfo); //获取CPU类型 
case cpuinfo.dwProcessorType of 
386 : buffer:=’ CPU类型: 386′; 
486 : buffer:=’ CPU类型: 486′; 
586 : buffer:=’ CPU类型: Pentium’; 
end; 
memo1.Lines.add(buffer); 

//从注册表中收获CPU标识,Windows版本,产品标识,注册单位名称及用户名 
myreg:=Tregistry.Create; 
myreg.RootKey:=HKEY_LOCAL_MACHINE; 
if
myreg.OpenKey(‘hardware\description\system\centralprocessor\0’,false)
then 
memo1.lines.add(‘ CPU标识:’+myreg.ReadString(‘VendorIdentifier’)); 
myreg.closekey; 
if myreg.openkey(‘software\microsoft\windows\currentversion’,false)
then begin 
memo1.lines.add(‘ windows版本:’+myreg.ReadString(‘Version’)); 
memo1.lines.add(‘
版本号:’+myreg.ReadString(‘VersionNumber’)+”+myreg.ReadString(‘Subversionnumber’)); 
memo1.lines.add(‘ 产品标识:’+myreg.Readstring(‘ProductID’)); 
memo1.lines.add(‘注册单位名称:’+myreg.readstring(‘RegisteredOrganization’)); 
memo1.lines.add(‘ 注册用户名:’+myreg.readstring(‘RegisteredOwner’)); 
end; 
myreg.CloseKey; 
myreg.Free; 
end; 
end. 

2002-11-20 13:44:20 注册表配置ODBC的详实例子 

【思路】:先在ODBC中配置然后到注册表中去看有啥扩展,然后照样写进去就足以了,不过那样做有三个题材,SQL
Server默许是用命名管道,倘诺要用TCP/IP协议请在注册表中找1433,就能找到它是在那里.照样写进去就OK了。 
var 
reg : TRegistry; 
begin 
reg := TRegistry.Create; 
//建立一个Registry实例 
with reg do 
begin 
RootKey:=HKEY_LOCAL_MACHINE; 
//设置根键值为HKEY_LOCAL_MACHINE 
//找到Software\ODBC\ODBC.INI\ODBC Data Sources 
if OpenKey(‘Software\ODBC\ODBC.INI\ODBC Data Sources’ True) then 
begin 
//注册贰个DSN名称 
WriteString( ‘DSN’ ‘SQL Server’ ); 
end 
else 
begin 
//创立键值退步 
ShowMessage(‘增添ODBC数据源战败’); 
exit; 
end; 
CloseKey; 
//找到或创设Software\ODBC\ODBC.INI\masdsn 写入DSN配置音讯 
if OpenKey(‘Software\ODBC\ODBC.INI\DSN’ True) then 
begin 
WriteString( ‘Driver’ ‘C:\Windows\System\sqlsrv32.dll’ ); 
WriteString( ‘LastUser’ ‘Username’ ); 
WriteString( ‘Password’ ‘password’ ); 
WriteString( ‘Server’ ‘ServerName’ ); 
end 
else 
//创造键值失利 
begin 
Showmessage(‘扩展ODBC数据源战败’); 
exit; 
end; 
CloseKey; 
Free; 
ShowMessage(‘扩张ODBC数据源成功’); 
end; 

//以上程序是写到system里的,当然同样能够写到当前用户里! 

二零零零-11-20 13:50:20 通过注册表读取设置字体 

unit Unit1; 

interface 

uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Registry; 

type 
TForm1 = class(TForm) 
Button1: TButton; 
Button2: TButton; 
procedure WriteFontToRegistry(Sender: TObject); 
procedure FormCreate(Sender: TObject); 
procedure ReadFontFromRegistry(Sender: TObject); 
procedure FormDestroy(Sender: TObject); 
private 
{ Private-Deklarationen } 
Font : TFont; 
public 
{ Public-Deklarationen } 
end; 

var 
Form1: TForm1; 

implementation 

{$R *.DFM} 

type 
TFontRegData = record 
Name : string[100]; 
Size : integer; 
Color : TColor; 
Style : set of TFontStyle; 
Charset : byte; 
Height : integer; 
Pitch : TFontPitch; 
PixelsPerInch : integer; 
end; 

// Before writing font data to the registry you have to copy all needed
data to a record of fixed size 

procedure PrepareFontDataForRegistry(Font : TFont;var RegData :
TFontRegData); 
begin 
{ Copy font data to record for saving to registry } 
//复制字体数据到记录并保存到注册表中 
with RegData do 
begin 
Name:=Font.Name; 
Size:=Font.Size; 
Color:=Font.Color; 
Style:=Font.Style; 
Charset:=Font.Charset; 
Height:=Font.Height; 
Pitch:=Font.Pitch; 
PixelsperInch:=Font.PixelsPerInch; 
end; 
end; 

procedure PrepareFontfromRegData(Font : TFont;RegData :
TFontRegData); 
begin 
{ Set font data to values read from registry } 
//设置来自注册表的字体数据的值 
with Font do 
begin 
Name:=RegData.Name; 
Size:=RegData.Size; 
Color:=RegData.Color; 
Style:=RegData.Style; 
Charset:=RegData.Charset; 
Height:=RegData.Height; 
Pitch:=RegData.Pitch; 
PixelsperInch:=RegData.PixelsPerInch; 
end; 
end; 

//初始化 
procedure TForm1.FormCreate(Sender: TObject); 
begin 
Font:=TFont.Create; 
Font.Name:=’Arial’; 
end; 

//写入注册表 
procedure TForm1.WriteFontToRegistry(Sender: TObject); 
var 
rd : TFontRegData; 
reg : TRegistry; 

begin 
PrepareFontDataForRegistry(Font,rd); 
Reg:=TRegistry.Create; 
Reg.OpenKey(‘Software\Test’,true); 
Reg.WriteBinaryData(‘FontData’,rd,Sizeof(rd)); 
reg.Free; 
end; 

//从注册表中读取字体设置值 
procedure TForm1.ReadFontFromRegistry(Sender: TObject); 
var 
rd : TFontRegData; 
reg : TRegistry; 

begin 
Reg:=TRegistry.Create; 
Reg.OpenKey(‘Software\Test’,true); 
if Reg.ValueExists(‘FontData’) then 
Reg.ReadBinaryData(‘FontData’,rd,Sizeof(rd)); 
reg.Free; 
PrepareFontFromRegData(Font,rd); 
end; 

procedure TForm1.FormDestroy(Sender: TObject); 
begin 
Font.Free; 
end; 

end. 

贰零零肆-11-20 13:56:06 系统登记表读写操作的例子代码 

操作注册表必要认识到注册表的两个根键。看看DELPHI的概念: 
const 
{ Reserved Key Handles. } 
{$EXTERNALSYM HKEY_CLASSES_ROOT} 
HKEY_CLASSES_ROOT = DWORD($80000000); 

{$EXTERNALSYM HKEY_CURRENT_USER} 
HKEY_CURRENT_USER = DWORD($80000001); 

{$EXTERNALSYM HKEY_LOCAL_MACHINE} 
HKEY_LOCAL_MACHINE = DWORD($80000002); 

{$EXTERNALSYM HKEY_USERS} 
HKEY_USERS = DWORD($80000003); 

{$EXTERNALSYM HKEY_PERFORMANCE_DATA} 
HKEY_PERFORMANCE_DATA = DWORD($80000004); 

{$EXTERNALSYM HKEY_CURRENT_CONFIG} 
HKEY_CURRENT_CONFIG = DWORD($80000005); 

{$EXTERNALSYM HKEY_DYN_DATA} 
HKEY_DYN_DATA = DWORD($80000006); 
它们必须在TRegistry变量的RootKey属性中钦定。 
要取得某3个途径的某部键值,必须找到某2个主键,例如有如下1个门路存放着WO揽胜D97存放的顺序路径: 
\Software\Microsoft\Office\8.0\Word\InstallRoot\Path 
其间,PATH是键,在它前边的就是主键(键的门道),而这几个键又是放在HKEY_LOCAL_MACHINE那些根键中的。当然,我们想要的是PATH对应的数码,而不是想清楚有PATH那么些键存在。PATH的门类是二个字符串,所以必要二个字符串变量存放它,例程中央银行使直接浮现的法门表明它。 
为此,读出PATH键数据的经过就相应是,明确根键,进入主键(路径),读出键的数据值。为了显示对注册表的写操作,大家还专程成立2个主键\Software\3hsoft和个中一个字符串的键MyData。 

上边是一小段有关此进度的次序,即便内容不多,但大多已经将读写的操作表现出来了。 

unit Unit1; 

interface 

uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Registry; // 记得要投入这一个革命的。 

type 
TForm1 = class(TForm) 
Button1: TButton; 
procedure Button1Click(Sender: TObject); 
end; 

var 
Form1: TForm1; 

implementation 

{$R *.DFM} 

procedure TForm1.Button1Click(Sender: TObject); 
Const 
FPath = ‘\Software\Microsoft\Office\8.0\Word\InstallRoot’; 
FKey = ‘Path’; 
FMyPath = ‘\Software\3hSoft’; 
FMyKey = ‘MyData’; 
Var 
Reg : TRegistry; 
begin 
Reg := TRegistry.Create; 
try 
Reg.RootKey := HKEY_LOCAL_MACHINE; 
If Reg.OpenKey(FPath, False) then 
ShowMessage(Reg.ReadString(FKey)); // 读出的 WinWord
的不二法门就显示出来了。 
Reg.CreateKey(FMyPath); // 创立我们的主键 
Reg.OpenKey(FMyPath, True); // 进入大家和好的主键中 
Reg.WriteString(FMyKey, ‘This is a registry operation test
program.’); 
// 写进键值。 
finally 
Reg.Free; // 用 Try..Finally 结构确定保障 REG 变量能够释放。 
end; 
end; 

end. 

2001-11-20 14:02:11 用注册表对Delphi程序开始展览加密 

  本加密方法分三片段: 
  1. 依照对注册表的查找结果判定设置对话框的情节。 
  2. 若首先使用,则设新密码;假如已经安装密码,则开始展览求证。 
  3.
一个密码变换小程序(比原来的错综复杂得多)。当然,借使急需修改密码的效益,只要将安装密码部分改动一下即可。 

  一 、程序运行时,通过搜索注册表,判断是或不是已有密码,来规定窗口的展现内容。不过先期应有以下的宣示然后才能动用: 
  在user中投入TRegistry,在var注解中投入以下多少个窗体变量: 
var 
  TheReg: TRegistry; 
  KeyName,ValueStr,tempStr:String; 
   procedure TfrmPass.FormShow(Sender: TObject); 
  begin 
   TheReg := TRegistry.Create; 
   try TheReg.RootKey := HKEY-LOCAL-MACHINE; 
   KeyName := ′SOFTWARE\Mypassword′; 
   //有该键则打开,没有则创建 
   if TheReg.OpenKey(KeyName, True) then begin 
   tempStr:=ExtractFileName(Application.ExeName); //读取密码 
   ValueStr:=TheReg.ReadString(tempStr); 
   //密码不为空则修改窗体为申明密码 
   if ValueStr<>′′ then begin 
   edit2.Visible:=false; frmPass.Caption:=′验证密码′; 
  edit1.SetFocus; OK.Caption:=′确定′; 
end 
   //密码为空则修改窗体为设置密码对话框 
   else begin 
   showmessage(′第①回选拔请设置密码!′); 
   edit2.Visible:=true; frmPass.Caption:=′请设置新密码′; 
   edit1.SetFocus; OK.Caption:=′设置′; 
   end; 
TheReg.CloseKey; 
end; 
   finally 
TheReg.Free; 
end; 
end; 
  贰 、按钮的响应代码:包罗新设密码和注明密码。 
  procedure TfrmPass.OKClick(Sender: TObject); 
  begin 
   //依据艾德it2的展示与否判断已有密码,举行验证 
   if edit2.Visible=false then begin 
   if pass(edit1.text)=ValueStr then begin 
   showmessage(′密码正确!′); 
end 
   else begin 
   showmessage(′密码不得法!无权操作!′); 
   halt; 
end; 
end //无密码,设置新密码 
   else begin 
   if edit1.text=edit2.text then begin 
   TheReg := TRegistry.Create; 
   TheReg.RootKey := HKEY-LOCAL-MACHINE; 
   KeyName := ′SOFTWARE\Mypassword′; 
   if TheReg.OpenKey(KeyName, True) then 
   TheReg.WriteString(tempStr,pass(edit1.text)); 
   TheReg.CloseKey; 
end 
   else begin 
   showmessage(′再一次键入的密码分裂,请重输!′); 
   edit1.text:=′′; edit2.text:=′′; 
   edit1.SetFocus; 
end; //实行下一步操作… 
   end; 
end; 
  三 、密码变换程序:注意要事先定义。 
  这么些变换小程序在小编看来还不算很复杂,只举行了一回变换,可是,想要破译也是得费点劲。读者还能运用别的的数学函数举办进一步复杂的变换。 
  function pass(pstr:string):string; 
  var str,str1:string; 
  i,j:integer; 
  begin 
   str:=pstr; 
   for i:=1 to length(str) do begin 
  //实行第3回变换 
   j:=(i*i*i mod (i+20))+(i*i mod (i+10))+i*2+1; 
   str1:=str1+chr(ord(str[i])+j); //第三遍变换 
   j:=(i*i*i mod (i+10))+(i*i mod (i+20))+i*2+1; 
   str1:=str1+chr(ord(str[i])+j); end; 
   pass:=str1; 
  end; 

2001-11-20 14:06:55 使Delphi程序回忆参数的安装 【王伟】 

大家日常用的过多软件都抱有局地回忆功能,如foxmail和TheBat等等。那些软件能在运转时自动的保持上贰回关闭软件时的一些景况,如窗口的发端地点,用户在软件中设置的部分特色(如窗口作风,横相排列依然竖相排列等等),即使能让大家的先后也负有如此的局地效果能够使大家先后看起来更专业性一些:)
那里笔者就来讲一下怎么使应用程序能记住上贰回关闭时的窗口地方,并在下1次运行时和上贰次的职责一样。
既是要保留音信,就必将要涉及到存贮的题材。数据的储备有少数种艺术,能够写.ini 
或.inf文件,还足以用Delphi提供的文书类来自定义1个文书,仍是能够用数据库接口(如ODBC) 
引入一种数据库文件,foxpro
的.dbf和Access的.mdb比较常用,还足以一贯往Windows的挂号表里写。写.ini和.inf文件没有其余的安全性,且不吻合win95,还记得在94,95年时用汉语的Windows3.第22中学山大学量的采用了.ini文件,但Windows95出现后,微软提出尽量的把音讯写到注册表中。用ODBC的话会给程序带来很多不须要的麻烦,如会使程序更为错综复杂,要求相应的DBMS的驱动程序的扶助,借使没有对号入座数据源的驱动程序,则该数据源就不可能动用,还有安全性难题也无法很好的解决。 
在这里推荐应用写注册表的点子。因为那种办法很便宜,不需太多额外的开支,程序比较简 
单,对一般的用户来说在注册表里找到有效的音讯比打开.ini文件要麻烦的多。所以注册表的安全性比.ini文件要略强一些。 
使应用程序能记住上3回关闭时的窗口岗位,并在这一回运行时和上2遍的职位一样。总体 
思路是那样的:在关闭程序时要记录下此次程序甘休时的音讯,写入注册表中,在下次程序运维 
时读注册表中相应音信,并赋给程序。 
对于大家这几个程序来说任重(Ren Zhong)而道远需求记录的音信是窗口关闭时的Top,Left,Height,Width。 
注意:要想使Delphi可以操作注册表,必须总结registry单元。 

以下是源程序和相关心释: 
unit Unit1; 

interface 

uses 
Windows, Messages,. . . . . . . ,registry; //包括registry单元 
type 
TForm1 = class(TForm) 

public 
ww:TRegistry; 
//声雀巢(Nestle)个TRegistry对象,大家就由此ww来落成对注册表的操作 

//运行窗口时要做的有的工作 
procedure TForm1.FormCreate(Sender: TObject); 
begin 
ww:=TRegistry.Create; 
//创建ww对象 
ww.RootKey :=HKEY_CURRENT_USER; 
//注意:通过修改RootKey可以把音讯写到注册表的每贰个角落 
ww.OpenKey(‘software’,FALSE); 
//打开键software,能够观看Borland,Netscape,还有Microsoft也在那么些software键中 
ww.CreateKey( ‘王伟’); 
//在software键中创立一个名为“王伟“的键值,使和谐的名字和Borland,Netscape, 
//Microsoft并排在一起,是否很Cool啊:) 
ww.OpenKey( ‘王伟’,FALSE); 
//打开键”王伟” 
ww.CreateKey(‘XX单位XX管理系统’); 
//创制应用程序的名称 
ww.OpenKey(‘XX单位XX管理系统’,TRUE); 
ww.CreateKey(‘位置’); 
//创设应用程序中某3个要储备的种类的名称,便于管理 
ww.OpenKey(‘位置’,TRUE); 
if (ww.ReadString(‘first’)<>’1′)then 
//那是值得注意的1个地点,通过“first“来判断程序是不是 
begin 
//是首先次写注册表,若是是率先次写则用程序给的暗许值来 
ww.WriteString(‘first’,’1′); 
//设置窗口的职位和尺寸。假如不是第三次运行应用程序则表达 
Form1.WindowState:=(wsNormal); 
//注册表中早已写了职分消息,就读那几个音讯并赋给Form。 
Form1.Top:=10; 
form1.Left:=10; 
form1.Height:=100; 
form1.Width:=100; 
end 
else 
begin 
if(ww.ReadString(‘max’)=’y’) then 
//判断上次关闭程序时,窗口是或不是是最大化的。如若是的话,则
Form1.WindowState:=(wsMaximized) 
//继续使窗口拥有这一风味。 
else 
begin 
Form1.top:=StrToInt(ww.ReadString(‘top’)); 
//假如不是最大化,则取地点和尺寸数据赋给From 
Form1.left:=StrToInt(ww.ReadString(‘left’)); 
Form1.height:=StrToInt(ww.ReadString(‘height’)); 
Form1.width:=StrToInt(ww.ReadString(‘width’)); 
end; 
end; 
end; 

//关闭窗口时要做的一部分工作 
procedure TForm1.FormDestroy(Sender: TObject); 
begin 
ww.OpenKey(‘位置’,FALSE); 
//打开“位置”键 
if Form1.WindowState=(wsMaximized) then 
//要是当前程序是最大化,则把这一音信写入注册表, 
ww.WriteString(‘max’,’y’) 
//便于下2次时利用。 
else 
begin 
ww.WriteString(‘max’,’n’); 
//假使不是最大化,则把窗口的岗位和分寸数据写入注册表中。 
ww.WriteString(‘top’,IntToStr(Form1.top)); 
ww.WriteString(‘left’,IntToStr(Form1.left)); 
ww.WriteString(‘height’,IntToStr(Form1.Height)); 
ww.writeString(‘width’,IntToStr(Form1.Width)); 
end; 
end; 

【须求留意的几点】: 
1:因为程序不容许在首先次使用时,就从注册表里读数据,所以率先次必须由程序赋三个 
初值。然后做上标记,表示早已有过第一次了,今后假使判断出不是首先次了,就足以读数据 
了。(这一点最注重,由那或多或少还足以引出八个话题,那就是能够做2个德姆o版的软件,每回运转时往注册表里加个1,当>10时,就不许用该软件了,cool吧) 

2:往注册表里能够写string型数据,也得以写Integer型数据,但在注册表中的Integer型数据是以16进制格局存在的,而作者辈在先后中用的都以10进制数,所以索性写string型,然后用StrToInt或IntToStr转换。

3:写注册表并不是很安全的,它的内容能够用Reg艾德it一览无佘的看来,所以绝对无法将有个别重庆大学的音信(如密码)不经加密而直接写入注册表,那样做是卓殊危急的!! 

2004-11-20 14:22:10 在DELPHI程序中动态设置ODBC数据源(使用注册表) 

【编辑者说】: 
那一个咚咚写得正确,比下边的十二分尤其详实,如果地点的十一分看不晓得就看那些呢,应该能看懂的啊,要不然…. 

在DELPHI数据库应用程序中,我们走访数据库一般有二种方法.一种是透过BDE数据库搜索引擎,即利用DELPHI自带的数据库驱动程序,那种办法的独到之处是速度快,但使用范围有限,当数据库版本更新时,有大概还是无法用于操作新的数据库;另一种艺术是透过ODBC,这种方法的优点是足以随操作系统(如WINDOWS)提供,作为标准接口能适应种种数据库,缺点是速度慢.在编制程序时,大家得以依据须求选择中间的一种方法. 

在采纳ODBC访问数据库时,平时的情势时是在ODBC管理面板中安装贰个ODBC系统数据源
(系统DSN),然后在DBD中或在程序中装置二个数据库别名(阿里as)对相应DSN,那样就足以万事大吉地操作数据库了.相信用DELPHI做过数据库应用的程序员对那方面曾经很熟练了,作者就不多说了.在实际上利用中,作者曾遭遇过那样的地方,大家的数据库应用程序是依靠ODBC系统数据源访问和操作数据库的,应用程序运维一直不错,直到某一天,3个对WINDOWS系统较为了然但又不太明白的用户不慎修改或删除了咱们事先安装的系统DSN…… 

于是,小编就起来商讨怎么在先后中动态地设置ODBC系统DSN的始末,那样就能够增添和谐程序的坚固性了.经过整整一天对WINDOWS注册表的钻研,终于找到了ODBC管理程序设置DSN的私人住房("天地自有公平,付出总会回报!",不是做广告!),现写出来与大家共享,也请大师指教. 

ODBC管理程序设置DSN的机要在注册表中,不信可以到HKEY_LOCAL_MACHINE\Software\ODBC 
去探视,肯定让你感觉到已经打响了二分一. 

率先来看望系统中已安装的ODBC数据库驱动程序.在HKEY_LOCAL_MACHINE\Software\ODBC\ 
ODBCInst.INI中,存放着曾经设置了的ODBC数据库驱动程序的音信,从此间能够查到已安装的 
ODBC数据库驱动程序呼应的DLL文件等音讯.在ODBCInst.INI\ODBC
Drivers的逐条键值中,键名是驱动程序名称(如Microsoft Access
Driver(*.mdb)),键值为“Installed”,表示驱动程序已安装.在
ODBCInst.INI\DriverName(DriverName为1个驱动程序名称,如Microsoft
Access Driver(*.mdb))
中,有驱动程序的详细音讯,大家珍视从此间获得ODBC驱动程序对应的DLL文件的门路和文书名,即键名Driver的键值,一般为”C:\WINDOWS\SYSTEM\FileName.DLL”. 

接下来来看系统DSN的挂号音信,在HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI中,存放着系统
DSN的挂号新闻,我们在ODBC管理面板设置的DSN参数就在那边. 

上边来探视成立二个ODBC系统DSN的手续,即大家在ODBC管理面板中成功参数设置后,ODBC 
治本程序是怎么在注册表中登记DSN音讯的.以创办三个名称为MyAccess的Ms
Access97类型的连串DSN为例,咱们钦点的参数首要有数据库类型(Microsoft
Access
Driver(*.mdb))、数据源名称(MyAccess)、数据源描述(笔者的ACCESS)、数据库路径(C:\Inetpub\wwwroot\Test.mdb),其余参数如用户名称、用户密码、独占、只读、系统数据库、暗中认可目录、缓冲区大小、扫描行数、页超时等利用系统缺省参数.那时,注册系统DSN一般应当以下多少个步骤: 

1.在HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI\ODBC Data
Sources中加进2个字符串 
键值,为MyAccess = Microsoft Access
Driver(*.mdb),在这之中独家为数据源名称和数据库类型. 
那是在注册表中注册二个系统DSN名称. 

2.在HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI中开创2个子键(SubKey)MyAccess,即 
始建叁个键为HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI\MyAccess,然后在其下创办一些键值,详细描述三个体系DSN的布置音讯,主要音讯有([]中的内容为小编注释): 

DBQ=C:\Inetpub\wwwroot\Test.mdb 
[字符串,表示数据库路径] 
Description=我的ACCESS 
[字符串,表示数据库描述] 
Driver=C:\PWIN98\System\odbcjt32.dll 
[字符串,表示驱动程序,可知ODBCINST.INI] 
DriverId=0x00000019(25) 
[数字,表示驱动程序标识,不能够改变] 
FIL=Ms Access; 
[字符串,大概与过滤Filter有关] 
SafeTransaction=0x00000000 
[数字,大概代表援助事务性操作的个数] 
UID=”” 
[字符串,表示用户名称,此处为空字符串] 
3.在HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI\MyAccess中开创二个子键(SubKey) 
Engines, 再在其下开创子键(SubKey)Jet,即创建三个键为
HKEY_LOCAL_MACHINE\Software 
\ODBC\ODBC.INI\MyAccess\Engines\Jet,然后在其下创办一些
键值,详细描述2个种类DSN的数据库引擎配置音讯,首要消息有([]中的内容为作者注释): 

ImplicitCommitSync=Yes 
[字符串,只怕意味着是还是不是及时反映数据修改] 
MaxBufferSize=0x00000200(512) 
[数字,表示缓冲区大大小小] 
PageTimeout=0x00000005(5) 
[数字,表示页超时] 
Threads=0x00000003(3) 
[数字,或许意味着帮衬的最大线程数目] 
UserCommitSync=Yes 
[字符串,或许代表是或不是立刻将数据修改反映到用户] 
如上是创建三个系统DSN的为主消息(别的消息如选拔或高级选项等音讯也在此处安装, 
只可是因使用暗许音讯,注册表里没有列出),大家在先后中按上述手续操作注册表,同样也能扩展叁个系统DSN或改动其配置.在底下的例证程序中,将按上述步骤建立3个系统DSN,请留意程序中的注释. 

{******************************************************* 
在本程序中,将创立三个ODBC系统数据源(DSN), 
数据源名称:MyAccess 数据源描述:作者的新数据源 
数据库类型:ACCESS97 
对应数据库:C:\Inetpub\wwwroot\test.mdb 
*******************************************************} 
{ 注意应在USES语句中隐含Registry } 
procedure TForm1.Button1Click(Sender: TObject); 
var 
registerTemp : TRegistry; 
bData : array[ 0..0 ] of byte; 
begin 
registerTemp := TRegistry.Create; 
//建立3个Registry实例 
with registerTemp do 
begin 
RootKey:=HKEY_LOCAL_MACHINE; 
//设置根键值为HKEY_LOCAL_MACHINE 

//找到Software\ODBC\ODBC.INI\ODBC Data Sources 
if OpenKey(‘Software\ODBC\ODBC.INI\ODBC Data Sources’,True) then 
begin //注册贰个DSN名称 
WriteString( ‘MyAccess’, ‘Microsoft Access Driver (*.mdb)’ ); 
end 
else 
begin//创造键值战败 
memo1.lines.add(‘增添ODBC数据源退步’); 
exit; 
end; 
CloseKey; 

//找到或创制Software\ODBC\ODBC.INI\MyAccess,写入DSN配置音讯 
if OpenKey(‘Software\ODBC\ODBC.INI\MyAccess’,True) then 
begin 
WriteString( ‘DBQ’, ‘C:\inetpub\wwwroot\test.mdb’ );//数据库目录 
WriteString( ‘Description’,’作者的新数据源’ );//数据源描述 
WriteString( ‘Driver’, ‘C:\PWIN98\SYSTEM\odbcjt32.dll’
);//驱动程序DLL文件 
WriteInteger( ‘DriverId’, 25 ); 
//驱动程序标识 
WriteString( ‘FIL’, ‘Ms Access;’ ); 
//Filter依据 
WriteInteger( ‘SafeTransaction’, 0 ); 
//援助的作业操作数目 
WriteString( ‘UID’, ” );//用户名称 
bData[0] := 0; 
WriteBinaryData( ‘Exclusive’, bData, 1 ); 
//非独占情势 
WriteBinaryData( ‘ReadOnly’, bData, 1 ); 
//非只读情势 
end 
else//成立键值退步 
begin 
memo1.lines.add(‘扩张ODBC数据源战败’); 
exit; 
end; 
CloseKey; 

//找到或创办Software\ODBC\ODBC.INI\MyAccess\Engines\Jet 
//写入DSN数据库引擎配置音讯 
if OpenKey(‘Software\ODBC\ODBC.INI\MyAccess\Engines\Jet’,True)
then 
begin 
WriteString( ‘ImplicitCommitSync’, ‘Yes’ ); 
WriteInteger( ‘马克斯BufferSize’, 512 );//缓冲区大小 
WriteInteger( ‘PageTimeout’, 10 );//页超时 
WriteInteger( ‘Threads’, 3 );//协助的线程数目 
WriteString( ‘UserCommitSync’, ‘Yes’ ); 
end 
else//成立键值失利 
begin 
memo1.lines.add(‘扩充ODBC数据源失败’); 
exit; 
end; 
CloseKey; 
memo1.lines.add(‘扩张新ODBC数据源成功’); 
Free; 
end; 
end; 

上述程序在PWIN98+DELPHI3.0下调节和测试通过. 

上边是创办常见数据库类型的DSN需求安装的信息([]为注释内容,除非凡注释外,各参数可知前边表达): 

1.Access(Microsoft Access Driver(*.mdb)) 
DBQ、Description、Driver[odbcjt32.dll]、DriverID[25]、FIL[Ms
Access;]、SafeTransaction[默认为0]、UID[默许为空]、Engines\Jet\ImplicitCommitSync[默认为Yes]、Engines\Jet\MaxBufferSize[默认512]、Engines\Jet\PageTimeout[默认为512]、Engines\Jet\Threads[默认为3]、Engines\Jet\UserCommitSync[默认为Yes] 
可选设置:SystemDb[字符串,系统数据库的门径]、ReadOnly[二进制,是不是以只读形式打开,1为是,暗中同意为0]、Exclusive[二进制,是不是以垄断格局打开,1为是,暗中认可为0]、PWD[字符串,用户密码] 

2.EXCEL(Microsoft Excel Driver(*.xls)) 
DBQ[Excel97(=path\xxx.xls)、5.0/7.0(=path\xxx.xls)、4.0(=path)、3.0(=path)]、Description、Driver[odbcjt32.dll]、DefaultDir[Excel97(<
>DBQ)、5.0/7.0(<
>DBQ)、4.0(=DBQ)、3.0(=DBQ)]、DriverID[790(Excel97)、22(5.0/7.0)、278(4.0)、534(3.0)]、FIL[Excel5.0;]、ReadOnly、SafeTransaction、UID、Engines\Excel\ImplicitCommitSync、 
Engines\Excel\MaxScanRows[数字,扫描行数,暗许为8]、Engines\Excel\Threads、Engines\Excel\UserCommitSync、Engines\Excel\FirstRowHasName[二进制,第②行是或不是是域名,1意味着是,暗许为1] 
【注】:
Excel97和Excel7.0/5.0的DBQ对应2个XLS文件,而Excel4.0和Excel3.0则对应八个目录;DefaultDir对应多个索引,在Excel97和Excel7.0/5.0中是DBQ所对应的路子,而在Excel4.0和Excel3.0下则与DBQ相同;种种版本的DriverID分歧. 

3.dBase(Microsoft dBase Driver(*.dbf)) 
DefaultDir[字符串,数据库文件所在目录]、Description、Driver[odbcjt32.dll]、 
DriverID[277(IV)、533(5.0)]、FIL[dbase
III;]、SafeTransaction、UID、Engines\Xbase\ImplicitCommitSync、Engines\Xbase\Collating[字符串,排序依据,可为ASCII、International、Norwegian-Danish、Swedish-Finnish]、Engines\Xbase\Deleted[二进制,是或不是不显得被软删除的笔录,0象征彰显,暗中同意为1]、Engines\Xbase\PageTimeout[默认为600]、Engines\Xbase\UserCommitSync、Engines\Xbase\Threads、Engines\Xbase
\Statistics[二进制,是还是不是用大致的行数,1为是,暗许0] 
【注】:(dBaseIV和dBase5.0多少个本子的DriverId有例外) 

4.Foxpro(Microsoft Foxpro Driver(*.dbf)) 
DefaultDir[数据库文件所在目录]、Description、Driver[odbcjt32.dll]、DriverID[536(2.6)、280(2.5)]、FIL[Foxpro
2.0;]、SafeTransaction、UID、Engines\Xbase\Collating[字符串,排序依据,可为ASCII、International]、Engines\Xbase\Deleted[二进制,是还是不是不出示
被软删除的笔录,0意味彰显,暗中认可为1]、Engines\Xbase\PageTimeout[默认为600]、Engines\Xbase\UserCommitSync、Engines\Xbase\Threads、Engines\Xbase\Statistics[二进制,是还是不是用大致的行数,1为是,暗中认可0] 
【注】:(Foxpro2.5和Foxpro2.6四个版本的DriverId有两样) 

把地方程序做成三个COM或ActiveX控件吧,在无数高等程序设计语言如DELPHI、
C++Buider、VB、VC、PB中都能用到的 

二零零一-11-20 14:30:46 怎么样在注册表中注册BDE 

【编者语】: 
地点讲了多少个注册ODBC的例子,那回大家的话说怎么注册BDE 

只拷贝BDE文件是那么些的,还要写注册表: 
必备的注册表项目包含: 

  1. BDE动态连接库文件地点设置 
    Key : “HKEY_LOCAL_MACHINE\Software\Borland\Database Engine” 
    Item : “DLLPATH” 
    Value : BDE动态连接库文件所在地点,如”C:\Program Files\Borland\Common
    Files\BDE” 
    (打开”C:\Program Files\Borland\Common
    Files\BDE\BDE32.hlp”,查找”Core
    Files”即可了然BDE各动态连接库文件的效率) 

  2. BDE语言驱动文件路径设置 
    Key : “HKEY_LOCAL_MACHINE\Software\Borland\BLW32” 
    Item : “BLAPIPATH” 
    Value : BDE语言驱动文件所在路径,如”C:\Program Files\Borland\Common
    Files\BDE” 
    (BDE语言驱动正是那么些*.BLL文件) 

  3. 钦赐可用的BDE语言驱动文件 
    Key : “HKEY_LOCAL_MACHINE\Software\Borland\BLW32” 
    Item : “LOCALE_LIB#” (#表示数字,
    如”LOCALE_LIB1″、”LOCALE_LIB3″等) 
    Value : 钦赐各BDE语言驱动文件,如”C:\Program Files\Borland\Common
    Files\BDE\USA.BLL” 
    (一般必需的语言驱动文件有”USA.BLL”,”EUROPE.BLL”和”FAREAST.BLL”,为力保起见,提议将有着语言驱动都安装上。在安装了Delphi3的机械上,用Regedit打开注册表,一看您就了解了怎么设了) 

二〇〇三-11-20 14:37:11 用DEPHI为使用软件建立注册机制 

【编者语】: 
地方给了一个“使用DELPHI给程序加密的措施”,想对这些点子做一些补给表明,因为材质较老,请酌定参考。 

  怎样珍惜自个儿的软件不被非授权盗用的标题,始终烦扰着每3个程序员。当前世界上爱惜 
软件的章程有好多,主就算使用加密(如加软件狗)格局或软件注册格局。使用软件狗等加密方 
法,就算其保险最得力,但对授权用户的正规使用有肯定的震慑,而且软件发给相比复杂,在实 
际运用中相比少被使用。而注册登记格局则是当下最盛行、运用最广泛的措施,固然有许多通用 
软件其注册码能够很不难地被胸闷友们所解,但对于单身程序员为某一定应用设计的运用软件而 
言,选择注册机制显得最经济、最有利,而且在自然而然的范围内非凡实惠。作者在其实工作中,广 
泛使用了软件注册格局,有效地保险了软件的权益。 
  DEPHI软件的成效极为强大,深受程序员喜欢。用DEPHI开发的软件,能够很便宜地出席注册机制。上边作者就像何在DEPHI开发的软件中加入注册机制与爱侣们沟通心得。 
  要落到实处软件注册机制,需化解以下多少个难题: 
一 、怎么着进入注册检查和测试,判断软件是否注册; 
贰 、如何隐藏注册码,及是不是注册的标志; 
三 、在软件不登记情状下,如何界定软件的选拔时间或次数; 
四 、对健康用户而言,不应造成选拔不便。 
对此上述四个问题,如何隐藏注册码及是或不是注册的标志是根本。在WINDOWS95中,WIN95自己及多数的选用软件都将其各样参数放入注册表中,因此注册表内的多寡展现颇为庞大和复杂。假设将登记标志隐藏在注册表的某一角落中,想要找到它并掌握它是然而困难的事。由此大家能够运用那或多或少,在注册表的某部分支上设置三个从名称上看不用特殊意义的重要字,将协调软件的登记标志数据存放在此处。 
总体注册机制主要由两个部分构成:检查和注册。通过检查标志值,得出软件是不是已登记;若没有挂号,则要看它同意选用的次数是或不是已落成;若可应用的次数已用完,则应提醒用户输入注册码,举办登记;唯有用户输入的注册码正确时,才让用户继续选取软件,同时将标志置为已登记,让用户永久性使用;不然允许利用的次数未达到,应将次数加一; 
若用户注册输入的注册码错误或拒绝注册,则一贯关闭软件,拒绝其持续应用。当然,在软件允 
许运用次数未达到规定的标准时,也应通过菜单项为用户提供机会开始展览登记登记。以下是作者在骨子里成本 
中,建立注册机制的程序代码及注释。 

假如软件的主程序窗口为FO奥迪Q5M1,则将该段代码置放在FO奥迪Q5M1.Create事变中。代码如下: 
procedure TForm1.form1create(Sender: TObject); 
var 
re_id:integer; 
registerTemp : TRegistry; 
inputstr,get_id:string; 
dy,clickedok:boolean; 
begin 
 dy:=false;
//软件是或不是已到注册期、及是还是不是同意继承行使的标志,当班值日为FALSE是为允许使 
用。 
 registerTemp := TRegistry.Create; //准备利用注册表 
 with registerTemp do 
 begin 
   RootKey:=HKEY_LOCAL_MACHINE; //存放在此根下 
   if
OpenKey(‘Software\Microsoft\Windows\CurrentVersion\Mark’,True)
then 
   //
建一目录,存放标志值。当然也能够存放在已存在的目录下。怎么样,很难发现吗? 
    begin 
     if valueexists(‘gc_id’) then begin 
//用gc_id的值作为标志,首先判断其设有否? 
       re_id:=readinteger(‘gc_id’);//读出标志值 
       if (re_id<>0) and (re_id<>100) then begin 
//若标志值为0,则表达已注册。 
        //若不为0且值不到100,表明虽未注册,但允许采纳的次数尚未实现。 
        re_id:=re_id+5; 
//允许标志的最大值为100,每趟加5,则最五只可用26次。 
        Writeinteger(‘gc_id’,re_id);//将履新后的标志值写入注册表中。 
     end; 
     if re_id=100 then dy:=true; //假若值已到100,则应注册。 
    end 
   else Writeinteger(‘gc_id’,5);//建立标志,并置早先标志值。 
  end; 
  if dy then begin
//若dy值为TRUE,则应提醒用户输入注册码,实行挂号。 
    clickedok:=InputQuery(‘您使用的长短注册软件,请输入注册码:’,’
‘,inputstr); 
    if clickedok then begin 
      get_id:=inttostr(27593758*2);//注册码为55187516,当然可进入更杂的算法。 
      if get_id=inputstr then begin 
        Writeinteger(‘gc_id’,0); 
//若输入的注册码正确,则将注明值置为0,即已注册。 
        CloseKey; 
        Free; 
       end 
      else begin
//若输入的注册码错误,应作出提示并拒绝让其继承使用 
        application.messagebox(‘注册码错误!请与我联系!’,’警告框’,mb_ok); 
        CloseKey; 
        Free; 
        application.terminate;
//中止程序运转,拒绝让其持续使用 
       end; 
      end 
    else begin
//若用户不输入注册码,也应作出提醒并驳回让其继承选择 
      application.messagebox(‘请与作者联系,使用注册软件!’,’警告框’,mb_ok); 
      CloseKey; 
      Free; 
      application.terminate; 
     end; 
  end; 
 end; 
end; 

(注:通过菜单举行挂号的措施同本段提示用户举办登记的内容千篇一律,那里不提供代码。) 

  以上程序代码已在DEPHI3.0/WIN95环境中运转经过,并在实际上利用中获取验证。对合法用户而言,那样的机制,只要其录入注册码1遍就能够,不扩展其平凡行使的承负;而对地下用户而言,除非她取得注册码或重装WINDOWS95,不然超越利用次数后,将不恐怕持续利用。当然在实际上利用中还有众多地点能够更进一步增进反破解能力,欢迎朋友们建议批评和指引。 

2004-11-20 14:39:14
通过对注册表进行改动,能够去除资源管理器上下文件菜单中对某类文件的拍卖命令

【问题】: 
因而对注册表实行改动,能够去除财富管理器上下文件菜单中对某类文件的处理命令程序例如下: 
procedure FileTDelAction(key, name: String); 
//key:关联键值为后缀的叙述键值,如.tst对应testfile,则key:=testfile 
//name:命令名称 
var 
myReg: TRegistry; 
begin 
myReg:=TRegistry.Create; 
myReg.RootKey:=HKEY_CLASSES_ROOT; 
//若是给出的是多个文本后缀,则转换到对应的叙说键值 
//在变更文书涉及时,假设未提交描述键值,则会自动生成,此处与地方是调换的 
{if key[1] = ‘.’ then 
key:= copy(key,2,maxint)+’_auto_file’;} 
if key[1] = ‘.’ then 
begin 
if myReg.KeyExists(key) then //首先看登记表中是不是有此键,有则取出 
begin 
myReg.OpenKey(key, false); 
key:=myReg.ReadString (”); 
end 
else 
key:= copy(key,2,maxint)+’_auto_file’; 
end; 
if key[Length(key)-1] <> ‘\’ then 
key:=key+’\’; 
myReg.OpenKey(‘\’+key+’shell\’, true); 
if myReg.KeyExists(name) then 
myReg.DeleteKey(name); 
myReg.CloseKey; 
myReg.Free; 
end; 

调用例子: 
Example: 
FileTDelAction(‘test’,’edit’); 

规律表明: 
将注册表中对应的键值删除就可以了。 

二零零零-11-20 14:47:34 用Delphi完结壁纸更换(适用于Windows95/98) 

在Windows95/9第88中学,都以利用注册表对系统数据开始展览管制,有关壁纸的设置数据保存在 
Hkey_Current_User\Control Panel\Desktop的沃尔paper和Tile沃尔paper
等键值中,只要成功修改了那四个键值,然后发音信给Windows即可更换壁纸。在本例的先后中,使用了三个Tform;多个Tspeedbutton(Speedbutton1用于接受用户的浏览命令,Speedbutton2用于接受用户的更换壁纸命令);多少个Timage(用于呈现图片)。此外,还用到一组文件控件: 
Tfilelistbox,Tdrivecombobox,Tdirectorylistbox,用于选用图片文件,能够设置FileListBox的mask属性,筛选突显在FileListBox中的文件类型(如只展现.bmp文件)。下边包车型客车七个程序段是兑现浏览图片和更换壁纸的机要代码。 

Procedure Tform1.SpeedButton1Click(Sender:Tobject); 
Begin 
If (filelistbox1.FileName=′′) Then
{判断Filelistbox1粤语件有没有被选中} 
  Messagedlg(′请先选取一幅位图′,mtInformation,[mbOK],0) 
Else 
Image1.Picture.LoadFormFile(Filelistbox1.FileName);{加载图片文件并出示} 
End; 

ProcedureTform1.SpeedButton2Click(Sender:TObject); 
Var 
Reg:Tregistry; 
{Tregistry 对象在Registry 单元中宣称,需用Uses令引用Registry单元} 

Begin 
If (Filelistbox1.FileName=′′) Then 
Messagedlg(′请先选取一幅位图′,mtinformation,[mbOK],0) 
Else 
Begin 
Reg:=Tregistry.Create;{创造Tregistry对象的实例} 
Reg.Rootkey:= Hkey_Current_User;{设置根键名称} 
Reg.OpenKey′Control Panel\Desktop′,False); 
{打开Control Panel\Desktop路径对应的主键} 
Reg.WriteString (′TileWallPaper′, ′0′); 
Reg.WriteString ′Wallpaper′,fileli?stbox1.FileName); 
{向Tile沃尔paper 和沃尔paper串覆盖写入新值} 
Systemparametersinfo(SPI_SETDESKWallpaper,0,Nil,SPIF_SendChange); 
{向Windows发送信息,文告Windows更换壁纸} 
Reg.CloseKey;{将改变内容写入注册表并关闭} 
Reg.Free;{释放对象} 
End; 
End; 
代码中用到的局地函数能够观测Delphi的联机扶助。须要专注的是:调用打开子键的函数OpenKey时,第②个参数一定要设为False。 
通过对注册表实行修改,能够在财富管理器上下文菜单中扩张对某类文件的拍卖命令程序例如下: 

procedure FileTAddAction(key, name, display, action: String); 
//key:关联键值为后缀的叙说键值,如.tst对应testfile,则key:=testfile 
//name:命令名称 
//display:在上下文件菜单上海展览中心示的唤起音讯 
//action:对应的命令 
var 
myReg:TRegistry; 
begin 
myReg:=Tregistry.Create; 
myReg.RootKey:=HKEY_CLASSES_ROOT; 
if name=” then name:=display; 
//假若给出的是二个文书后缀,则转换来对应的描述键值 
//在变更文书涉及时,借使未提交描述键值,则会自动生成,此处与地点是关联的 
{ if key[1] = ‘.’ then 
key:= copy(key,2,maxint)+’_auto_file’;} 
if key[1] = ‘.’ then 
begin 
if myReg.KeyExists(key) then //首先看登记表中是或不是有此键,有则取出 
begin 
myReg.OpenKey(key, false); 
key:=myReg.ReadString (”); 
end 
else 
key:= copy(key,2,maxint)+’_auto_file’; 
end; 
if key[Length(key)-1] <> ‘\’ then 
key:=key+’\’; 
if name[Length(name)-1] <> ‘\’ then 
name:=name+’\’; 
myReg.OpenKey(key+’Shell\’+name, true); 
myReg.WriteString(”, display); 
MyReg.CloseKey; 
MyReg.OpenKey(key+’Shell\’+name+’Command\’, true); 
MyReg.WriteString(”, action); 
myReg.Free; 
end; 

调用例子: 
Example: 
FileTAddAction(‘testfile’,’edit’,’Edit’,Application.ExeName+’-e
“%1″‘); 

规律表达: 
如.txt对应的讲述键值为testfile 
则在testfile的键值下边,扩张动作子键 
如: testfile\shell\ ”, Edit 
testfile\shell\Command\ ”, ‘c:\testfile -e “%1″‘ 

二〇〇一-11-20 15:07:49 怎么样创制程序快速方式 

落到实处原理: 
由此OLE Interface 来落成,通时要拍卖注册表。 
对于火速情势的蕴藏地点能够钦点为桌面,起始菜单,发送到等,那样首先通过对系统注册 
表的读取,获取相应的实在地址,将用来保存急速形式文件。 
应用四个接口:IUnknown, IShellLink, IPersistFile 
IUnknown取得一般性的com 对象 
IShellLink取得对快捷格局的拍卖,能够设置实行理文件书名,飞速键,描述,参数等 
IPersistFile对转移的飞速格局实行保存 
程序如下: 

//参加如下单元 
uses 
Registry, ShlObj, ActiveX, ComObj; 

//定义快速格局存放地方桌面,发送,起初菜单 
type 
ShortcutType = (_DESKTOP, _QUICKLAUNCH, _SENDTO, _STARTMENU); 

procedure CreateShortcut( 
FileName: string; //执行文件名,全路径 
description: string; //飞速方式讲述 
arguments: string; //参数 
Location: ShortcutType //存放地点 
); 
var 
MyObject : IUnknown; 
MySLink : IShellLink; 
MyPFile : IPersistFile; 
Directory, 
LinkName : string; 
WFileName : WideString; 
MyReg, 
QuickLaunchReg : TRegIniFile; 
begin 
MyObject := CreateComObject(CLSID_ShellLink); //创建com对象 
MySLink := MyObject as IShellLink; //转化为IShellLink接口 
MyPFile := MyObject as IPersistFile; //转化为IPersistFile接口 
MySLink.SetPath(PChar(FileName)); //设置执行文书名 
MySLink.SetArguments(PChar(arguments)); //设置执行参数 
MySLink.SetDescription(PChar(Description)); //设置描述 
MySLink.SetWorkingDirectory(PChar(ExtractFilePath(application.exename))); 
//设置工作途径为履行顺序所在目录 

//上面起始取存放地点的实在目录 
MyReg
:=TRegIniFile.Create(‘Software\MicroSoft\Windows\CurrentVersion\Explorer’); 
try 
LinkName := ChangeFileExt(FileName, ‘.lnk’); //生成火速方式文件名 
LinkName := ExtractFileName(LinkName); //取文件主名 
case Location of 
_DESKTOP : Directory := MyReg.ReadString(‘Shell Folders’,’Desktop’,
”); 
_STARTMENU : Directory := MyReg.ReadString(‘Shell Folders’,’Start
Menu’, ”); 
_SENDTO : Directory := MyReg.ReadString(‘Shell Folders’,’SendTo’,
”); 
_QUICKLAUNCH: 
begin 
QuickLaunchReg := 
TRegIniFile.Create(‘Software\MicroSoft\Windows\CurrentVersion\GrpConv’); 
try 
Directory := QuickLaunchReg.ReadString(‘MapGroups’, ‘Quick Launch’,
”); 
finally 
QuickLaunchReg.Free; 
end; 
end; 
end; 

if Directory <> ” then 
begin 
WFileName := Directory + ‘\’ + LinkName;
//合成存放快捷方式文件全路线名 
MyPFile.Save(PWChar(WFileName), False); //保存急迅文件 
end; 
finally 
MyReg.Free; 
end; 
end; 
【注】:关于更详实的IShellLink的申明能够查阅相关的扶持文书档案。假诺要去除火速形式,则将.LNK文件删除即可。 
Delphi 4.0 [Help]->[MS SDK Help Files]->《Win32 Developer’s
References》 

2001-11-20 15:13:50
问:如何让本人的程序像“Explorer”一样,系统重启后能东山再起到系统关闭时的景色?

【答】: 
实际是注册表在添乱,你只怕早就注意到,让祥和的程序随着Windows的起步而运维是在“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run”下报了名,而要达到你的目的正是在“..\RunOnce”下报了名即可。当然,余下的题材便是在哪些时候写入这么些消息?若是您小心的话,就会意识Delphi自个儿附带了1个例证(Tregistry下)。说到那边,大家又要提到Windows的音信了,只是限于篇幅,就那么些标题那里就不再赘述了,笔者个人提出大家注意一下Delphi的Messages.pas单元中有关WM_XXX的定义及Windows
API的协理。 
uses 
Windows, Messages,…, Registry; 

private 
procedure WMEndSession(var Msg:TWMEndSession); message
WM_ENDSESSION; 

procedure TForm1.WMEndSession(var Message: TWMEndSession); 
var 
Reg: TRegistry; 
begin 
Reg := TRegistry.Create; 
try 
Reg.RootKey := HKEY_CURRENT_USER; 
if
Reg.OpenKey(‘\Software\Microsoft\Windows\CurrentVersion\RunOnce’, 
True) then 
Reg.WriteString(‘MyApp’,'”‘ + ParamStr(0) + ‘”‘); 
finally 
Reg.CloseKey; 
Reg.Free; 
inherited; 
end; 
end; 

二零零一-11-20 15:17:41
通过对注册表进行修改,能够在财富管理器上下文件菜单中的新建子菜单中扩充新的一声令下 

并且请参考“通过对注册表实行改动,能够去除能源管理器上下文件菜单中对某类文件的处理命令”的作品。 

先后例如下: 
type 
TFileNewType = (ftNullFile, ftFileName, ftCommand); 

procedure FileTAddNew(ft, param: String; newType: TFileNewType); 
//fp:文件后缀键值,如.tst 
//param:传递参数 
//newType:新建的项目,有空文件, 文件名, 命令 
var 
myReg:TRegistry; 
begin 
myReg:=TRegistry.Create; 
myReg.RootKey:=HKEY_CLASSES_ROOT; 
if not myReg.KeyExists(ft) then 
begin 
MyReg.Free; 
Exit; 
end; 
myReg.OpenKey(ft+’\ShellNew’, true); 
case NewType of 
ftNullFile : MyReg.WriteString(‘NullFile’, ”); 
ftFileName : MyReg.WriteString(‘FileName’, param); 
ftCommand : MyReg.WriteString(‘Command’, param); 
end; 
MyReg.CloseKey; 
MyReg.Free; 
end; 

调用例子: 
Example: 
FileTAddNew(‘.tst’,”, ftNullFile); 

规律表明: 
在后缀键的底下扩展子键ShellNew。如在上下文菜单中加进新建.tst文件的命令 
在.tst键值下边扩展子键 .tst\ShellNew ‘NullFile’, ” 

二零零二-12-15 15:22:56 怎么样用DELPHI搜索注册表的满贯项、鍵 

unit Unit1; 

interface 

uses 
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, 
Grids, Registry, StdCtrls, ExtCtrls, ComCtrls; 

type 
TForm1 = class(TForm) 
StatusBar1: TStatusBar; 
Panel1: TPanel; 
StringGrid1: TStringGrid; 
btnStart: TButton; 
btnRemove: TButton; 
edKey: TEdit; 
edTime: TEdit; 
edValueName: TEdit; 
edValue: TEdit; 
btnStop: TButton; 
procedure btnStartClick(Sender: TObject); 
procedure FormCreate(Sender: TObject); 
procedure FormDestroy(Sender: TObject); 
procedure FormShow(Sender: TObject); 
procedure btnRemoveClick(Sender: TObject); 
procedure StringGrid1SelectCell(Sender: TObject; Col, Row: Integer; 
var CanSelect: Boolean); 
procedure btnStopClick(Sender: TObject); 
private 
{ Private declarations } 
fRegistry: TRegistry; 
fRowCount: Integer; 
fCurrentKeyValue: String; 
fStopFlag: Boolean; 
fNoSelection: Boolean; 
procedure DoAnalyzeRegistry; 
procedure DoAnalyzeBranch; 
procedure DoAnalyzeKey(const Key: String); 
function DoAnalyzeValue(const Key, Value: String): Boolean; 
public 
{ Public declarations } 
end; 

var 
Form1: TForm1; 

implementation 

{$R *.DFM} 

const Root : Array[0..3] of Char = (‘A’, ‘:’, ‘\’, #0); 

const 
nKeyName = 0; 
nFileTime = 1; 
nValueName = 2; 
nValueString = 3; 

procedure NormalizeRegistryPath(var Path: String); 
begin 
if (Path = ”) or (Path[1] <> ‘\’) then 
Path := ‘\’ + Path; 
end; 

procedure TForm1.btnStartClick(Sender: TObject); 
begin 
btnStop.Enabled := TRUE; 
fRowCount := 1; 
StringGrid1.RowCount := 2; 
StringGrid1.Cells[nKeyName, 1] := ”; 
StringGrid1.Cells[nFileTime, 1] := ”; 
StringGrid1.Cells[nValueName, 1] := ”; 
StringGrid1.Cells[nValueString, 1] := ”; 

DoAnalyzeRegistry; 
end; 

procedure TForm1.FormCreate(Sender: TObject); 
begin 
fRegistry := TRegistry.Create; 
end; 

procedure TForm1.FormDestroy(Sender: TObject); 
begin 
fRegistry.Free; 
end; 

procedure TForm1.DoAnalyzeRegistry; 
begin 
fStopFlag := FALSE; 
fNoSelection := TRUE; 

if not fStopFlag then 
begin 
fCurrentKeyValue := ‘HKEY_CURRENT_USER’; 
fRegistry.RootKey := HKEY_CURRENT_USER; 
fRegistry.OpenKey(‘\’, FALSE); 
DoAnalyzeBranch(); 
end; 

if not fStopFlag then 
begin 
fCurrentKeyValue := ‘HKEY_USERS’; 
fRegistry.RootKey := HKEY_USERS; 
fRegistry.OpenKey(‘\’, FALSE); 
DoAnalyzeBranch(); 
end; 

if not fStopFlag then 
begin 
fCurrentKeyValue := ‘HKEY_LOCAL_MACHINE’; 
fRegistry.RootKey := HKEY_LOCAL_MACHINE; 
fRegistry.OpenKey(‘\Software’, FALSE); 
DoAnalyzeBranch(); 
end; 

StringGrid1.RowCount := fRowCount; 
StatusBar1.SimpleText := ‘Number of invalid references:
‘+IntToStr(fRowCount – 1); 
btnStop.Enabled := FALSE; 

if fRowCount = 1 then 
begin 
MessageDlg(‘No invalid references
detected.’,mtInformation,[mbOK],0); 
btnRemove.Enabled := FALSE; 
end 
else 
begin 
btnRemove.Enabled := TRUE; 
end; 

end; 

procedure TForm1.DoAnalyzeBranch; 
var 
I: Integer; 
Keys: TStringList; 
Path: String; 
begin 
Keys := TStringList.Create; 
try 
Path := fRegistry.CurrentPath; 
fRegistry.GetKeyNames(Keys); 
for I := 0 to Keys.Count – 1 do 
begin 
if fRegistry.OpenKey(Keys[I], FALSE) then 
begin 
DoAnalyzeKey(Keys[I]); 
if fStopFlag then Break; 
if fRegistry.HasSubKeys then DoAnalyzeBranch; 
end; 

if fStopFlag then Break; 

NormalizeRegistryPath(Path); 
if not fRegistry.OpenKey(Path, FALSE) then 
raise exception.Create(‘Can not open key ‘+Path); 
end; 
finally 
Keys.Free; 
end; 
end; 

procedure TForm1.DoAnalyzeKey(const Key: String); 
var 
I: Integer; 
Values: TStringList; 
DataType: TRegDataType; 
StringValue: String; 
RegKeyInfo: TRegKeyInfo; 
SystemTime: TSystemTime; 
StringDate: String; 
begin 
Values := TStringList.Create; 
try 
fRegistry.GetValueNames(Values); 
for I := 0 to Values.Count – 1 do 
begin 

DataType := fRegistry.GetDataType(Values[I]); 
if (DataType = rdString) or (DataType = rdExpandString) then 
begin 
StatusBar1.SimpleText := ‘Analyzing: ‘+Key; 
{ Let the applocation to process messages, 
so the text would be on the status bar 
while we are still in the loop } 
Application.ProcessMessages; 

if fStopFlag then Break; 

StringValue := fRegistry.ReadString(Values[I]); 

if (not DoAnalyzeValue(Key, Values[I])) or 
(not DoAnalyzeValue(Key, StringValue)) then 
begin 
if StringGrid1.RowCount = fRowCount then 
StringGrid1.RowCount := fRowCount + 10; 

fRegistry.GetKeyInfo(RegKeyInfo); 
FileTimeToSystemTime(RegKeyInfo.FileTime, SystemTime); 
DateTimeToString(StringDate, ‘mm/dd/yyyy hh:mmAM/PM’,
SystemTimeToDateTime(SystemTime)); 

StringGrid1.Cells[nKeyName, fRowCount] := fCurrentKeyValue + ‘: ‘
+fRegistry.CurrentPath; 
StringGrid1.Cells[nFileTime, fRowCount]:= StringDate; 
StringGrid1.Cells[nValueName, fRowCount] := Values[I]; 
StringGrid1.Cells[nValueString, fRowCount] := StringValue; 

{ If there is no rows selected yet then select the first one } 
if fNoSelection then 
begin 
fNoSelection := FALSE; 
StringGrid1.Selection := TGridRect(Rect(0, 1, 4, 1)); 
end; 

Inc(fRowCount); 
end; 
end; 
end; 
finally 
Values.Free; 
end; 
end; 

function TForm1.DoAnalyzeValue(const Key, Value: String): Boolean; 
var 
DriveType: UINT; 
Path: String; 
FileName: String; 
begin 
Result := TRUE; 

{ Verify if the string can be treated as path (and file name)} 
if Length(Value) < 3 then Exit; 
if not (UpCase(Value[1]) in [‘C’..’Z’]) then Exit; 
if Pos(‘;’, Value) > 0 then Exit; 
if Pos(‘,’, Value) > 0 then Exit; 
if Pos(‘ ‘, Value) > 0 then Exit; 
if (Value[2] <> ‘:’) or (Value[3] <> ‘\’) then Exit; 

Root[0] := Value[1]; 
DriveType := GetDriveType(Root); 
if (DriveType = DRIVE_FIXED) then 
begin 
if (ExtractFileExt(Value) = ”) then 
begin 
{ No extension, try to treat the value as path } 
Path := Value; 
if (Path[Length(Path)] <> ‘\’) then 
Path := Value + ‘\’; 

if not SetCurrentDirectory(PChar(Path)) then 
begin 
Result := FALSE; 
Exit; 
end; 
end 
else 
begin 
Path := ExtractFilePath(Value); 
if not SetCurrentDirectory(PChar(Path)) then 
begin 
Result := FALSE; 
Exit; 
end; 
FileName := ExtractFileName(Value); 
if (GetFileAttributes(PChar(Value)) = -1) then 
begin 
Result := FALSE; 
Exit; 
end; 
end; 
end; 
end; 

procedure TForm1.FormShow(Sender: TObject); 
begin 
StringGrid1.Cells[nKeyName, 0] := ‘Registry Key’; 
StringGrid1.Cells[nFileTime, 0] := ‘Last Modification’; 
StringGrid1.Cells[nValueName, 0] := ‘String Value’; 
StringGrid1.Cells[nValueString, 0] := ‘File/Path reference’; 
fRowCount := 1; 
btnRemove.Enabled := FALSE; 
btnStop.Enabled := FALSE; 
fNoSelection := TRUE; 
end; 

procedure TForm1.btnRemoveClick(Sender: TObject); 
var 
I: Integer; 
Msg: String; 
Count: Integer; 
Selection: TGridRect; 
RootKey: Longint; 
Path: String; 
procedure ParseKeyValue(const S: String); 
var 
I: Integer; 
Key: String; 
begin 
I := Pos(‘:’, S); 
Key := Copy(S, 1, I-1); 
Path := Copy(S, I+2 , Length(S)); 
NormalizeRegistryPath(Path); 

if Key = ‘HKEY_CURRENT_USER’ then 
RootKey := HKEY_CURRENT_USER 
else if Key = ‘HKEY_USERS’ then 
RootKey := HKEY_USERS 
else if Key = ‘HKEY_LOCAL_MACHINE’ then 
RootKey := HKEY_LOCAL_MACHINE; 
end; 

begin 
Selection := StringGrid1.Selection; 
Count := Selection.Bottom – Selection.Top + 1; 

if Count = 1 then 
Msg := ‘Are you sure you want to remove selected entry from the
Registry?’ 
else 
Msg := ‘Are you sure you want to remove ‘ + 
IntToStr(Selection.Bottom – Selection.Top + 1) + 
‘ selected entries from the Registry?’; 

if MessageDlg(Msg, mtWarning, [mbYes,mbNo], 0) = mrYes then 
begin 
for I := Selection.Top to Selection.Bottom do 
begin 
ParseKeyValue(StringGrid1.Cells[nKeyName, I]); 
fRegistry.RootKey := RootKey; 

if not fRegistry.OpenKey(Path, FALSE) then 
raise Exception.Create(‘Error opening registry key ‘+Path); 

fRegistry.DeleteValue(StringGrid1.Cells[nValueName, I]); 
end; 

{ Initiate re-scanning } 
btnStartClick(self); 

end; 
end; 

procedure TForm1.StringGrid1SelectCell(Sender: TObject; Col, Row:
Integer; 
var CanSelect: Boolean); 
begin 
{ Display values in the edit controls 
only when there is any data in the grid } 
if not (fNoSelection) then 
begin 
edKey.Text := StringGrid1.Cells[nKeyName, Row]; 
edTime.Text := StringGrid1.Cells[nFileTime, Row]; 
edValueName.Text := StringGrid1.Cells[nValueName, Row]; 
edValue.Text := StringGrid1.Cells[nValueString, Row]; 
end; 
end; 

procedure TForm1.btnStopClick(Sender: TObject); 
begin 
{ Set the stop flag, so the registry scanning process can stop } 
fStopFlag := TRUE; 
end; 

end. 

二〇〇四-12-15 16:21:10 那些顺序可以博得注册表下的全部值(别的一种方法) 

Var Reg : TRegistry; 
list : TStrings; 
i : Integer; 
Begin 
Reg:=TRegistry.Create; 
Reg.RootKey:=’HKEY_LOCAL_MACHINE’; 
If Reg.OpenKey(‘\Software\Microsoft\CurrentVersion\Run’, false)
then 
Begin 
List:=TStringList.Create; 
Reg.GetValueNames(List); 
For i:=0 to list.Count-1 do 
If Reg.ValueExists(List[i]) then 
Begin 
Case Reg.GetDataType(List[i]) of 
rdInteger: Reg.ReadInteger(List[i]); 
rdBinary: Reg.ReadBinaryData(List[i]); 
else 
Reg.ReadString(List[i]); 
End; 
End; 
End; 
End; 

其余,ReadBinaryData能够读取二进制键值。

相关文章