C# Verwaltung von PC's

[Thaxll'ssillyia]

Hallo Community!

Ich bin noch C#-Anfänger und hätte gern ein paar Fragen zu einem Projekt, das ich erarbeiten möchte.
Es geht um das Verwalten von Computern.

Diese Computer würde ich in einer Dictionary vom Typ <string (Besitzer), Computer (der Rechner)> anlegen, wobei "Computer" meine Klasse mit den Eigenschaften eines Computers ist.
Diese Klasse ist in Unterklassen gegliedert (Hardware, Software, Lizenzen).

Hier mein Code:

    public partial class Form1 : Form                       // ......Formular
    {
        Dictionary<string, Computer> Rechner;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Rechner = new Dictionary<string, Computer>();
            Computer C = new Computer();
            C.Hardware.Rechnernummer = "die 1";
            Rechner.Add("Ich", C);
        }
    }

    class Computer                                                   //........die Klassen
    {
        Hardware hardware;                      // Daten des Rechners
        Dictionary<string, Software> software;  // Liste der installierten Software
        Dictionary<string, Lizenzen> lizenzen;  // Liste der verwendeten Lizenzen

        public Hardware Hardware
        {
            get { return hardware; }
            set { hardware = value; }
        }
        public Dictionary<string, Software> Software
        {
            get { return software; }
            set { software = value; }
        }
        public Dictionary<string, Lizenzen> Lizenzen
        {
            get { return lizenzen; }
            set { lizenzen = value; }
        }

        /// <summary>
        /// Legt einen neuen Computer an.
        /// </summary>
        public Computer()
        {
            hardware = new Hardware();
            software = new Dictionary<string,Software>();
            lizenzen = new Dictionary<string, Lizenzen>();        }
    }

    class Hardware
    {
        string rechnernummer;

        public string Rechnernummer
        {
            get { return rechnernummer; }
            set { rechnernummer = value; }
        }
        // andere Daten

    }
    class Software
    {
        string name;
    }
    class Lizenzen
    {
        string typ;         // Einzelplatz oder Nutzerlizenz
        string zuSoftware;  // Name der Software, wozu die Lizenz gehört
        int lizenznummer;   // oder vom Typ "string"
    }
    class Lizenztyp
    {

    }

Nun erst mal meine Frage: Ist diese Art der Verwaltung gut? Was kann man verbessern?

Ein Problem, auf das ich gestoße bin, ist, dass ich unterschiedliche Lizenztypen habe. Jeder Typ besitzt andere Variablen. Gibt es eine Möglichkeit, beim Anlegen einer Lizenz für einen Rechner den Typ zu bestimmen und dann nur die Variabeln dieses Typs definieren/einlesen zu können?
Ich meine jetzt nicht, dass ich das mit einer Abfrage im Programm mache, sondern ich diese Aufsplittung bereits in meinen Klassen vornehmen kann.

So in etwa:

C.Lizenzen.Typ = new Einzellizenz();
C.Lizenzen.(Zugriff auf Eigenschaft der Einzellizenz)

Vielen Dank für Hilfe!

Gruß Thax

 

[Grantig]

Wieso denn so viele Dictionaries?
Du könntest die Besitzer Property auch einfach in die Computer Klasse packen und dann statt Dictionary<string,Computer> einfach ne List<Computer> verwenden.

Auch Dictionary<string, Software> und Dictionary<string, Lizenzen> sehen irgendwie überflüssig aus. Da wären wohl auch einfache Listen angebrachter imo.



Wegen den Lizenzen:
Also erstmal wär ne Klasse "Lizenz" sinnvoll die als Basisklasse dient. Alle anderen Lizenztypen kannst du dann von Lizenz ableiten also quasi so:

class Lizenz
{
       public string SoftwareName {get;set;}
       public string LizenzNummer {get;set;}
}

class Einzellizenz : Lizenz
{
       //zusätzliche Properties einfügen
}

Die Klasse Lizenztyp wird damit hinfällig. Solltest du trotzdem ne Lizenztyp Eigenschaft haben wollen, (obwohl der Typ dann ja schon aus dem Klassentyp selbst hervorgeht) dann wäre ein Enum die bessere Wahl.
Dann kannst du eine List<Lizenz> anlegen und die von Lizenz abgeleiteten Klassen drin lagern:

List<Lizenz> lizenzen = new List<Lizenz>();

lizenzen.Add(new Einzellizenz());

Wenn du dann einfach nur alle Properties einer Lizenz in ner Textbox anzeigen willst, dann geht das per Reflection.

 

[Thaxll'ssillyia]

Wieso denn so viele Dictionaries?
Du könntest die Besitzer Property auch einfach in die Computer Klasse packen und dann statt Dictionary<string,Computer> einfach ne List<Computer> verwenden.

Ich komme mit Dictionarys sehr gut zurecht, bzw., haben dessen Einträge immer eine Eigenschaft gemeinsam, zb. den Namen, den ich dan als Key verwenden kann. Halt Angewöhnung, manche kommen damit nicht gut klar, bloß ne Formsache hoff ich mal

Wegen den Lizenzen:
Also erstmal wär ne Klasse "Lizenz" sinnvoll die als Basisklasse dient. Alle anderen Lizenztypen kannst du dann von Lizenz ableiten also quasi so:

Ah, das mit der Ableitung hatt ich nicht gewusst, danke dir!

Und wie kann ich dann ermitteln, was für eine Lizenz es ist, ohne eine Eigenschaft einzufügen (zB: string Lizenztyp) ?

Danke für die Hilfe.

 

[Grantig]

Naja, wenn du die Auflistungen nicht durchsuchen musst, dann sind Dictionaries eigentlich überflüssig und erzeugen nur unnötig overhead (wenn auch nur in geringem Ausmaß).

[...] haben dessen Einträge immer eine Eigenschaft gemeinsam

Die Einträge haben alle Eigenschaften gemeinsam, da sie alle vom selben Typ sind.

Und wie kann ich dann ermitteln, was für eine Lizenz es ist, ohne eine Eigenschaft einzufügen

Beispielsweise so:

Lizenz lizenz = new Einzellizenz();
bool isEinzellizenz = lizenz is Einzellizenz;

oder so:

Lizenz lizenz = new Einzellizenz();
Type t = lizenz.GetType();

Ist zwar nicht beides genau das gleiche, läuft aber aufs gleiche hinaus

 

[Thaxll'ssillyia]

Okay, ich hab jetzt aber ein weiteres Problem:

Ich kann zwar mit

Lizenz T = new Lizentyp.Volumenlizenz();
T.AnzahlderLizenzen

Auf die Spezielle Eigenschaft einer Volumenlizenz zugreifen, wenn ich aber mit

Lizenzen.Add("Hallo", new Lizentyp.Volumenlizenz());

eine Lizenz zur Lizenzliste hinzufüge, kann ich nicht mit

Lizenzen["Hallo"].AnzahlderLizenzen

auf die Eigenschaft des Elementes zugreifen, da nur die Eigenschaften der Basislizenz sichtbar sind.
Habt ihr eine Lösung?

 

[roker002]

wie kommst du auf

Lizenz T = new Lizentyp.Volumenlizenz();

mit Punkt Operator? soll Volumenlizenz() eine statische Methode sein oder soll es eine normaler Methode sein? Wenn es statisch ist kannst du zum ersten kein NEW operator anwenden und zum zweiten... ach egal...

Also wenn Lizenztyp eine Namespace ist geht das, wenn die Klasse den Namen Volumlizenz hat. Aber ich sehe dass dein klasse eigentlich vom Typ Lizenz sein sollte. Oder ist Lizenz dein Interface Klasse?

Bin total verwirrt!

 

[Grantig]

[...]kann ich nicht mit

Lizenzen["Hallo"].AnzahlderLizenzen

auf die Eigenschaft des Elementes zugreifen, da nur die Eigenschaften der Basislizenz sichtbar sind.

Das ist schon klar, deine Liste enthält eben nur Objekte vom Typ "Lizenz".
Du musst erst in den entsprechenden Typ casten, beispielsweise so:

int anzahl = ((Volumenlizenz)Lizenzenz["Hallo"]).AnzahderLizenzen;

--------------------------

Oder ist Lizenz dein Interface Klasse?

Es ist seine Basisklasse, von der er ableitet, wie ich vorgeschlagen habe.