Przeczytaj klucz rejestru

Question

Mam aplikację internetową, która importuje biblioteki DLL z folderu bin.

const string dllpath = "Utility.dll"; 

    [DllImport(dllpath)] 

Teraz chcę najpierw zaimportować biblioteki DLL z folderu nie w bieżącym projekcie, ale w innej lokalizacji.

Ścieżka tego folderu jest przechowywana w kluczu rejestru.

Jak powinienem to zrobić?

Edit:

Dlaczego nie mogę pracować na to uwagę ???

public partial class Reports1 : System.Web.UI.Page 
{ 

    RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(@"Software\xyz"); 
    string pathName = (string)registryKey.GetValue("BinDir"); 

    const string dllpath = pathName; 
    [DllImport(dllpath)] 
    public static extern bool GetErrorString(uint lookupCode, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder buf, uint bufSize); 

    protected void Page_Load(object sender, EventArgs e) 
    { 

string pathName = (string)registryKey.GetValue("BinDir"); nie pracuje tutaj, ale działa w przypadku pageload ...

Ale jeśli ja to import DLL nie będzie działać ... Jak mogę rozwiązać ten problem?

Answer 1

Czytanie rejestru jest dość proste. Przestrzeń nazw Microsoft.Win32 ma klasę statyczną Registry. Aby odczytać klucz z węzła HKLM, kod jest:

RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("Software\\NodeName") 

Jeśli węzeł jest HKCU można zastąpić LocalMachine z CurrentUser.

Po uzyskaniu obiektu RegistryKey użyj wartości GetValue, aby uzyskać wartość z rejestru. Kontynuując Stosując powyższy przykład, uzyskanie wartości rejestru PathName byłoby:

string pathName = (string) registryKey.GetValue("pathName"); 

I nie zapomnij, aby zamknąć obiekt RegistryKey kiedy jesteś z nim zrobić (lub umieścić oświadczenie, aby uzyskać wartość w bloku Using).

Aktualizacje

widzę parę rzeczy. Po pierwsze, chciałbym zmienić ścieżkę dostępu do właściwość statyczna zdefiniowana jako:

Private static string PathName 
{ 
    get 
    { 
     using (RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(@"Software\Copium")) 
     { 
       return (string)registryKey.GetValue("BinDir"); 
     } 
    } 
} 

Obie kwestie były:

1. Odniesienie RegistryKey zachowa rejestr otwarty. Użycie go jako zmiennej statycznej w klasie spowoduje problemy na komputerze.
2. Ścieżki do ścieżek w rejestrze wykorzystują ukośniki, a nie ukośniki.

Answer 2

try 
{ 
    RegistryKey regKey = Registry.LocalMachine; 
    regKey = regKey.OpenSubKey(@"Software\Application\"); 

    if (regKey != null) 
    { 
     return regKey.GetValue("KEY NAME").ToString(); 
    } 
    else 
    { 
     return null; 
    } 
} 
catch (Exception ex) 
{ 
    return null; 
} 

Answer 3

Można to wykorzystać:

/// <summary> 
/// To read a registry key. 
/// input: KeyName (string) 
/// output: value (string) 
/// </summary> 
public string Read(string KeyName) 
{ 
    // Opening the registry key 
    RegistryKey rk = baseRegistryKey ; 
    // Open a subKey as read-only 
    RegistryKey sk1 = rk.OpenSubKey(subKey); 
    // If the RegistrySubKey doesn't exist -> (null) 
    if (sk1 == null) 
    { 
     return null; 
    } 
    else 
    { 
     try 
     { 
      // If the RegistryKey exists I get its value 
      // or null is returned. 
      return (string)sk1.GetValue(KeyName.ToUpper()); 
     } 
     catch (Exception e) 
     { 
      // AAAAAAAAAAARGH, an error! 
      ShowErrorMessage(e, "Reading registry " + KeyName.ToUpper()); 
      return null; 
     } 
    } 
} 

Więcej informacji na stronie this web site.

Answer 4

Żadna z tych odpowiedzi nie sprawdziła się u mnie.To właśnie użyłem:

static void Main() 
{ 
    const string dotNetFourPath = "Software\\Microsoft";//note backslash 
    using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(dotNetFourPath)) 
    { 
     Console.WriteLine(registryKey.SubKeyCount);//registry is not null 
     foreach (var VARIABLE in registryKey.GetSubKeyNames()) 
     { 
      Console.WriteLine(VARIABLE);//here I can see I have many keys 
      //no need to switch to x64 as suggested on other posts 
     } 
    } 
} 

Answer 5

Wszystkie te odpowiedzi mogą prowadzić do problemów z 64-bitowym systemem operacyjnym - co jest obecnie powszechne.

W mojej sytuacji kompilowałem do celu "Dowolny procesor", a oprogramowanie działa poprawnie, gdy instaluję na 64-bitowym systemie operacyjnym. Ale moje testy jednostkowe napotykają na problemy - oczywiście są wykonywane w trybie 32-bitowym.

W tym przypadku nie szuka się HKEY_LOCAL_MACHINE\SOFTWARE\MyCompany\MySoftware, ale HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\MyCompany\MySoftware, ale nie ma wpisów!

W tej sytuacji musimy określić punkt początkowy naszych poszukiwań przy użyciu

RegistryKey hklm = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64) 

W sumie możemy wykorzystać.

string configurationDirectory = string.Empty; 

using (RegistryKey hklm = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64)) 
{ 
    using (RegistryKey registryKey = hklm.OpenSubKey(@"SOFTWARE\MyCompany\MySoftware")) 
    { 
     if (registryKey != null) 
     { 
      configurationDirectory = (string)registryKey.GetValue("ConfigurationDirectory"); 
     } 
    } 
}