വിൻഡോസിലെ രജിസ്ട്രി എന്താണ്?

നിങ്ങൾ വിശദാംശങ്ങളിലേക്ക് പോകാതെ, ആക്സസ് ചെയ്യാവുന്ന ഒരു നിർവചനം നൽകുക, തുടർന്ന്:

വിൻഡോസിൻ്റെ ആധുനിക പതിപ്പുകളിലെ രജിസ്ട്രിയെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ ഡാറ്റാബേസ് എന്ന് വിളിക്കാം. വിൻഡോസ്, ആപ്ലിക്കേഷൻ ക്രമീകരണങ്ങൾ എന്നിവ സംഭരിക്കുന്നതിനാണ് ഡാറ്റാബേസ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

നിങ്ങൾ മുമ്പ് അത്തരമൊരു ആശയം നേരിട്ടിട്ടില്ലെങ്കിൽ, ചില സാഹിത്യങ്ങൾ വായിക്കാൻ ഞാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. ഡെൽഫി ഉപയോഗിച്ച് രജിസ്ട്രിയിൽ പ്രവർത്തിക്കാൻ ആവശ്യമായ മിനിമം ഞാൻ ഇപ്പോൾ ചുരുക്കത്തിൽ നിങ്ങളോട് പറയും.

രജിസ്ട്രി കീകളുടെ ഉദ്ദേശ്യം.

രജിസ്ട്രിയിൽ സംഭരിച്ചിരിക്കുന്ന എല്ലാ ഡാറ്റയും നാല് ഗ്രൂപ്പുകളായി തിരിച്ചിരിക്കുന്നു:

• HKEY_CLASSES_ROOT(ചുരുക്കമുള്ള HKCR) - ഈ വിഭാഗം ആപ്ലിക്കേഷനുകളും ഫയൽ എക്സ്റ്റൻഷനുകളും തമ്മിലുള്ള ബന്ധങ്ങൾ സംഭരിക്കുന്നു. ലളിതമായി പറഞ്ഞാൽ, ഏത് പ്രോഗ്രാമാണ് ഏത് ഫയലുകൾ തുറക്കേണ്ടത്.
• HKEY_CURRENT_USER- ഉപയോക്താവിനെക്കുറിച്ചുള്ള ഡാറ്റ അടങ്ങിയിരിക്കുന്നു. ഈ ത്രെഡിൽ നിങ്ങൾക്ക് ഡെസ്ക്ടോപ്പിൻ്റെയും മറ്റ് ഉപയോക്തൃ ഡയറക്ടറികളുടെയും വിലാസം കാണാൻ കഴിയും.
• HKEY_LOCAL_MACHINE- ഈ രജിസ്ട്രി വിഭാഗം സിസ്റ്റത്തിൻ്റെ ആഗോള ഹാർഡ്‌വെയർ, സോഫ്റ്റ്‌വെയർ ക്രമീകരണങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംഭരിക്കുന്നു.
• HKEY_USERS- ഓരോ ഉപയോക്താവിനും വ്യക്തിഗത ക്രമീകരണങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
• HKEY_CURRENT_CONFIG- കമ്പ്യൂട്ടർ കോൺഫിഗറേഷൻ ഡാറ്റ.

ഓരോ രജിസ്ട്രി വിഭാഗവും കീകൾ സംഭരിക്കുന്നു, അവയിൽ ഓരോന്നിനും സബ്കീകൾ ഉണ്ടായിരിക്കാം.

ഓരോ രജിസ്ട്രി കീയ്ക്കും ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഉണ്ട്:

1. പാരാമീറ്ററിൻ്റെ പേര്
2. പാരാമീറ്റർ തരം
3. അർത്ഥം

അതിനാൽ, വിൻഡോസ് രജിസ്ട്രിയുമായി ബന്ധപ്പെട്ട അടിസ്ഥാന ആശയങ്ങൾ ഞങ്ങൾ അവലോകനം ചെയ്തു. നേരിട്ട് പ്രോഗ്രാമിംഗ് ആരംഭിക്കാൻ സമയമായി.

ഡെൽഫിയിലെ രജിസ്ട്രികളിൽ പ്രവർത്തിക്കുന്നു

രജിസ്ട്രിയിൽ പ്രവർത്തിക്കാൻ, ഞങ്ങൾ ഒരു റെഡിമെയ്ഡ് TRegIniFile ഒബ്ജക്റ്റ് ഉപയോഗിക്കും. ഈ ഒബ്‌ജക്റ്റ് ഞങ്ങൾക്ക് ലഭ്യമാക്കുന്നതിന്, ഉപയോഗ വിഭാഗത്തിൽ രജിസ്ട്രി മൊഡ്യൂൾ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്.

അതിനാൽ, ഒരു ചെറിയ ആപ്ലിക്കേഷൻ എഴുതുന്നതാണ് നല്ലതെന്ന് ഞാൻ കരുതുന്നു. ഞങ്ങൾ രജിസ്ട്രിയിൽ നൽകിയ മൂല്യം പ്രോഗ്രാം സംരക്ഷിക്കുകയോ വായിക്കുകയോ ചെയ്യും. നമുക്ക് രൂപം വരയ്ക്കാം.

ആദ്യത്തെ ഫീൽഡിൽ നമ്മൾ സേവ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന വേരിയബിൾ നൽകും. രണ്ടാമത്തെ വിൻഡോയിൽ രജിസ്ട്രിയിൽ നിന്ന് വായിച്ച മൂല്യം ഞങ്ങൾ പ്രദർശിപ്പിക്കും. അനുബന്ധ ബട്ടണുകൾ അമർത്തി ഞങ്ങൾ ഇത് ചെയ്യും.

നിങ്ങൾ BSave ബട്ടൺ അമർത്തുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം:

നടപടിക്രമം TForm1. BSave ക്ലിക്ക് (അയക്കുന്നയാൾ: TObject); var FReestr: TRegIniFile; // വേരിയബിൾ നിർവചിക്കുക FReestr:=TRegIniFile.Create("സോഫ്റ്റ്‌വെയർ"); // FReestr.OpenKey ("MyProg",true) ആരംഭിക്കുക; // ആവശ്യമുള്ള കീ തുറക്കുക FReestr.WriteString("value1","test",ESave.Text); // FreeAndNil (FReestr) മൂല്യം നൽകുക; // വേരിയബിൾ എൻഡ് നശിപ്പിക്കുക;

ആദ്യം നമ്മൾ TRegIniFile ടൈപ്പിൻ്റെ ഒരു വേരിയബിൾ നിർവചിക്കുന്നു. തുടർന്ന് ഞങ്ങൾ അത് സമാരംഭിക്കുന്നു, ഇതിനായി ഞങ്ങൾ സൃഷ്ടിക്കൽ രീതി എന്ന് വിളിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, HKEY_CURRENT_USER ബ്രാഞ്ച് ഞങ്ങൾക്കായി തുറക്കും. കൺസ്ട്രക്റ്റർ പാരാമീറ്റർ (“സോഫ്റ്റ്‌വെയർ”) ഞങ്ങളോട് അതേ പേരിലുള്ള ബ്രാഞ്ച് വിഭാഗത്തിലേക്ക് ഉടൻ പോകുമെന്ന് പറയുന്നു. നിങ്ങൾ കൺസ്ട്രക്റ്റർക്ക് ഒരു മൂല്യവും നൽകുന്നില്ലെങ്കിൽ, മോശമായ ഒന്നും സംഭവിക്കില്ല. തുടക്കത്തിനു ശേഷം പ്രധാന ശാഖയുടെ വേരിൽ നമ്മൾ സ്വയം കണ്ടെത്തും. നിങ്ങൾക്ക് മറ്റൊരു രജിസ്ട്രി ബ്രാഞ്ച് ആവശ്യമുണ്ടെങ്കിൽ, വേരിയബിൾ ആരംഭിച്ചതിന് ശേഷം, RootKey പാരാമീറ്ററിന് ഉചിതമായ മൂല്യം നൽകുക.

ഉദാഹരണത്തിന്:

FReestr.RootKey:= HKEY_CLASSES_ROOT;

സമാരംഭിച്ച ശേഷം, നമുക്ക് താൽപ്പര്യമുള്ള ഉപവിഭാഗത്തിലേക്ക് പോകണം - രീതി ഓപ്പൺകീ. രീതിക്ക് രണ്ട് പാരാമീറ്ററുകളുണ്ട്: ഉപവിഭാഗത്തിൻ്റെ പേരും അത് നിലവിലില്ലെങ്കിൽ അത് സൃഷ്ടിക്കേണ്ടതുണ്ടോ എന്നതും. നടപടിക്രമം ഓപ്പൺകീനിങ്ങൾ ആഗ്രഹിക്കുന്ന ഉപവിഭാഗത്തിൽ എത്തുന്നതുവരെ നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര തവണ വിളിക്കാം.

ഇപ്പോൾ നമുക്ക് നേരിട്ട് റെക്കോർഡിംഗിലേക്ക് പോകാം. WriteString- അതാണ് ഞങ്ങളെ സഹായിക്കുന്നത്. നമുക്ക് മൂന്ന് പാരാമീറ്ററുകൾ കൈമാറാം:

1. ഉപവിഭാഗത്തിൻ്റെ പേര്
2. പാരാമീറ്ററിൻ്റെ പേര്
3. അർത്ഥം

ഈ രീതിയെ WriteString എന്ന് വിളിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക - ഇത് സ്ട്രിംഗുകൾ എഴുതാൻ ഉപയോഗിക്കുന്നു; നിങ്ങൾക്ക് ഒരു സംഖ്യ എഴുതണമെങ്കിൽ, WriteInteger ഉപയോഗിക്കുക, അങ്ങനെ സാമ്യം ഉപയോഗിച്ച്.

മൂല്യം സംരക്ഷിച്ച ശേഷം, നമുക്ക് വേരിയബിൾ ഇല്ലാതാക്കാം.

FreeAndNil(FReestr);

നിങ്ങൾ BLoad ബട്ടൺ അമർത്തുമ്പോൾ, ഇനിപ്പറയുന്നവ സംഭവിക്കുന്നു:

നടപടിക്രമം TForm1.BLoadClick(അയക്കുന്നയാൾ: TObject); var FReestr: TRegIniFile; FReestr ആരംഭിക്കുക:=TRegIniFile.Create("സോഫ്റ്റ്‌വെയർ"); FReestr.OpenKey("MyProg",true); ELoad.Text:=FReestr.ReadString("മൂല്യം1","ടെസ്റ്റ്","വായിച്ചിട്ടില്ല"); FreeAndNil(FReestr); അവസാനിക്കുന്നു;

FReestr.ReadString രീതി ഒഴികെ എല്ലാം വളരെ സമാനമാണ്. ഈ രീതി “മൂല്യം1” കീയിൽ നിന്ന് “ടെസ്റ്റ്” പാരാമീറ്റർ വായിക്കുന്നു; അത്തരമൊരു പാരാമീറ്റർ ഇല്ലെങ്കിലോ അത് വായിക്കാൻ കഴിയുന്നില്ലെങ്കിലോ, “വായിച്ചിട്ടില്ല” എന്ന മൂല്യം നിയുക്തമാക്കിയിരിക്കുന്നു.

ഡെൽഫിയിലെ രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നതിൻ്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഇപ്പോൾ നിങ്ങൾക്കറിയാം; നിങ്ങൾക്ക് കൂടുതൽ വിശദീകരിക്കണമെങ്കിൽ, ചുവടെയുള്ള അഭിപ്രായങ്ങളിൽ നിങ്ങളുടെ ചോദ്യങ്ങൾ ചോദിക്കുക.

1. ഒരു പുതിയ പ്രമാണം സൃഷ്ടിക്കുക, അത് Windows/ShellNew ഫോൾഡറിൽ സ്ഥാപിക്കുക

2. രജിസ്ട്രി എഡിറ്ററിൽ, ഈ ഫയലിൻ്റെ വിപുലീകരണം കണ്ടെത്തുക, ഒരു പുതിയ സബ്കീ ചേർക്കുക, അവിടെ ലൈൻ ചേർക്കുക: സൃഷ്ടിച്ച ഫയലിൻ്റെ പേര് വ്യക്തമാക്കുന്ന മൂല്യമായി FileName.

രജിസ്റ്റർ ചെയ്യാത്ത ഫയലുകൾ തുറക്കുന്ന ഫയലിലേക്കുള്ള പാത

1. HKEY_CLASSES_ROOT\Unknown\Shell എന്ന കീ കണ്ടെത്തുക

2. ഒരു പുതിയ ഓപ്പൺ കീ ചേർക്കുക

3. ഈ കീയ്ക്ക് കീഴിൽ കമാൻഡ് എന്ന് പേരുള്ള ഒരു കീയും ഉണ്ട്, അതിൽ നിങ്ങൾ മൂല്യം (സ്ഥിരസ്ഥിതി) സമാരംഭിക്കുന്ന ഫയലിൻ്റെ പേരിലേക്ക് മാറ്റുന്നു, നിങ്ങൾ പേരിലേക്ക് % 1 ചേർക്കേണ്ടതുണ്ട്. (വിൻഡോസ് ഈ പ്രതീകത്തെ സമാരംഭിക്കുന്ന ഫയലിൻ്റെ പേര് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും)

എക്സ്പ്ലോററിൽ, സന്ദർഭ മെനു "പുതിയ വിൻഡോയിൽ തുറക്കുക"

1. HKEY_CLASSES_ROOT\Directory\Shell എന്ന കീ കണ്ടെത്തുക

2. ഒരു സബ്‌കീ സൃഷ്‌ടിക്കുക: തുറക്കുക, അതിൽ മൂല്യം (സ്ഥിരസ്ഥിതി) മാറ്റുക: "ഒരു പുതിയ വിൻഡോയിൽ തുറക്കുക"

3. ഈ കീക്ക് കീഴിൽ, മറ്റൊരു സബ്കീ കമാൻഡ് ഉണ്ടാക്കുക (Default) = explorer% 1

ഒരു ലോജിടെക് മൗസിൻ്റെ മധ്യ ബട്ടൺ ഡബിൾ ക്ലിക്ക് ആയി ഉപയോഗിക്കുന്നു

HKEY_LOCAL_MACHINE\SoftWare\Logitech കണക്റ്റുചെയ്‌ത് അവിടെ DoubleClick പാരാമീറ്റർ കണ്ടെത്തുക, 000-നെ 001 ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക

പുതിയ ശബ്ദ ഇവൻ്റുകൾ

ഉദാഹരണത്തിന്, WinWord ആരംഭിക്കുന്നതിനും അടയ്ക്കുന്നതിനുമായി ഇത് ശബ്ദങ്ങൾ സൃഷ്ടിക്കുന്നു

HKEY_CURRENT_USER\AppEvents\Shemes\Apps WinWord സബ്കീ ചേർക്കുകയും അതിലേക്ക് തുറക്കുകയും അടയ്ക്കുകയും ചെയ്യുക.

പുതിയ ഇവൻ്റുകൾ ഇപ്പോൾ ശബ്‌ദ ക്രമീകരണങ്ങളിൽ ദൃശ്യമാണ്

പ്രോഗ്രാമുകൾ അൺഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള രജിസ്ട്രിയിലെ പാത:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall

ഡെൽഫി 1 ലെ രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നു

ഡെൽഫി 2-ലും അതിനു മുകളിലും, TRegistry ഒബ്‌ജക്റ്റ് പ്രത്യക്ഷപ്പെട്ടു, അത് ഉപയോഗിച്ച് രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നത് വളരെ എളുപ്പമാണ്. എന്നാൽ ഇവിടെ നമ്മൾ ഡെൽഫി 1-ലും ലഭ്യമായ API ഫംഗ്‌ഷനുകൾ നോക്കും.

സിസ്റ്റം വേരിയബിളുകൾ സംഭരിക്കുന്നതിനാണ് രജിസ്ട്രി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്, കൂടാതെ പ്രോഗ്രാം ഫയലുകൾ രജിസ്റ്റർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അവ അനുബന്ധ ഐക്കൺ ഉപയോഗിച്ച് എക്സ്പ്ലോററിൽ പ്രദർശിപ്പിക്കുമെന്ന് ഉറപ്പാക്കുന്നു, നിങ്ങൾ ഈ ഫയലിൽ ക്ലിക്കുചെയ്യുമ്പോൾ പ്രോഗ്രാമിനെ വിളിക്കുന്നു, കൂടാതെ മെനുവിലേക്ക് നിരവധി കമാൻഡുകൾ ചേർക്കുന്നു. ഫയലിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്യുമ്പോൾ വിളിച്ചു. കൂടാതെ, നിങ്ങളുടെ ചില വിവരങ്ങൾ രജിസ്ട്രിയിൽ നൽകാം (വേരിയബിളുകൾ, കോൺസ്റ്റൻ്റ്സ്, ഇൻസ്റ്റാൾ ചെയ്ത പ്രോഗ്രാമിനെക്കുറിച്ചുള്ള ഡാറ്റ...). നിങ്ങൾക്ക് അൺഇൻസ്റ്റാൾ ലിസ്റ്റിലേക്ക് ഒരു പ്രോഗ്രാം ചേർക്കാൻ കഴിയും, അത് കൺട്രോൾ പാനലിലെ ആഡ്/റിമൂവ് പ്രോഗ്രാംസ് മാനേജറിൽ നിന്ന് അത് നീക്കംചെയ്യാൻ നിങ്ങളെ അനുവദിക്കും.

രജിസ്ട്രിയിൽ പ്രവർത്തിക്കാൻ നിരവധി API ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു:

RegCreateKey(കീ: HKey; സബ്കീ: PChar; var ഫലം: HKey): നീളം;

രജിസ്ട്രിയിൽ ഒരു സബ്കീ സൃഷ്ടിക്കുക. "റൂട്ട്" രജിസ്ട്രി വിഭാഗത്തിലേക്കുള്ള പ്രധാന പോയിൻ്റുകൾ, ഡെൽഫി1-ൽ ഒരെണ്ണം മാത്രമേ ലഭ്യമാകൂ - HKEY_CLASSES_ROOT, Delphi3-ൽ - എല്ലാം. സബ്കീ - വിഭാഗത്തിൻ്റെ പേര് - ഡോസിലെ ഫയലിലേക്കുള്ള പാതയുടെ തത്വമനുസരിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത് (ഉദാഹരണം subkey1\subkey2\ ...). അത്തരമൊരു വിഭാഗം ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തുറക്കും (ഏത് സാഹചര്യത്തിലും, കോൾ വിജയകരമാണെങ്കിൽ, ഫലത്തിൽ വിഭാഗത്തിനുള്ള ഹാൻഡിൽ അടങ്ങിയിരിക്കുന്നു). റിട്ടേൺ മൂല്യം അനുസരിച്ചാണ് കോളിൻ്റെ വിജയം നിർണ്ണയിക്കുന്നത്; ERROR_SUCCESS എങ്കിൽ, വിജയം, അല്ലെങ്കിൽ ഒരു പിശക്.

RegOpenKey(കീ: HKey; സബ്കീ: PChar; var ഫലം: HKey): ലോംഗിൻറ്;

കീ\ സബ്കീ സബ്കീ തുറന്ന് ഫല വേരിയബിളിൽ ഹാൻഡിൽ തിരികെ നൽകുക. ആ പേരിൽ ഒരു വിഭാഗവും ഇല്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടുന്നില്ല. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ വിജയകരമാണെങ്കിൽ ERROR_SUCCESS.

RegCloseKey(കീ: HKey): ദൈർഘ്യമേറിയത്;

കീ പരാമർശിച്ച വിഭാഗം അടയ്‌ക്കുന്നു. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ വിജയകരമാണെങ്കിൽ ERROR_SUCCESS.

RegDeleteKey(കീ: HKey; സബ്കീ: PChar): ദൈർഘ്യമേറിയത്;

കീ\സബ്കീ സബ്കീ ഇല്ലാതാക്കുക. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ പിശകുകൾ ഇല്ലെങ്കിൽ ERROR_SUCCESS.

RegEnumKey(കീ: HKey; സൂചിക: രേഖാംശം; ബഫർ: PChar; cb: നീളം): നീളം;

കീ വിഭാഗത്തിൻ്റെ എല്ലാ ഉപവിഭാഗങ്ങളുടെയും പേരുകൾ നേടുക, അവിടെ കീ തുറന്നതോ സൃഷ്‌ടിച്ചതോ ആയ വിഭാഗത്തിനായുള്ള ഹാൻഡിൽ (RegCreateKey, RegOpenKey എന്നിവ കാണുക), ബഫർ ബഫറിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്, cb എന്നത് ബഫറിൻ്റെ വലുപ്പമാണ്, സൂചികയാണ് സൂചിക, ആദ്യമായി RegEnumKey വിളിക്കുമ്പോൾ 0 ന് തുല്യമായിരിക്കണം. RegEnumKey-ലേക്കുള്ള അടുത്ത കോൾ പരാജയപ്പെടുന്നത് വരെ സൂചിക വർദ്ധിപ്പിച്ചിരിക്കുന്ന ഒരു സമയത്ത് ലൂപ്പിലാണ് സാധാരണ ഉപയോഗം (ഉദാഹരണം കാണുക).

RegQueryValue(കീ: HKey; ഉപകീ: PChar; മൂല്യം: PChar; var cb: Longint): നീളം;

കീ\SubKey. മൂല്യം - സ്ട്രിങ്ങിനുള്ള ബഫർ എന്ന കീയുമായി ബന്ധപ്പെട്ട ടെക്സ്റ്റ് സ്ട്രിംഗ് നൽകുന്നു; cb എന്നത് വലുപ്പമാണ്, ഇൻപുട്ട് എന്നത് ബഫറിൻ്റെ വലുപ്പമാണ്, ഔട്ട്‌പുട്ട് എന്നത് മടങ്ങിയ സ്ട്രിംഗിൻ്റെ നീളമാണ്. റിട്ടേൺ - പിശക് കോഡ്.

RegSetValue(കീ: HKey; സബ്കീ: PChar; ValType: Longint; മൂല്യം: PChar; cb: Longint): നീളം;

കീ\സബ്കീ കീ, ValType - വേരിയബിളിൻ്റെ തരം, മൂല്യം - വേരിയബിളിനുള്ള ബഫർ, cb - ബഫർ വലുപ്പം എന്നിവയ്ക്കായി ഒരു പുതിയ മൂല്യം സജ്ജമാക്കുക. Windows 3.1-ൽ Value=REG_SZ മാത്രമേ അനുവദനീയമായിട്ടുള്ളൂ. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ പിശകുകൾ ഇല്ലെങ്കിൽ ERROR_SUCCESS.

(നിർദ്ദിഷ്‌ട വിഭാഗത്തിലെ എല്ലാ ഉപവിഭാഗങ്ങളുടെയും ഒരു ലിസ്റ്റ് സൃഷ്‌ടിക്കുക) നടപടിക്രമം TForm1.Button1Click(അയയ്ക്കുന്നയാൾ: TObject); var MyKey: HKey; (ഒരു വിഭാഗത്തിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഹാൻഡിൽ) ബഫർ: ചാറിൻ്റെ നിര; (ബഫർ) പിശക്, (പിശക് കോഡ്) സൂചിക: ദൈർഘ്യം; ( Subkey index ) ആരംഭിക്കുന്നത് Err:=RegOpenKey(HKEY_CLASSES_ROOT,"DelphiUnit",MyKey); (തുറന്ന വിഭാഗം) പിഴവാണെങ്കിൽ<>ERROR_SUCCESS തുടർന്ന് MessageDlg ആരംഭിക്കുക ("അത്തരമൊരു വിഭാഗമില്ല!",mtError,,0); പുറത്ത്; അവസാനിക്കുന്നു; സൂചിക:=0; (ആദ്യ സബ്കീയുടെ പേര് നിർവചിച്ചു) Err:=RegEnumKey(MyKey,index,Buffer,Sizeof(Buffer)); err=ERROR_SUCCESS ചെയ്യുമ്പോൾ (ഉപവിഭാഗങ്ങൾ ഉള്ളപ്പോൾ ലൂപ്പ് ചെയ്യുക) ആരംഭിക്കുക memo1.lines.add(StrPas(Buffer)); (ലിസ്റ്റിലേക്ക് ഉപവിഭാഗത്തിൻ്റെ പേര് ചേർക്കുക) inc(ഇൻഡക്സ്); (ഉപകീ നമ്പർ വർദ്ധിപ്പിക്കുക) പിശക്:=RegEnumKey(MyKey,index,Buffer,Sizeof(Buffer)); (അഭ്യർത്ഥന) അവസാനം; RegCloseKey(MyKey); (ഉപവിഭാഗം അടച്ചു) അവസാനം;

INIFILES ഒബ്‌ജക്റ്റ് - INI ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു.

രജിസ്ട്രിയേക്കാൾ INI ഫയലുകൾ ഉപയോഗിക്കുന്നതാണ് ചിലപ്പോൾ നല്ലത്?

• 1. INI ഫയലുകൾ ഒരു സാധാരണ നോട്ട്പാഡിൽ കാണാനും എഡിറ്റ് ചെയ്യാനും കഴിയും.
• 2. പ്രോഗ്രാമിനൊപ്പം ഫോൾഡറിൽ INI ഫയൽ സംഭരിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ മറ്റൊരു കമ്പ്യൂട്ടറിലേക്ക് ഫോൾഡർ കൈമാറുമ്പോൾ, ക്രമീകരണങ്ങൾ സംരക്ഷിക്കപ്പെടും. (ഒരു ഫ്ലോപ്പി ഡിസ്കിൽ ചേരാത്ത ഒരു പ്രോഗ്രാം പോലും ഞാൻ ഇതുവരെ എഴുതിയിട്ടില്ല :)
• 3. രജിസ്ട്രിയിൽ പുതുതായി വരുന്ന ഒരാൾക്ക് എളുപ്പത്തിൽ ആശയക്കുഴപ്പത്തിലാകാം അല്ലെങ്കിൽ (ദൈവം വിലക്കട്ടെ) എന്തെങ്കിലും തെറ്റ് മാറ്റാം.

അതിനാൽ, പ്രോഗ്രാം ക്രമീകരണങ്ങൾ സംഭരിക്കുന്നതിന് സാധാരണ വിൻഡോസ് INI ഫയലുകൾ ഉപയോഗിക്കുന്നത് സൗകര്യപ്രദമാണ്. IniFiles മൊഡ്യൂളിൻ്റെ TIniFiles ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ചാണ് INI ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത്. TIniFiles ഒബ്ജക്റ്റിൻ്റെ രീതികളുടെ ഒരു ഹ്രസ്വ വിവരണം ചുവടെ നൽകിയിരിക്കുന്നു.

കൺസ്ട്രക്ടർ സൃഷ്‌ടിക്കുക("d:\test.INI");

ഒരു ഒബ്‌ജക്‌റ്റിൻ്റെ ഒരു ഉദാഹരണം സൃഷ്‌ടിച്ച് അതിനെ ഒരു ഫയലുമായി ബന്ധപ്പെടുത്തുക. അത്തരമൊരു ഫയൽ ഇല്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും, പക്ഷേ നിങ്ങൾ അതിൽ വിവരങ്ങൾ എഴുതുമ്പോൾ മാത്രം.

WriteBool (const Section, Ident: string; Value: Boolean);

വിഭാഗത്തിൻ്റെ ഐഡൻറ് എന്ന് പേരിട്ടിരിക്കുന്ന ഘടകം ഒരു ബൂളിയൻ മൂല്യത്തിലേക്ക് അസൈൻ ചെയ്യുക

WriteInteger(const Section, Ident: string; Value: Longint);

വിഭാഗത്തിൻ്റെ ഐഡൻറ് എന്ന് പേരിട്ടിരിക്കുന്ന ഘടകത്തിന് ലോഞ്ചിൻ്റ് തരത്തിൻ്റെ ഒരു മൂല്യം നൽകുക

WriteString(const Section, Ident, Value: string);

വിഭാഗത്തിൻ്റെ ഐഡൻറ് എന്ന് പേരിട്ടിരിക്കുന്ന ഘടകം സ്ട്രിംഗ് ടൈപ്പിൻ്റെ മൂല്യത്തിലേക്ക് അസൈൻ ചെയ്യുക

ReadSection(const Section: string; Strings: TStrings);

ReadSectionValues(const Section: string; Strings: TStrings);

EraseSection(const വിഭാഗം: സ്ട്രിംഗ്);

ഒരു വിഭാഗം അതിൻ്റെ എല്ലാ ഉള്ളടക്കങ്ങളും ഇല്ലാതാക്കുക

ReadBool(const Section, Ident: string; Default: Boolean): Boolean;

ReadInteger(const Section, Ident: string; Default: Longint): Longint;

ReadString(const Section, Ident, Default: string): string;

ഉറവിടം അടച്ച് റിലീസ് ചെയ്യുക. INI ഫയൽ ഉപയോഗിച്ച് ജോലി പൂർത്തിയാക്കുമ്പോൾ വിളിക്കണം

പ്രോപ്പർട്ടി മൂല്യങ്ങൾ: സ്ട്രിംഗ്;

പേര് പ്രകാരം നിലവിലുള്ള പാരാമീറ്റർ ആക്സസ് ചെയ്യുന്നു

നടപടിക്രമം TForm1.FormClose(അയക്കുന്നയാൾ: TObject); var IniFile:TIniFile; IniFile ആരംഭിക്കുക:= TIniFile.Create("d:\test.INI"); (ഒരു ഒബ്‌ജക്റ്റ് ഇൻസ്‌റ്റൻസ് സൃഷ്‌ടിച്ചു) IniFile.WriteBool("ഓപ്‌ഷനുകൾ", "ശബ്‌ദം", ശരി); ( ഓപ്‌ഷൻ വിഭാഗം: ശബ്‌ദം:=ട്രൂ ) IniFile.WriteInteger("ഓപ്‌ഷനുകൾ", "ലെവൽ", 3); (വിഭാഗം ഓപ്ഷനുകൾ: ലെവൽ:=3 ) IniFile.WriteString("ഓപ്ഷനുകൾ" , "രഹസ്യ രഹസ്യവാക്ക്", പാസ്); ( ഓപ്‌ഷനുകൾ വിഭാഗം: രഹസ്യ പാസ്‌വേഡിൽ പാസ് വേരിയബിളിൻ്റെ മൂല്യം എഴുതുക ) IniFile.ReadSection("Options ", memo1.lines); (വേരിയബിൾ പേരുകൾ വായിക്കുന്നു) IniFile.ReadSectionValues("Options ", memo2.lines); (പേരുകളും മൂല്യങ്ങളും വായിക്കുന്നു) IniFile.Free; (ഫയൽ അടയ്ക്കുക, ഒബ്ജക്റ്റ് നശിപ്പിക്കുക, മെമ്മറി സ്വതന്ത്രമാക്കുക) അവസാനം;

ഡെൽഫിയിലെ രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നു

പുതിയ സന്ദർഭ മെനുവിലേക്ക് ഇനങ്ങൾ ചേർക്കുന്നു

1. ഒരു പുതിയ പ്രമാണം സൃഷ്‌ടിച്ച് അത് Windows/ShellNew ഫോൾഡറിൽ സ്ഥാപിക്കുക
2. രജിസ്ട്രി എഡിറ്ററിൽ, ഈ ഫയലിൻ്റെ വിപുലീകരണം കണ്ടെത്തുക, ഒരു പുതിയ സബ്കീ ചേർക്കുക, അവിടെ ലൈൻ ചേർക്കുക: FileName അതിൻ്റെ മൂല്യമായി സൃഷ്ടിച്ച ഫയലിൻ്റെ പേര് വ്യക്തമാക്കുക.

രജിസ്റ്റർ ചെയ്യാത്ത ഫയലുകൾ തുറക്കുന്ന ഫയലിലേക്കുള്ള പാത

1. താക്കോൽ കണ്ടെത്തുക HKEY_CLASSES_റൂട്ട്\അജ്ഞാതം\ഷെൽ
2. ഒരു പുതിയ ഓപ്പൺ കീ ചേർക്കുക
3. ഈ കീയുടെ കീഴിൽ ഒരു കീ എന്ന പേരിൽ ഒരു കമാൻഡ് ഉണ്ട്, അതിൽ നിങ്ങൾ മൂല്യം (സ്ഥിരസ്ഥിതി) സമാരംഭിക്കുന്ന ഫയലിൻ്റെ പേരിലേക്ക് മാറ്റുന്നു, നിങ്ങൾ പേരിലേക്ക് % 1 ചേർക്കേണ്ടതുണ്ട്. (വിൻഡോസ് ഈ പ്രതീകത്തെ സമാരംഭിക്കുന്ന ഫയലിൻ്റെ പേര് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും)

എക്സ്പ്ലോററിലെ സന്ദർഭ മെനു"തുറക്കുകവിപുതിയത്ജാലകം"

1. താക്കോൽ കണ്ടെത്തുക HKEY_CLASSES_ROOT\Directory\Shell
2. ഒരു സബ്‌കീ സൃഷ്‌ടിക്കുക: opennew അതിൽ മൂല്യം (സ്ഥിരസ്ഥിതി) ഇതിലേക്ക് മാറ്റുക: "ഒരു പുതിയ വിൻഡോയിൽ തുറക്കുക"
3. ഈ കീക്ക് കീഴിൽ, മറ്റൊരു സബ്കീ കമാൻഡ് ഉണ്ടാക്കുക (Default) = explorer% 1

ഒരു ലോജിടെക് മൗസിൻ്റെ മധ്യ ബട്ടൺ ഡബിൾ ക്ലിക്ക് ആയി ഉപയോഗിക്കുന്നു

HKEY_LOCAL_MACHINE\SoftWare\Logitech കണക്റ്റുചെയ്‌ത് അവിടെ DoubleClick പാരാമീറ്റർ കണ്ടെത്തുക, 000-നെ 001 ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക

പുതിയ ശബ്ദ ഇവൻ്റുകൾ

ഉദാഹരണത്തിന്, WinWord ആരംഭിക്കുന്നതിനും അടയ്ക്കുന്നതിനുമായി ഇത് ശബ്ദങ്ങൾ സൃഷ്ടിക്കുന്നു

HKEY_CURRENT_USER\AppEvents\Shemes\Apps WinWord സബ്കീയും ഓപ്പൺ, ക്ലോസ് സബ്കീകളും ചേർക്കുക.

പുതിയ ഇവൻ്റുകൾ ഇപ്പോൾ ശബ്‌ദ ക്രമീകരണങ്ങളിൽ ദൃശ്യമാണ്

പ്രോഗ്രാമുകൾ അൺഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള രജിസ്ട്രിയിലെ പാത:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall

ഡെൽഫി 1 ലെ രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നു

ഡെൽഫി 2-ലും അതിന് മുകളിലും, TRegistry ഒബ്‌ജക്റ്റ് പ്രത്യക്ഷപ്പെട്ടു, അത് ഉപയോഗിച്ച് രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നത് വളരെ എളുപ്പമാണ്. എന്നാൽ ഇവിടെ നമ്മൾ ഡെൽഫി 1-ലും ലഭ്യമായ API ഫംഗ്‌ഷനുകൾ നോക്കും.

സിസ്റ്റം വേരിയബിളുകൾ സംഭരിക്കുന്നതിനാണ് രജിസ്ട്രി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്, കൂടാതെ പ്രോഗ്രാം ഫയലുകൾ രജിസ്റ്റർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അവ അനുബന്ധ ഐക്കൺ ഉപയോഗിച്ച് എക്സ്പ്ലോററിൽ പ്രദർശിപ്പിക്കുമെന്ന് ഉറപ്പാക്കുന്നു, നിങ്ങൾ ഈ ഫയലിൽ ക്ലിക്കുചെയ്യുമ്പോൾ പ്രോഗ്രാമിനെ വിളിക്കുന്നു, കൂടാതെ മെനുവിലേക്ക് നിരവധി കമാൻഡുകൾ ചേർക്കുന്നു. നിങ്ങൾ ഫയലിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്യുമ്പോൾ വിളിച്ചു. കൂടാതെ, നിങ്ങളുടെ ചില വിവരങ്ങൾ രജിസ്ട്രിയിൽ നൽകാം (വേരിയബിളുകൾ, കോൺസ്റ്റൻ്റ്സ്, ഇൻസ്റ്റാൾ ചെയ്ത പ്രോഗ്രാമിനെക്കുറിച്ചുള്ള ഡാറ്റ...). നിങ്ങൾക്ക് അൺഇൻസ്റ്റാൾ ലിസ്റ്റിലേക്ക് ഒരു പ്രോഗ്രാം ചേർക്കാൻ കഴിയും, അത് കൺട്രോൾ പാനലിലെ ആഡ്/റിമൂവ് പ്രോഗ്രാംസ് മാനേജറിൽ നിന്ന് അത് നീക്കംചെയ്യാൻ നിങ്ങളെ അനുവദിക്കും.

രജിസ്ട്രിയിൽ പ്രവർത്തിക്കാൻ നിരവധി API ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു:

രജിസ്ട്രിയിൽ ഒരു സബ്കീ സൃഷ്ടിക്കുക. "റൂട്ട്" രജിസ്ട്രി വിഭാഗത്തിലേക്കുള്ള പ്രധാന പോയിൻ്റുകൾ, ഡെൽഫി1-ൽ ഒരെണ്ണം മാത്രമേ ലഭ്യമാകൂ - HKEY_CLASSES_ROOT, Delphi3-ൽ - എല്ലാം. സബ്കീ - വിഭാഗത്തിൻ്റെ പേര് - ഡോസിലെ ഫയലിലേക്കുള്ള പാതയുടെ തത്വമനുസരിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത് (ഉദാഹരണം subkey1\subkey2\ ...). അത്തരമൊരു വിഭാഗം ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തുറക്കും (ഏത് സാഹചര്യത്തിലും, കോൾ വിജയകരമാണെങ്കിൽ, ഫലത്തിൽ വിഭാഗത്തിനുള്ള ഹാൻഡിൽ അടങ്ങിയിരിക്കുന്നു). റിട്ടേൺ മൂല്യം അനുസരിച്ചാണ് കോളിൻ്റെ വിജയം നിർണ്ണയിക്കുന്നത്; ERROR_SUCCESS എങ്കിൽ, വിജയം, അല്ലെങ്കിൽ ഒരു പിശക്.

കീ പരാമർശിച്ച വിഭാഗം അടയ്‌ക്കുന്നു. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ വിജയകരമാണെങ്കിൽ ERROR_SUCCESS.

കീ വിഭാഗത്തിൻ്റെ എല്ലാ ഉപവിഭാഗങ്ങളുടെയും പേരുകൾ നേടുക, അവിടെ കീ തുറന്നതോ സൃഷ്‌ടിച്ചതോ ആയ വിഭാഗത്തിനായുള്ള ഹാൻഡിൽ (RegCreateKey, RegOpenKey എന്നിവ കാണുക), ബഫർ ബഫറിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്, cb എന്നത് ബഫറിൻ്റെ വലുപ്പമാണ്, സൂചികയാണ് സൂചിക, ആദ്യമായി RegEnumKey വിളിക്കുമ്പോൾ 0 ന് തുല്യമായിരിക്കണം. RegEnumKey-ലേക്കുള്ള അടുത്ത കോൾ പരാജയപ്പെടുന്നത് വരെ സൂചിക വർദ്ധിപ്പിച്ചിരിക്കുന്ന ഒരു സമയത്ത് ലൂപ്പിലാണ് സാധാരണ ഉപയോഗം (ഉദാഹരണം കാണുക).

കീ\സബ്കീ കീ, ValType - വേരിയബിളിൻ്റെ തരം, മൂല്യം - വേരിയബിളിനുള്ള ബഫർ, cb - ബഫർ വലുപ്പം എന്നിവയ്ക്കായി ഒരു പുതിയ മൂല്യം സജ്ജമാക്കുക. Windows 3.1-ൽ Value=REG_SZ മാത്രമേ അനുവദനീയമായിട്ടുള്ളൂ. റിട്ടേൺ - പിശക് കോഡ് അല്ലെങ്കിൽ പിശകുകൾ ഇല്ലെങ്കിൽ ERROR_SUCCESS.

INIFILES ഒബ്‌ജക്റ്റ് - INI ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു.

രജിസ്ട്രിയേക്കാൾ INI ഫയലുകൾ ഉപയോഗിക്കുന്നതാണ് ചിലപ്പോൾ നല്ലത്?

1. INI ഫയലുകൾ ഒരു സാധാരണ നോട്ട്പാഡിൽ കാണാനും എഡിറ്റ് ചെയ്യാനും കഴിയും.
2. പ്രോഗ്രാമിനൊപ്പം ഫോൾഡറിൽ INI ഫയൽ സംഭരിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഫോൾഡർ മറ്റൊരു കമ്പ്യൂട്ടറിലേക്ക് മാറ്റുമ്പോൾ, ക്രമീകരണങ്ങൾ സംരക്ഷിക്കപ്പെടും. (ഒരു ഫ്ലോപ്പി ഡിസ്കിൽ ചേരാത്ത ഒരു പ്രോഗ്രാം പോലും ഞാൻ ഇതുവരെ എഴുതിയിട്ടില്ല :)
3. രജിസ്ട്രിയിൽ പുതുതായി വരുന്ന ഒരാൾക്ക് ആശയക്കുഴപ്പത്തിലാകുകയോ (ദൈവം വിലക്കട്ടെ) എന്തെങ്കിലും തെറ്റ് മാറ്റുകയോ ചെയ്യാം.

അതിനാൽ, പ്രോഗ്രാം ക്രമീകരണങ്ങൾ സംഭരിക്കുന്നതിന് സാധാരണ വിൻഡോസ് INI ഫയലുകൾ ഉപയോഗിക്കുന്നത് സൗകര്യപ്രദമാണ്. IniFiles മൊഡ്യൂളിൻ്റെ TIniFiles ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ചാണ് INI ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത്. TIniFiles ഒബ്ജക്റ്റിൻ്റെ രീതികളുടെ ഒരു ഹ്രസ്വ വിവരണം ചുവടെ നൽകിയിരിക്കുന്നു.

വിഭാഗത്തിൻ്റെ ഐഡൻറ് എന്ന് പേരിട്ടിരിക്കുന്ന ഘടകം ഒരു ബൂളിയൻ മൂല്യത്തിലേക്ക് അസൈൻ ചെയ്യുക

വിഭാഗത്തിൻ്റെ ഐഡൻറ് എന്ന് പേരിട്ടിരിക്കുന്ന ഘടകം സ്ട്രിംഗ് ടൈപ്പിൻ്റെ മൂല്യത്തിലേക്ക് അസൈൻ ചെയ്യുക

പേര് പ്രകാരം നിലവിലുള്ള പാരാമീറ്റർ ആക്സസ് ചെയ്യുന്നു

ഉദാഹരണം: