verschachtelte Klassen serialisieren und Deserialisieren

[kiar]

hallo gemeinde

Bräuchte mal einen gewaltigenSchlag auf den Hinterkopf.

wie Oben schon gesagt , möchte ich verschachtelte Klassen serialisieren. ich habe eine Klasse:

Delphi-Quellcode:

type
TVersicherter = Class
  fName: String;
  fVorname: String;
  fNummer : Integer;
  fMitversicherte : Boolean;
... usw
end;

jetzt will ich erreichen , wenn Mitversicherte = true ist, meine Datei so aussieht:

XML-Code:

< TVersicherte
<Name> Mustermann </Name>
<Vornmae> Manfred </Vorname>
<Mitversicherte> true </Mitversicherte>
<1.Mitversicherter
<Name> Mustermann </NAme>
<Vorname> Hanna </Vorname>
</1.Miteversicherter>
</TVersicherter>

Für Hilfe in irgendeiner Weise wäre ich dankbar. Es kann auch in C# sein.

Danke Raik

[Dax]

Ging das nicht nochmal mit Listenproperties? Ich meine so wäre es gewesen.. Oder Array-Properties...

[Robert_G]

"Fragestellen for D... äh Anfänger"

• Was geht genau nicht?
• Mit welchem Code hast du es versucht?
• Was können wir ausschließen weil du es schon versucht hast?
• Wie sehen deine Properties aus?

Außerdem, damit man mehr Lust zum Antworten bekommt:

• Ts haben in .Net nix zu suchen, da würden sich mir, als Benutzer deiner Klasse in einer anderen .Net Sprache, die Fußnägel aufrolllen. Möglicherweise bis zum Knie...
• Gibst du keinen access modifier für die Felder an, sind sie public! (published gibt es ja in .Net nicht)
  Public fXXX sehen sicher witzig aus (auch im XML output) aber wären doch irgendwie Unsinn, meinst du nicht?

[kiar]

hallo Robert,

mein Gott, das ist 14 Tage her und da du sonst nicht antwortest, hatte ich ebend fast eine Herzattacke .

die Frage hat sich erledigt. Da ich kein Netzzugang die ganze Woche habe, habe ich es einfacher realisiert. habe eine Klasse Einstellungen( jupp das T habe ich weggenommen ) dort mache ich alles zusammen. Im Endeffekt sieht es dann so aus

XML-Code:

<Einstellungen>
< Versicherte>
<Name> Mustermann </Name>
<Vornmae> Manfred </Vorname>
<Mitversicherte> true </Mitversicherte>
</Versicherter>
<1.Mitversicherter>
<Name> Mustermann </NAme>
<Vorname> Hanna </Vorname>
</1.Miteversicherter>
</Einstellungen>

Raik

[Robert_G]

Wie du wieder gekonnt alle Punkte ignoriert hast...
Wenn nun Karl-Heinz hier reinschaut und auf eine Lösung hofft, gibt's nur unser hohles Geblubber...

Deine Datei ist kein XML! 1.Mitversicherte dürfte kein korrekter Tag sein.
Du willst wohl sowas haben:

XML-Code:

<?xml version="1.0" encoding="utf-8" ?>
<Einstellungen xmlns="http://Raik.net/Einstellungen.xsd">
  <Versicherte>
    <Versicherter Name="Mustermann"
                  Vorname="Manfred">
      <Mitversicherte>
        <Mitversicherter Name="Mustermann"
                         Vorname="Hanna"/>
      </Mitversicherte>
    </Versicherter>
  </Versicherte>
</Einstellungen>

Das sind effektiv 3 Klassen: Die Einstellungen, ein Versicherter und ein Hauptversicherter, der von Versicherter erbt um dann noch eine Eigenschaft Mitversicherte einzuführen.

Ich hatte gerade Lust und habe das mal zusammengefriemelt.
Du wirst es dir noch zu D.Net untersetzen müssen, aber das sollte easy möglich sein. (zumal dir ja auch C# nicht unbekannt ist )

Der Versicherte:

Delphi-Quellcode:

uses
   System.Xml.*;

type
   [SerializableAttribute]
   [XmlTypeAttribute(&Namespace := 'http://Raik.net/Einstellungen.xsd')]
   Versicherter = public class
   public
      [XmlAttributeAttribute]
      property Name : String;
      [XmlAttributeAttribute]
      property Vorname : String;
      constructor; empty; //parameterloser constructor für den serializer
      constructor(name, vorname : String);
   end;
   
implementation

constructor Versicherter(name, vorname : String);   
begin
   self.Name := name;
   self.Vorname := vorname;
end;

Der Hauptversicherte:

Delphi-Quellcode:

uses
   System.Xml.*,
   System.Collections.Generic;

type
   [SerializableAttribute]
   [XmlTypeAttribute(&Namespace := 'http://Raik.net/Einstellungen.xsd')]
   HauptVersicherter = public class(Versicherter)
   private
      fMitVersicherte : List<Versicherter> := new List<Versicherter>();
   public
      [XmlArrayAttribute('Mitversicherte')]
      [XmlArrayItemAttribute('Mitversicherter', IsNullable := false)]
      property MitVersicherte : List<Versicherter> read fMitVersicherte;
   end;

Und die Einstellungen:

Delphi-Quellcode:

uses
   System.Xml.*,
   System.Collections.Generic;

type
   [XmlRootAttribute(&Namespace := 'http://Raik.net/Einstellungen.xsd',
                     IsNullable := false)]
   Einstellungen = public class
   private
      fVersicherte: List<HauptVersicherter> := new List<HauptVersicherter>();
   protected
   public
      [XmlArrayAttribute('Versicherte')]
      [XmlArrayItemAttribute('Versicherter', 
                             typeof(HauptVersicherter),
                             IsNullable := false)]
      property Versicherte : List<HauptVersicherter> read fVersicherte;
   end;

Alles "dumme" Daten container mit ein paar Attributen, die das XML Mapping steuern.

Hier noch Bleistift code zum Laden und Speichern:

Delphi-Quellcode:

class method ConsoleApp.Load(fileName : String);
begin
   var serializer := new XmlSerializer(typeof(Einstellungen));
   
   using reader := new XmlTextReader(fileName) do
      var einstellungen := serializer.Deserialize(reader) as Einstellungen;
end;

class method ConsoleApp.Save(fileName : String);
begin
   var serializer := new XmlSerializer(typeof(Einstellungen));

   var einstellungen := new Einstellungen();
      
   with hauptVersicherter := new HauptVersicherter('Mustermann', 'Manfred') do
   begin
      hauptVersicherter.MitVersicherte.Add(new Versicherter('Mustermann', 'Hanna'));
      einstellungen.Versicherte.Add(hauptVersicherter);
   end;

   using writer := new XmlTextWriter(fileName, Encoding.UTF8) do
      serializer.Serialize(writer, einstellungen);
end;

Ist eigentlich ziemlich easy und spätestens beim Übersetzen sollte der Groschen fallen.

[kiar]

hallo Robert,

erstmal Danke, werde es mir zu Gemüte führen. Meine XML Datei sieht schon richtig aus, habe auch die Klasse Einstellungen anderst gestaltet.

habe ebend keine Zeit muss Hausaufgaben machen .

melde mich heute abend nochmal.

Eine kurze Frage: Was macht der Parameterlose Constructor? ..... nicht gleich wieder 'dummes Schwein' sagen, bin nur schnell über dein Code gerasselt.
raik

[Robert_G]

Zitat von kiar:

Eine kurze Frage: Was macht der Parameterlose Constructor?

Nix.
Der Serializer sucht sich einen parameterlosen Constructor um eine Instanz anzulegen. Findet er keinen knallt's.
Hier muss der Constructor nix machen.

Zitat:

..... nicht gleich wieder 'dummes Schwein' sagen,

Oink, oink Das habe ich mir doch immer verkniffen...

[kiar]

Zitat von Robert_G:

Der Serializer sucht sich einen parameterlosen Constructor um eine Instanz anzulegen. Findet er keinen knallt's.
Hier muss der Constructor nix machen.

jetzt bin ich aus meinem Traum raus, hatte nämlich einen Constructor der ähnlich deinem aussah und jedesmal meckert delphi und wollte einen parameterlosen Constructor haben. dann hat es ebend einen gekriegt, obwohl ich damit nicht glücklich war.

raik

[Robert_G]

Zitat von kiar:

jetzt bin ich aus meinem Traum raus, hatte nämlich einen Constructor der ähnlich deinem aussah und jedesmal meckert delphi und wollte einen parameterlosen Constructor haben. dann hat es ebend einen gekriegt, obwohl ich damit nicht glücklich war.

*Taschentuch sucht*

Was ist denn jetzt so schlimm? Du kannst du doch vorerst einen parameterlosen constructor neben dem nehmen, den du schon hast.

Nachdem D2007 rausgekommen ist ( ) kannst du den dann in der Sichtbarkeit auf assembly Level reduzieren und das neue
InternalsVisibleToAttribute verwenden um ihn für den Serializer sichtbar zu machen. In 1.1 gab's auch das, aber das ist ein ziemlicher PITA.

[kiar]

Moin Robert,

habe versucht das ganze zu übersetzen. Bin leider an der List <''> gescheitert.

wäre nicht schlecht, wenn du der gescheiterten Existenz noch mal auf die Sprünge helfen könntest.


raik