Wie können 32-Bit-Anwendungen auf die 64-Bit-Windows-Registrierung zugreifen?

Zugriff auf die 64-Bit-Registrierung von einer 32-Bit-Anwendung aus

Die Herausforderung: 32-Bit-Anwendungen benötigen häufig Zugriff auf 64-Bit-Registrierungsschlüssel, um beispielsweise SQL Server-Instanzdetails abzurufen. Sie greifen jedoch normalerweise nur auf den Zweig Wow6432Node zu.

Die Lösung: Windows 7 und höher bieten integrierte Unterstützung für den Zugriff auf 64-Bit-Registrierungsschlüssel über .NET Framework 4.x oder höher. Der Schlüssel ist die Verwendung der RegistryView-Enumeration:

• RegistryView.Registry64: Greift auf die 64-Bit-Registrierung zu.
• RegistryView.Registry32: Greift auf die 32-Bit-Registrierung zu.

Codebeispiel (direkter 64-Bit-Zugriff):

Dieser Codeausschnitt demonstriert den direkten Zugriff auf die 64-Bit-Registrierung:

<code class="language-csharp">using Microsoft.Win32;

RegistryKey localKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
RegistryKey sqlServerKey = localKey.OpenSubKey(@"SOFTWARE\Microsoft\Microsoft SQL Server\Instance Names\SQL");
string sqlExpressKeyName = (string)sqlServerKey.GetValue("SQLEXPRESS"); </code>

Ein robusterer Ansatz (Hilfsfunktionen):

Für mehr Flexibilität fragen diese Hilfsfunktionen sowohl 32-Bit- als auch 64-Bit-Register ab und konsolidieren die Ergebnisse:

<code class="language-csharp">using Microsoft.Win32;
using System.Collections.Generic;
using System.Linq;

public static IEnumerable<string> GetAllRegValueNames(string RegPath, RegistryHive hive = RegistryHive.LocalMachine)
{
    var reg64 = GetRegValueNames(RegistryView.Registry64, RegPath, hive);
    var reg32 = GetRegValueNames(RegistryView.Registry32, RegPath, hive);
    var result = (reg64 != null && reg32 != null) ? reg64.Union(reg32) : (reg64 ?? reg32);
    return (result ?? new List<string>().AsEnumerable()).OrderBy(x => x);
}

public static object GetRegValue(string RegPath, string ValueName = "", RegistryHive hive = RegistryHive.LocalMachine)
{
    return GetRegValue(RegistryView.Registry64, RegPath, ValueName, hive) ?? GetRegValue(RegistryView.Registry32, RegPath, ValueName, hive);
}

private static IEnumerable<string> GetRegValueNames(RegistryView view, string regPath, RegistryHive hive)
{
    try
    {
        using (var key = RegistryKey.OpenBaseKey(hive, view).OpenSubKey(regPath))
        {
            return key?.GetValueNames();
        }
    }
    catch (Exception) { return null; }
}

private static object GetRegValue(RegistryView view, string regPath, string valueName, RegistryHive hive)
{
    try
    {
        using (var key = RegistryKey.OpenBaseKey(hive, view).OpenSubKey(regPath))
        {
            return key?.GetValue(valueName);
        }
    }
    catch (Exception) { return null; }
}</code>

Verwendung der Hilfsfunktionen:

In diesem Beispiel werden die Hilfsfunktionen verwendet:

<code class="language-csharp">var sqlRegPath = @"SOFTWARE\Microsoft\Microsoft SQL Server\Instance Names\SQL";
foreach (var valueName in GetAllRegValueNames(sqlRegPath))
{
    var value = GetRegValue(sqlRegPath, valueName);
    Console.WriteLine($"{valueName}={value}");
}</code>

Dieser verbesserte Ansatz behandelt potenzielle Ausnahmen und bietet eine robustere Lösung für den Zugriff auf Registrierungsinformationen, unabhängig von der Architektur der Anwendung oder des Registrierungsschlüssels.

Das obige ist der detaillierte Inhalt vonWie können 32-Bit-Anwendungen auf die 64-Bit-Windows-Registrierung zugreifen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!