DevTrain Startseite Visual Studio 1 Magazin  
  
  
SUCHEN:  
ARTIKEL ONLINE: 525   

Kategorien
.NET
Datenbanken
Web
XML

Allgemein
Camp
Foren
Events
Persönliche Einstellungen
Registrieren
Prämien Shop
Kontakt
Impressum
Über DevTrain

Autoren


   Autor: Klaas Wedemeyer Artikel Drucken
        
Rechte, Einstellungen und Lizenzen einfach und wieder verwendbar verwalten (Teil 1)

Die Entkopplung von den Komponenten einer Anwendung wird in letzter Zeit sehr groß geschrieben. Es reicht aber nicht aus, die Klasse hinter einem Interface zu verstecken. Es ist viel wichtiger, die Logik der Komponente vor dem Rest der Anwendung zu verbergen. Dieses möchte ich Euch im ersten Teil anhand einer Lizenzverwaltung zeigen. Im zweiten Teil  nehme ich die Einstellungen und eine Rechteverwaltung als Beispiel.
Eine Lizenzverwaltung kann folgende Ansprüche haben:
Standard Lizenzen, Kundenspezifische Lizenzen, Lizenzpakete, unterschiedliche Kombinationen der Lizenzen in Paketen,  Begrenzung der Laufzeit nach Tagen oder einem festen Datum.
Werden diese Möglichkeiten in die Anwendung weitergereicht, ist die Flexibilität und die Wartbarkeit schnell eingeschränkt. Bei genauerer Betrachtung benötigt die Anwendung nur die Information, ob eine Funktionalität frei geschaltet ist. Wie die Lizenzverwaltung diesen Wert ermittelt, ist ihre private Sache. In den meisten Fällen wird der Wert ein Boolean sein, aber auch andere Typen sind sinnvoll, z.B. ein Integer für die Anzahl der erlaubten Benutzer.
Meine Lösung:
Mit Attributen werden die Lizenzen (jeweils eine Funktionalität) bekannt gegeben. Zu jeder Lizenz gehören eine Id, ein Typ und ein Default. Die Anwendung kann die Lizenzverwaltung mit der Id nach dem dazugehörigen Wert fragen und entsprechend Menüs, Dialoge, usw. aktivieren. Meine Beispiellösung der Lizenzverwaltung liest aus einem Verzeichnis Lizenz-Pakete (XML Dateien). In diesen Dateien stehen die einzelnen Lizenzen (Id und Wert) und deren Gültigkeiten. Wird eine Id in den Dateien nicht gefunden, wird der Default zurückgegeben. Diese Dateien sind in meinem Beispiel (fürs Testen) nicht verschlüsselt, für eine Auslieferung wäre das aber sinnvoll.

Zuerst müssen die Lizenzen definiert werden. Hier bieten sich Attribute an der Assembly (in der Assemblyinfo) an. Hier zeigt sich leider eine Schwäche der Attribute: Als Werte können nur einfache Datentypen (Zahlen und Texte) übergeben werden, Konstruktoren (new Guid(?)) und Variablen (myLicences.LicenceNr1) können nicht angegeben. Ich habe mich deshalb entschlossen, die Lizenzen als Member in eine Klasse zu definieren. So kann man die Lizenz mit dem aussagekräftigen Variablennamen ansprechen.

[ConfigurationClass]
public class AppLicenses
{
 [License(typeof(bool), Name="Control sichtbar", Description="macht ein Control sichtbar", Default=true)]
 public static Guid ControlVisible = new Guid("{84EEC6D9-A0C1-47d7-963F-B8A6913EDB02}");
}

Die Verwendung ist genauso einfach. Die Lizenzverwaltung wird durch eine Classfactory erzeugt. Die Lizenzverwaltung fragt man mit der Id (aus der Membervariablen) nach dem Wert. Mit diesem lassen sich nun Menüpunkte aktivieren oder Funktionen steuern.

ILicenses Licenses = ClassFactory.GetObject<ILicenses>();
if (Licenses != null)
   txtTest.Visible =  Licenses.GetLicense<bool>(AppLicenses.ControlVisible);

Das ist alles, was die Anwendung über Lizenzen wissen muss. Der Rest wird in der Lizenzverwaltung implementiert. Im ersten Schritt sucht die Verwaltung alle Assemblies nach Lizenzdefinitionen durch und speichert sie in einem Dictionary.

foreach (Type aClass in assembly.GetTypes())
{
// erst die Klassen finden ...
if (aClass.GetCustomAttributes(typeof(ConfigurationClassAttribute), true).Length>0)
 {
  object aObject = Activator.CreateInstance(aClass);
  // ... dann die Member lesen ...
  foreach (FieldInfo member in aClass.GetFields())
  {
   // ... die die Attribute haben ...
   LicenseAttribute [] classAttributes = (LicenseAttribute []) member.GetCustomAttributes(typeof(LicenseAttribute), true);
   if (classAttributes!=null && classAttributes.Length == 1)
   {
// ... und den Wert speichern
    Guid Id = (Guid) member.GetValue(aObject);
    DefaultConfigurationList.Add(Id, classAttributes[0]);
   }
  }
 }
}

Im zweiten Schritt werden alle XML Dateien im Licence Verzeichnis gelesen.

// erst mal das Verzeichnis suchen
string AppPath =  Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
string LicensePath = Path.Combine(AppPath, "License");
DirectoryInfo dir = new DirectoryInfo(LicensePath);
// dann alle XML Dateien lesen
FileInfo[] XmlFiles = dir.GetFiles("*.xml");
foreach (FileInfo XmlFile in XmlFiles)
{
// Jede Datei lesen
 StreamReader reader = File.OpenText(XmlFile.FullName);
 XmlDocument Doc = new XmlDocument();
 Doc.Load(reader);
// jetzt durch die Knoten wandern ...
 foreach (XmlNode Licenses in Doc.GetElementsByTagName("licenses"))
 {
  foreach (XmlNode License in Doc.GetElementsByTagName("license"))
  {
// ... bis man die Lizenzen gefunden hat
   string sId = "";
   sId = License.Attributes["id"].Value;
   string Value = License.Attributes["value"].Value;
   Guid Id = new Guid(sId);
                  // Den Wert von Text nach Object wandeln und speichern
   ValueList.Add(Id, Value==?TRUE?) // hier nur Boolean
  }
 }
}
 
Bei einer Anfrage wird der Wert aus der XML Datei zurückgegeben. Wenn keiner gefunden wurde, wird der Default Wert zurückgegeben.

if (ValueList.ContainsKey(Id))
    return ValueList[Id];
return DefaultConfigurationList[Id].Default;

Der ganze Code und ein kleines Beispiel steht auf meiner Homepage www.KlaasWedemeyer.de


DevTrain Camp - Schneller zum .NET 3.5 Developer
 
Verwandte Artikel      Verlinkte Dokumente
    Keine verknüpften Dokumente
    Keine Links vorhanden

  Erfasst am: 25.10.2006
  Gültig bis: 23.01.2007
1 Ratings
Bewertung: 80,0%
schlecht    sehr gut  

 
© Copyright 2007 ppedv AG