Windows Entwicklung: Auslesen und schreiben von Dateierweiterungen aus der Registry mit dem .Net Framework

20. August 2009 23:48

Oft benötigt man Informationen zu einem bestimmten Datentyp. Dies kann beispielsweise die Applikation sein, mit welchem dieser Dateityp geöffnet werden soll oder der MIME-Typ wenn diese Datei für die Verwendung im Web genutzt werden soll. All dies lässt sich sehr einfach mit dem .Net Framework realisieren. Hierfür muss lediglich Microsoft.Win32 referenziert werden und schon hat man Zugriff auf die Registry.

Will man sich die Dateierweiterung von einem gewissen Pfad anzeigen so kann man dies einfach mit Path.GetExtension anzeigen lassen. Hierfür wird System.IO benötigt.

Für das folgende Beispiel werden also folgende Namespaces benötigt:

using System.IO;
using Microsoft.Win32;

Um den Registrywert der Datei zu erhalten soll ein Pfad in der Konsole eingegeben werden. Dieser wird dann mit der Dateierweiterung abgefragt.

static void Main(string[] args)
{
    string path = Console.ReadLine();

    string ext = Path.GetExtension(path).ToLower();

    ….

    Console.Read();
}

Ein einzelner Registry-Wert ist vom Typ “RegistryKey”. Dieser hat neben einen Namen verschiedene Werte. Werte haben zum Einem eine Bezeichnung (ValueName) und einen Wert (Value). Die Schlüsseln kann man über “GetValueNames” abfragen. Den Wert eines Schlüssels erhält man über “GetValue”. Hierbei wird auch noch der Name des Schlüssels benötigt, welcher aus der “GetValueNames” kommt.

private static void ReadKey(RegistryKey regKey)
{
    Console.WriteLine("###### Key: {0}", regKey.Name);

    foreach (string key in regKey.GetValueNames())
    {
        Console.WriteLine(string.Format("{0}\t{1}", key, regKey.GetValue(key)));
    }
}

Diese Funktion muss auch noch aus der Main-Methode aufgerufen werden. Hierzu erstellt man sich einen neuen RegistryKey, welcher aus dem “ClassesRoot”-Bereich der Registry kommt. Dies geschieht mit “OpenSubKey”, welche den Namen des Schlüssels benötigt.

Microsoft.Win32.RegistryKey regKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(ext);

ReadKey(regKey);

Abbildung: HKEY_CLASSES_ROOT Bereich in der Registry

Wenn man sich nun den Key “docx” anzeigen will (docx ist das Word-Format) so bemerkt man das es hier noch weitere Unterordner gibt. Auch auf diese kann man einfach zugreifen. Hierzu machen wir unsere “ReadKey” Methode einfach rekursiv.

Alle Unterschlüssel sind mit “GetSubKeyNames()” einfach abrufbar. Wenn man die Methode “ReadKey” mit “OpenSubKey” des Schlüssels aufruft kann man sich den jeweiligen Unterschlüssel aufrufen.

Die nun folgende foreach-Schleife kommt ans Ende der “ReadKey” Methode.

foreach (string sub in regKey.GetSubKeyNames())
{
    ReadKey(regKey.OpenSubKey(sub));
}

Nun kann man die Keys auch schon auslesen. Damit dies funktioniert muss man lediglich einen gültigen Dateinamen eingeben – dies kann beispielsweise “a.docx” sein.

Nun ist das Auslesen der Registry jedoch bei weitem nicht so interessant wie das Schreiben. Auch dies ist sehr einfach möglich. Hierzu braucht man zum Einem einen Schlüsselnamen, welcher mit dem Root-Key beginnt. Diesen erhält man indem man den Namen von den Built-In Klassen abfragt. Will man einen Dateinamen schreiben so kombiniert man diesen mit den vorher definierten Root-Key.

In weiterer Folge erstellt man sich den Schlüssel mit Registry.SetValue. Diese Methode ermöglicht es auch, vorhandene Schlüssel zu aktualisieren. Als Parameter sind hier der Schlüsselname, Der ValueName, der Wert (Value) und der Typ des Eintrages notwendig. Als Typ wird hier RegistryValueKind.String verwendet.

private static void WriteKey(string KeyName)
{
    string newKey = string.Format(@"{0}\{1}", Registry.ClassesRoot.Name, KeyName);
    Registry.SetValue(newKey, "Content Type", "application/myapp-v1.0", RegistryValueKind.String);
    Console.WriteLine("Key Generated");
}

Diese Methode wird nun in der Main Methode aufgerufen.

WriteKey(".mya");

Wenn man die Anwendung nun ausführt, so geschieht ein Wunder: ES STÜRZT AB! Der Grund hierfür ist das Administrator-Rechte notwendig sind. Am Besten einfach Visual Studio als Admin starten ;)

Noch besser ist es jedoch, wenn man überprüft ob der User überhaupt die Rechte fürs erstellen von Schlüsseln hat.

Hierfür wird zum einem eine Referenz auf

using System.Security.Principal;

benötigt.

Mit WindowsIdentity wird die aktuelle Identität abgefragt. WindowsPrincipal stellt nun die Methode zur Verfügung ob es sich hierbei um einem Administrator handelt. Dies geschieht mit “IsInRole”. Wenn dies nicht der Fall ist, so wird über die WindowsIdentity ausgegeben, das es der User nicht darf.

private static void WriteKey(string KeyName)
{
    WindowsIdentity identity = WindowsIdentity.GetCurrent();
    WindowsPrincipal principal = new WindowsPrincipal(identity);

    if (principal.IsInRole(WindowsBuiltInRole.Administrator))
    {
        string newKey = string.Format(@"{0}\{1}", Registry.ClassesRoot.Name, KeyName);
        Registry.SetValue(newKey, "Content Type", "application/myapp-v1.0", RegistryValueKind.String);
        Console.WriteLine("Key Generated");     
    }
    else
    {
        Console.WriteLine("{0} has insufficent rights to do this", identity.Name);
    }
}