Array einer Struktur speichern und wieder laden.

[Bernd W. (bw87)]

Hallo zusammen,

ich habe eine Frage zum FileStream. Ich möchte eine erstellte Struktur 
auf der Festplatte speichern um sie bei erneutem Aufruf des Programms 
wieder laden zu können.
Zur Struktur

public struct konfiguration

{
            public int id;
            public string name;
            public string description;
}
//Die Struktur hat noch weiter Variablen, aber alles int oder string von 
//daher abgekürzt

konfiguration[] neu = new konfiguration[200];
konfiguration[] zwischen = new konfiguration[200];

Nach jedem Eingeben der Werte in Textfeldern wird diese in einem 
FileStream gespeichert.(Datei ist angehangen)

FileStream savedata = new 
FileStream(@"C:\ProgramData\Konfigurationstabelle E-Paper.txt", 
FileMode.Append);
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(savedata, neu[i]);
            savedata.Close();

Um die Datei zu laden habe ich folgendes gemacht:

FileStream readdata = new 
FileStream(@"C:\ProgramData\Konfigurationstabelle E-Paper.txt", 
FileMode.Open);
            BinaryFormatter formatter = new BinaryFormatter();
            konfiguration zwischen = (konfiguration) 
formatter.Deserialize(readdata);

Meine Frage:
Ich verstehe nicht ganz, was in die Variable "zwischen" gespeichert 
wurde. Ist das der gesamte Inhalt der .txt Datei? Mit dem Befehl
Textfeld1.Text = zwischen.name;

wird mir der Name des ersten Eintrags angezeigt. "neu[0].name" 
sozusagen. Wie kann ich mir neu[1].name usw. anzeigen lassen?

[abcabc (Gast)]

zwischen ist genau ein struct vom Typ konfiguration.
Was du machst ist: du serialisierst alles nach einander und liest nur 
wieder das erste Element ein.

Was du willst: Mach dir ein struct mit dem Array von konfiguration als 
Typ und serialisiere dieses struct.

Und btw. schreib die Typen Namen groß...

[Bernd W. (bw87)]

Wenn ich dich richtig verstehe erstelle ich folgende Struktur:

 [Serializable]
        public struct Speichern
        {
           public Konfiguration[] abspeichern;
        }
Speichern[] save = new Speichern[200];

Werte zuweisen und abspeichen geht dann folgender Maßen?(Habe den 
Fildemode auf "Create" geändert. Datei ist wieder angehangen)

save[i].abspeichern= neu;

            FileStream savedata = new 
FileStream(@"C:\ProgramData\Konfigurationstabelle E-Paper.txt", 
FileMode.Create);
            BinaryFormatter formatter = new BinaryFormatter();

            formatter.Serialize(savedata, save);
            savedata.Close();

Wird dadurch ein Array mit dem Aufbau save[] = {neu[0];neu[1];usw.} 
abgespeichert?

Wenn ich die Datei dann wieder laden möchte bekomme ich die 
Fehlermeldung "Die angegebene Umwandlung ist ungültig"

FileStream readdata = new 
FileStream(@"C:\ProgramData\Konfigurationstabelle E-Paper.txt", 
FileMode.Open);
            BinaryFormatter formatter = new BinaryFormatter();
             Speichern zwischen = (Speichern) 
formatter.Deserialize(readdata);


Ich habe bisher eher in C programmiert und bin in C# noch recht am 
anfang(ist dir wahrscheinlich schon aufgefallen)

Wenn ich wie oben beschrieben falsch vorgehe wäre ein Code Beispiel 
super. Mit google und den Microsoft Hilfen verstehe ich das recht 
schwer. Da läuft das mehr nach dem Prinzig "Try and Error".

[test (Gast)]

Nut mal nebenbei, das ist keine Textdatei. Die Dateiendung "txt" ist 
hier unschön. Du könntest generisch "bin" nutzen oder auch "cfg" oder 
ähnlich.
Musste ich mal loswerden ;-)


Zum eigentlichen Thema sage ich lieber nix ;-) Serialisieren finde ich 
sehr unschön. Besser ist es (IMHO) Konfiguration im ini oder xml Format 
zu speichern (oder auch in der Registry). Und dann bitte auch an der 
richtigen Stelle.

Ist für ein privates Hobbyprojekt zwar nicht wichtig, aber es schadet 
nich es gleich richtig zu machen.

[Frank E. (Firma: Q3) (qualidat)]

Ich würde da besser eine HashMap verwenden, die kann als Value auch 
Objekte aufnehmen. Statt der Struct machst du ein Objekt mit all den 
Attributen in den versch. Typen. Der Vorteil ist auch, dass man sich bei 
einer HashMap nicht vorher bezüglich der Größe festlegen muss. Speichern 
kann man die HashMap so:

FileOutputStream outStream = new FileOutputStream(fname);
ObjectOutputStream outObj = new ObjectOutputStream(outStream);    
outObj.writeObject(outMap);                      
outObj.flush();                            
outObj.close();                            
outStream.close();

Einlesen geht so:

FileInputStream inpStream = new FileInputStream(fname);
ObjectInputStream inpObj = new ObjectInputStream(inpStream);    
inpMap=(HashMap<String,Object>)inpObj.readObject();        
inpObj.close();                            
inpStream.close();

[Frank E. (Firma: Q3) (qualidat)]

test schrieb:

> Zum eigentlichen Thema sage ich lieber nix ;-) Serialisieren finde ich
> sehr unschön. Besser ist es (IMHO) Konfiguration im ini oder xml Format
> zu speichern (oder auch in der Registry). Und dann bitte auch an der
> richtigen Stelle.

Java-Programme sollten plattform-Unabängig sein. "Registry" passt da 
nicht ...

[Markus L. (rollerblade)]

Wieso Java? Er macht .NET.