Lecture d'une clé de registre

Question

J'ai une application Web qui importe des DLL à partir du dossier bin.

const string dllpath = "Utility.dll"; 

    [DllImport(dllpath)] 

Maintenant ce que je veux faire est d'abord importer les DLL à partir d'un dossier pas dans le projet en cours, mais à un autre endroit.

Le chemin de ce dossier est stocké dans une clé de registre.

Comment est-ce que je devrais faire ceci?

Modifier:

Pourquoi ne puis-je travailler ceci ???

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"); ne fonctionne pas ici, mais travaille dans l'événement pageload ...

Mais si je ne cette importation DLL ne fonctionnera pas ... Comment puis-je résoudre ce problème?

Answer 1

La lecture du registre est assez simple. L'espace de noms Microsoft.Win32 a une classe statique Registry. Pour lire une clé à partir du nœud HKLM, le code est:

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

Si le nœud est HKCU, vous pouvez remplacer LocalMachine avec CurrentUser.

Une fois que vous avez l'objet RegistryKey, utilisez GetValue pour obtenir la valeur du registre. En continuant l'exemple précédent, obtenir la valeur de Registre pathName serait:

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

Et ne pas oublier de fermer l'objet RegistryKey lorsque vous avez terminé avec elle (ou mettre la déclaration pour obtenir la valeur dans un bloc Using).

Mises à jour

Je vois deux ou trois choses. Tout d'abord, je changerais nom_du_canvas à une propriété statique définie comme:

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

Les deux questions sont les suivantes:

1. La référence RegistryKey gardera le registre ouvert. L'utiliser comme variable statique dans la classe provoquera des problèmes sur l'ordinateur.
2. Les chemins d'accès du registre utilisent des barres obliques et non des barres obliques inverses.

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

Vous pouvez utiliser ceci:

/// <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; 
     } 
    } 
} 

Pour de plus amples informations, visitez le this web site.

Answer 4

Aucune de ces réponses n'a fonctionné pour moi.C'est ce que j'ai utilisé:

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

Toutes ces réponses peuvent entraîner des problèmes sur un système d'exploitation 64 bits - ce qui est habituel de nos jours.

Dans ma situation, je compile à la cible 'Any CPU' et le logiciel fonctionne correctement lorsque je l'installe sur un système d'exploitation 64 bits. Mais mes tests unitaires rencontrent des problèmes - ils sont évidemment exécutés en mode 32 bits.

Dans ce cas, le HKEY_LOCAL_MACHINE\SOFTWARE\MyCompany\MySoftware n'est pas recherché mais HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\MyCompany\MySoftware mais il n'y a aucune entrée!

Dans cette situation, nous devons préciser le point de départ de notre recherche en utilisant

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

Au total, nous pouvons utiliser.

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"); 
     } 
    } 
}