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

32号Delphi程序中而使用TRegistry对象来存取注册表文件中之信息。 

  一、创建与刑释解教TRegistry对象 

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

  2.刑满释放TRegistry对象。对注册表操作完后,应放TRegistry对象所占据内存:ARegistry.Destroy。 

  二、指定要操作的键 

  操作注册表时,首先应指定操作的主键:先被属性RootKey赋值以指定根键,然后据此艺术OpenKey来指定要操作的主键名。 

  1.指定根键(RootKey)。 
  根键是注册表的入口,也注册表信息之归类,其值可为: 
  HKEY—CLASSES—ROOT:存储整个系统对象类消息,如ActiveX对象注册、文件涉及等信息。 
  HKEY—CURRENT—USER:存储时用户之布置信息。为性RootKey的默认值。 
  HKEY—LOCAL—MACHINE:存储时网的软硬件配置信息。应用程序自己之音讯可储存于拖欠根键下。
 HKEY—USERS:存储所有用户通用的布局信息。 
  还好是HKEY—CURRENT—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; 
  读取一个字符串值,Name为字符串名称。 
  function ReadInteger(const Name: string): Integer; 
  读取一个平头价值,Name为整数名称。 
  function ReadBinaryData(const Name: string; var Buffer; BufSize:
Integer):Integer; 
  读博二前进制值,Name为第二前进制值名称,Buffer也接收缓冲区,BufSize为缓冲区大小,返回吗实在读取的字节数。 
  其它措施还有:ReadBool、ReadCurrency、ReadDate、ReadDateTime、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、WriteDateTime、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—USERS
\.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 
查评语»»» 
2003-11-20 11:59:20
注册表中针对编程常用之几项(ODBC/BDE/Internet/Windows) 

自我用底凡 WINDOWS 2000, WIN2000 的 REGEDIT 提供了仿佛 IE
中珍藏夹的作用,我的珍藏夹着起几个可能对大家编程时见面生出救助(这是我于编程过程遭到的探讨出的,请大师指教): 

1。关于 ODBC 和 DBE: 
HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI\ODBC File DSN 
发出若的 COMPUTER 上 ODBC 的 FILE DSN 的寄放的缺省路径,如果您建 FILE
DSN
的早晚择了和睦的门道,那你虽得小心了,系统不见面为卿保存该路线,你的融洽牢记它们,:-(; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI\ODBC Drivers 
排有了你的所有 ODBC DRIVER, 
有关 ODBC DRIVER
的称呼,有一个比好玩之地方:不知大家又没因此TSession.GetDriverNames
取过系统 ODBC DRIVER 名,我所以之时光 DRIVER 名最丰富只能取得到 31
单字符,剩下的即深受截掉了,不知是自己编程有题目要么 DELPHI 的 BUG; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBCINST.INI 
列有了公的有 ODBC DRIVER 的详细布置; 

HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI 
排有了而的所有 SYSTEM DSN 以及它的配备情况; 

HKEY_CURRENT_USER\Software\ODBC\ODBC.INI 
列有了公的富有 USER 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 
INTERNET Option 中 INTERNET 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
下还出接近之地方,是对具有用户的,我不怕无罗嗦了。 

2003-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 下的TSR
程序。实现方式如下: 

首先,在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 WORD 安装于你的系统面临常常,它见面把.DOC 文件与和谐涉嫌,当您双击一个DOC
文件,就见面启动MS
WORD,打开你指定的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; 
//建立一个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 
当你的应用程序是一个基于BDE
的数据库应用程序时,如果运行在一个尚未设置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; 
//建立一个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),你如果在这目录下多一个.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 下调试以及由此。 

2003-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. 

2003-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; 

2003-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. 

2003-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; 

2003-11-20 13:38:19 下Windows API 函数和注册表获取系统信息 

以出应用程序时,增加一桩显示计算机体系信息之意义,例如已装的软盘、硬盘、光驱、网络驱动器,硬盘的容量与剩下空间,显示器分辨率、键盘类型、鼠标的键数,内存大小、CPU
类型,Windows
的版号、产品标识、注册用户单位名和用户称、当前操作用户名等(
见运行图示),当然还有再多的音信,这样见面要您的顺序还友好。其实,有无数应用程序就是这样做的。 

经过调用Windows 的API 函数和看Windows
注册表,可以取大量的系统信息。Delphi 为大部分Windows API
函数提供了调用接口( 可参见DELPHI3\SOURCE\RTL\WIN\windows.pas
文件),并提供了一个效全面的TRegistry 类,使我们好便宜之调用Windows
API 函数和做客注册表,例如: 

1、function GetDriveType(lpRootPathName: PChar): UINT;
返回指定驱动器的品类。 

2、function GetDiskFreeSpace(lpRootPathName: PChar; var
lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters,
lpTotalNumberOfClusters: DWORD): BOOL;
返回指定驱动器的究竟簇数、剩余簇数及各簇扇区数、每扇区字节数,从而可以测算出到底容量与剩 
余空间。 

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

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

5、在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; 
以上就举几例,获取其他部分消息的法子与此类似,详见源程序。 

本程序在Pwin95、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_RAMDISK: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_BOTTOMRIGHT : buffer:=’ 最小化窗口:自右下角’; 
ARW_TOPLEFT : buffer:=’ 最小化窗口:自左上角’; 
ARW_TOPRIGHT : 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. 

2003-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里的,当然同样可形容及手上用户里! 

2003-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. 

2003-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属性中指定。 
如果取得某一个路子的之一键值,必须找到有一个主键,例如有如下一个路径存放着WORD97存放的程序路径: 
\Software\Microsoft\Office\8.0\Word\InstallRoot\Path 
里头,PATH是键,在它前面的哪怕是主键(键的门道),而这些键又是位于HKEY_LOCAL_MACHINE这个根键中之。当然,我们纪念使的凡PATH对应的多寡,而非是眷恋知道出PATH这个键是。PATH的型是一个字符串,所以要一个字符串变量存放它,例程中运用直接展示的方法表达她。 
故,读出PATH键数据的历程即应有是,确定根键,进入主键(路径),读出键的数据值。为了体现对注册表的形容操作,我们尚特别创建一个主键\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. 

2003-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 
   //根据Edit2的示为判断已出密码,进行验证 
   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 
  //进行第一次等变换 
   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; 

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

我们平常用底诸多软件都存有局部记得功能,如foxmail和TheBat等等。这些软件会于启动时自动的保持上平等不良关闭软件时之有些态,如窗口的起来位置,用户在软件被装置的有特色(如窗口作风,横相排列还是竖相排列等等),如果会被咱们的次第吗具备这样的一部分功力可要我们先后看起重新专业性一些:)
这里我就来讲一下什么使应用程序能记住上同差关闭时之窗口岗位,并于产一致软开行时同达到同一浅的职一样。
既是要保存信息,就必将要是干到存贮的题目。数据的储备有一些栽方法,可以写.ini 
或.inf文件,还可为此Delphi提供的文本类来自定义一个文件,还可以用数据库接口(如ODBC) 
引入一种数据库文件,foxpro
的.dbf和Access的.mdb比较常用,还可直接向Windows的登记表里写。写.ini和.inf文件并未其它的安全性,且无适合win95,还记在94,95年隔三差五用汉语的Windows3.2中大量之用了.ini文件,但Windows95出现后,微软建议尽量的管消息写及注册表中。用ODBC的讲话会吃程序带来众多勿必要之辛苦,如会如程序更加错综复杂,需要相应的DBMS的驱动程序的支撑,如果无对号入座数据源的驱动程序,则该数据源就不克采取,还有安全性问题呢无可知非常好的缓解。 
在此处推荐应用写注册表的措施。因为这种措施很有利,不欲太多额外的开,程序于简 
徒,对一般的用户来说在注册表里找到中之音于打开.ini文件要麻烦的大多。所以注册表的安全性比.ini文件要稍高片。 
设应用程序能记住上同不行关闭时之窗口岗位,并于就同糟糕开行时以及齐一样蹩脚的职位一样。总体 
思路是这么的:在关闭程序时如记录下本次次结束时之音,写副注册表中,在下次程序启动 
时常读注册表中相应信息,并赋给程序。 
对于我们这个程序来说要需要记录之音是窗口关闭时的Top,Left,Height,Width。 
只顾:要惦记如果Delphi可以操作注册表,必须概括registry单元。 

以下是根源程序及有关注释: 
unit Unit1; 

interface 

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

public 
ww:TRegistry; 
//声明一个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(‘位置’); 
//创建应用程序中某一个假设储备的类型之名号,便于管理 
ww.OpenKey(‘位置’,TRUE); 
if (ww.ReadString(‘first’)<>’1′)then 
//这是值得注意的一个地方,通过“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’) 
//便于下一致浅时利用。 
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:因为程序不可能以首先不善采用时,就起注册表里读数据,所以率先糟糕必须由程序予以一个 
乍值。然后开上记,表示已经生了第一不成了,以后只要判断有未是第一坏了,就足以读数据 
了。(这点最为着重,由这或多或少尚可以引出一个话题,那即便是足以做一个Demo版的软件,每次启动时向注册表里加个1,当>10时,就未能用该软件了,cool吧) 

2:往注册表里可以形容string型数据,也可以描绘Integer型数据,但以注册表中之Integer型数据是盖16进制形式有的,而我们当先后中因故的还是10迈入制数,所以索性写string型,然后据此StrToInt或IntToStr转换。

3:写注册表并无是颇安全之,它的情节可以据此RegEdit一览无佘的看来,所以绝对不克将一些重中之重之音(如密码)不经加密而直接写副注册表,这样做是深惊险的!! 

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

【编辑者说】: 
这咚咚写得正确,比上面的怪更详实,如果上面的杀看不知情即使扣留之吧,应该力所能及看懂的吧,要不然…. 

于DELPHI数据库应用程序中,我们看数据库一般有些许种植方法.一种植是透过BDE数据库搜索引擎,即采用DELPHI自带的数据库驱动程序,这种方法的长是快快,但下范围片,当数据库版本更新时,有或未可知用来操作新的数据库;另一样种植方法是由此ODBC,这种方法的长处是足以遵循操作系统(如WINDOWS)提供,作为标准接口能适应强数据库,缺点是速度慢.在编程时,我们好依据需要选择中间的等同种植方法. 

于使用ODBC访问数据库时,通常的方时是于ODBC管理面板中设置一个ODBC系统数据源
(系统DSN),然后在DBD中或者在次中安装一个数据库别名(Alias)对应当DSN,这样即便足以顺利地操作数据库了.相信用DELPHI做了数据库应用之程序员对当下上面曾坏熟悉了,笔者就非多说了.在骨子里采用被,笔者已遇过如此的动静,我们的数据库应用程序是借助ODBC系统数据源访问和操作数据库的,应用程序运行一直可以,直到某平等天,一个对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为一个驱动程序名称,如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中增一个字符串 
键值,为MyAccess = Microsoft Access
Driver(*.mdb),其中分别吗数据源名称以及数据库类型. 
当即是在注册表中登记一个系DSN名称. 

2.在HKEY_LOCAL_MACHINE\Software\ODBC\ODBC.INI中开创一个子键(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,然后在该下创办有
键值,详细描述一个系统DSN的数据库引擎配置信息,主要信息发生([]蒙之始末呢笔者注释): 

ImplicitCommitSync=Yes 
[字符串,可能意味着是否马上反映数据修改] 
MaxBufferSize=0x00000200(512) 
[数字,表示缓冲区大小] 
PageTimeout=0x00000005(5) 
[数字,表示页超时] 
Threads=0x00000003(3) 
[数字,可能代表支持之最好要命线程数目] 
UserCommitSync=Yes 
[字符串,可能代表是否马上以数据修改反映到用户] 
上述是树立一个体系DSN的核心信息(其它信息而选择或高档选项等消息吗在此地装, 
只不过因为采取默认信息,注册表里没有列出),我们在次中遵循上述手续操作注册表,同样为会增一个体系DSN或涂改该配置.在下面的例子程序中,将依上述步骤建立一个系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; 
//建立一个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( ‘MaxBufferSize’, 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对应一个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中都能就此到的 

2003-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打开注册表,一看您就是知晓了怎么使了) 

2003-11-20 14:37:11 用DEPHI为以软件建立注册机制 

【编者语】: 
点给了一个“使用DELPHI给程序加密的计”,想对这办法做一些补充说明,因为材料比老,请酌定参考。 

  如何维护自己的软件不吃非授权盗用的题目,始终困扰着各一个程序员。当前世界上保护 
软件的主意有好多,主要是使加密(如加软件狗)方式还是软件注册方式。使用软件狗等加密方 
法,虽然那个保障最管用,但对授权用户的正常化使用产生得之震慑,而且软件发给比较复杂,在实 
边界运用中比较少为运用。而注册登记办法虽然是眼下极其盛、运用最广大的法子,虽然发出许多通用 
软件其注册码可以生轻地受发烧友们所败,但对于独立程序员也某个一定应用设计之运用软件如果 
讲,采用注册机制显得太划算、最利于,而且在定之限定外十分实用。笔者在实际上工作备受,广 
发使用了软件注册方式,有效地掩护了软件之权益。 
  DEPHI软件的力量极为强大,深受程序员喜欢。用DEPHI开发之软件,可以挺便宜地在注册机制。下面笔者就如何以DEPHI开发的软件受到参加注册机制同爱侣等交流心得。 
  要落实软件注册机制,需解决以下几个问题: 
1、如何在注册检测,判断软件是否注册; 
2、如何隐藏注册码,及是否报之标志; 
3、在软件无注册情况下,如何限软件的利用时要次数; 
4、对正常用户而言,不应促成采用不便。 
于上述四个问题,如何隐藏注册码及是否注册的标志是关键。在WINDOWS95中,WIN95自家及多数之使用软件还将该各种参数放入注册表中,因而注册表内的数量显示极为巨大和错综复杂。如果用注册标志隐藏在注册表的某某平等角落中,想只要找到她并知道她是极其困难的从业。因此我们可以行使这一点,在注册表的某个分支上设置一个自名称及看不用特殊意义的关键字,将好软件之注册标志数据存放于此处。 
满注册机制至关重要是因为少个部分构成:检查和登记。通过检查标志值,得出软件是否曾经登记;若没报,则要看它们同意使用的次数是否已上;若只是运的次数已用了,则应提示用户输入注册码,进行注册;只有用户输入的注册码正确时,才被用户继续运用软件,同时用表明置为已注册,让用户永久性使用;否则允许使用的次数不达成,应以次数加相同; 
如用户注册输入的注册码错误或拒绝注册,则一直关门软件,拒绝其继承利用。当然,在软件允 
配施用次数不达成时,也承诺透过菜单项为用户提供机会进行登记登记。以下是笔者于实际付出 
遭,建立注册机制的程序代码及注释。 

如果软件之主程序窗口也FORM1,则拿该段代码置放在FORM1.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,则极端多特可用20涂鸦。 
        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环境被运行通过,并于实质上利用中获得证明。对官用户而言,这样的编制,只要该录入注册码一不成就好,不增加其便使用的承负;而对伪用户而言,除非他获注册码或重装WINDOWS95,否则超过利用次数后,将无法继续利用。当然在骨子里利用中还有众多地方得进一步增长反破解能力,欢迎朋友等提出批评与指导。 

2003-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’); 

原理说明: 
拿注册表中对应之键值删除就可了。 

2003-11-20 14:47:34 用Delphi实现壁纸更换(适用于Windows95/98) 

以Windows95/98遭遇,都是使用注册表对系统数据开展管理,有关壁纸的安装数据保存在 
Hkey_Current_User\Control Panel\Desktop的Wallpaper和TileWallpaper
等键值中,只要成功修改了立即片个键值,然后发消息被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); 
{向TileWallpaper 和Wallpaper串覆盖写副新价值} 
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″‘ 

2003-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》 

2003-11-20 15:13:50
问:如何被自己的顺序像“Explorer”一样,系统更开后能够回复到系统关闭时之状态?

【答】: 
其实是注册表在肇事,你也许曾经注意到,让自己的程序随着Windows的启航而启动是以“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run”下报了名,而如高达而的目的就是是当“..\RunOnce”下报即可。当然,余下的问题就是以啊时写副这个消息?如果你小心的话语,就会见发现Delphi本身附带了一个例子(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; 

2003-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’, ” 

2003-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. 

2003-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可以读取二前进制键值。

相关文章