Hi Leuts Ein absoluter Beginner hat ein kleines Problem. Ich möchte während der Laufzeit verschiedene Dateien überprüfen und diese Ergebnisse im Speicher festhalten. Dafür habe ich mir eine Klasse erstelle welche über entsprechende Properties die Daten annimmt und festhält. Mein Problem nun besteht nun darin, wie ich diese während der Laufzeit erzeugte Klasse benennen kann und wieder gezielt abrufen kann. Ich würde die Klasse am liebsten nach dem Dateinamen benennen und damit dann später auch wieder drauf zugreifen können. Ich konnte jedoch kein NOOB-freundliches Tutorial oder eine Erklärung dazu finden, zudem ich überhaupt nicht weis, ob es dafür sogar einen Fachbegriff gibt unter dem das zu finden wäre. Hat jemand einen Tip? MFG Marco
Du erzeugst keine Klassen dynamisch sondern du instanzierst diese. Schau dir mal das Konzept der HashMap an. In dieser werden jeweils Wertepaare gespeichert: ein eindeutiger Schlüssel (z.B. dein Dateiname) und dann der zu dem Schlüssel gehörige Wert (hier dein erzeugtes Objekt). Hier findest du ein kleines BSP, damit kannst du dann selbst weitergooglen http://www.microsoft.com/mspress/books/sampchap/6173.aspx#116
Stichwort: Serialisierung/Deserialisierung
1 | |
2 | // die folgende Klasse soll serialisierbar sein, also Attribut
|
3 | [Serializable] |
4 | public class Data { |
5 | int mXYZ = 0; |
6 | public int XYZ { |
7 | get { return mXYZ; } |
8 | set { mXYZ = value; } |
9 | }
|
10 | }
|
11 | |
12 | // soll's nicht als XML, sondern in einem Binärformat
|
13 | // geschrieben werden kann man XmlSerializer z.B.
|
14 | // durch BinaryFormatter ersetzen
|
15 | |
16 | // alles ohne Fehlerbehandlung...
|
17 | void writeXML(string fileName, object o) { |
18 | XmlSerializer xs = new XmlSerializer(o.GetType()); |
19 | FileStream fs = File.Create(fileName); |
20 | xs.Serialize(fs, o); |
21 | fs.Close(); |
22 | }
|
23 | |
24 | object readXML(string fileName, Type t) { |
25 | XmlSerializer xs = new XmlSerializer(t); |
26 | FileStream fs = File.OpenRead(fileName); |
27 | object o = xs.Deserialize(fs); |
28 | fs.Close(); |
29 | return o; |
30 | }
|
31 | |
32 | // benutzen kann man das z.B. so
|
33 | Data dat = new Data(); |
34 | Data dat2; |
35 | |
36 | dat.XYZ = 123; |
37 | |
38 | writeXML("test.xml", dat); |
39 | dat2 = readXML("test.xml", typeof(Data)) as Data; |
40 | |
41 | // generisch geht's auch etwas eleganter
|
42 | public class ObjSerDes { |
43 | public static void WriteXML<T>(string fileName, T o) { |
44 | XmlSerializer xs = new XmlSerializer(typeof(T)); |
45 | FileStream fs = File.Create(fileName); |
46 | xs.Serialize(fs, o); |
47 | fs.Close(); |
48 | }
|
49 | |
50 | public static T ReadXML<T>(string fileName) { |
51 | XmlSerializer xs = new XmlSerializer(typeof(T)); |
52 | FileStream fs = File.OpenRead(fileName); |
53 | T o = (T)xs.Deserialize(fs); |
54 | fs.Close(); |
55 | return o; |
56 | }
|
57 | }
|
58 | |
59 | ObjSerDes.WriteXML<Data>("test2.xml", dat); |
60 | dat2 = ObjSerDes.ReadXML<Data>("test2.xml"); |
Ich danke Euch für die Antworten. Ist erstmal wieder reichlich zum googeln. Aber wenigstens weis ich jetzt in welcher Richtung ich suchen muß. Die Hashtable scheint mir dabei etwas NOOB-freundlicher zu sein. Wenn ich da jetzt auch im "Value-Bereich" direkt auf die Classproperties zugreifen kann ist das genau das was ich suche. MFG Marco
Hi, Noch als Info am Rande: Verwende ab .Net 2.0 die Hashtable NICHT mehr. Verwende stattdessen die generische Klasse Dictionary<K,V>, ist typsicher, performanter & leichter anzuwenden(man spart sich die Casts). Die Hashtable existiert meines Wissend nur noch aus Kompatibilitätsgründen. greets
Vielen Dank Obwohl ich gestern den ganzen Tag mit der Hashtable verbracht habe (ja, als NOOB dauert das so lange) konnte ich diesen Hinweis nicht finden. Ein Problem besteht aber noch: Ich muß für jede meiner zu untersuchenden Datei ja eine eigene Instanz der selbstgeschriebenen Klasse instanzieren und diese dann dem Dictonary unter einem bestimmten Key (dem Dateinamen) ablegen. Ich habe probleme damit dieses, sowie auch den Zugriff auf die Properties der einzelnen Klassen zu erlangen, bzw. weis nicht wie das gehen sollte. Was mir einfiel wäre dies hier: Ich ermittele die Anzahl aller Dateien (hier als Beispiel 12 Stück) die zu analysieren sind und erzeuge ein Class-Array im Sinne von:
1 | myclass [] test = new myclass[12]; |
Dann muß ich wie ich gelesen habe die Klassen einzeln instanzieren durch eine Schleife:
1 | test[i] = new myclass(); |
Damit "hätte" ich nun 12 Klassen in einem Array. Mit einer weiteren Schleife würde ich nun die Dateinamen mit einer Klasse aus dem Array verbinden und das in dem Dictionary speichern.
1 | myStringDict.Add("DATEINAME als STRING", test[1]); |
Und dann stecke ich fest ... wie komme ich nun an die Properties meiner Klasse in test[1] ? Vermutlich ist das hier alles völliger Schwachsinn, aber anders wüßte ich nicht weiter. Damit ich es verstehe müßte es halt so simpel wie möglich sein, auch wenn es nicht die 100%ig beste Möglichkeit wäre. Geht das so überhaupt, bzw wie kann man es besser machen ? Ich müßte ja die einzelnen Eigenschaften meiner Klasse einzeln auslesen und abändern können, z.B: test[1].EIGENSCHAFT1 = "WERT" test[1].EIGENSCHAFT2 = "WERT" MFG Marco
1 | // Anlegen des Dictonaries
|
2 | Dictonary<string, myclass> dict = = new Dictionary<string, myclass>(); |
3 | |
4 | // neue Instanz bzw. Schlüssel/Wert-Paar hinzufügen
|
5 | dict.Add(fileName, new myclass()); |
6 | |
7 | // Zugriff
|
8 | dict[fileName].Eigenschaft1 = 1234; |
9 | |
10 | // wenn nacheinander auf alle Einträge im Dictonary zugegriffen
|
11 | // werden muss, geht's z.B. so
|
12 | foreach (KeyValuePair<string, Data> kvp in ds) { |
13 | kvp.Value.Eigenschaft1 = 5678; |
14 | }
|
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.