verschachtelte Klassen serialisieren und Deserialisieren

[kiar]

hallo gemeinde :mrgreen:

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? :gruebel: 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... :shock:
• 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 :shock: .

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 :mrgreen: ) 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... :mrgreen:
Wenn nun Karl-Heinz hier reinschaut und auf eine Lösung hofft, gibt's nur unser hohles Geblubber... :mrgreen:

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 :mrgreen:.

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:

Zitat von kiar

Eine kurze Frage: Was macht der Parameterlose Constructor?

Nix. :mrgreen:
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 :mrgreen: Das habe ich mir doch immer verkniffen... :angle2:

[kiar]

Zitat:

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:

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* :cry:

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 ( :mrgreen: ) 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. :mrgreen:


raik

[Robert_G]

Zitat:

Zitat von 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. :mrgreen:

Moin Raik,
gerne doch. ;)
Eine List<Miep> ist eine arraybasierte Collection mit Elementen vom Typ Miep, das ganze fällt unter das Schlagwort "generics".
Um das unter .Net 1.1 zu bekommen gibt es zum Beispiel den collection wizard aus #d. Da du D.Net benutzt und bisher kein .Net Compiler circuläre Referenzen von Assemblies unterstützt sehe ich für dich nur drei Möglichkeiten.

• Du schreibst diese Klassen in c# und kannst den typed collection wizard benutzen.
  Die Assembly benutzt du dann von D.Net.
• Du deklarierst leere Pseudo klassen in C#, (Hauptversicherter und Versicherter).
  Auf die wendest du den collection wiz an und kompostiert das ganze. Nun kannst du die Assembly in den Reflector werfen und D.Net Code herauskopieren.
• Du tippst alles von Hand

Da du einen gewissen masochistischen Hang offenbarst, empfehle ich dir #3. :mrgreen:

btw: Nein, Du kannst keine ArrayList nehmen, da die beim Serialisieren *ziemlich* zickig ist. ;)

Außerdem:

Delphi-Quellcode:

uses System.Xml.*;
...
begin
   var serializer := new XmlSerializer(typeof(Einstellungen));
   
   using reader := new XmlTextReader(fileName) do
      var einstellungen := serializer.Deserialize(reader) as Einstellungen;
end;

entspricht in Delphi.Net:

Delphi-Quellcode:

uses
  System.Xml,
  System.Xml.Serialization;
...
var
  einstellungen : DeinNamespcae.Einstellungen; //siehe [1]
  reader        : XmlTextReader;
  serializer    : XmlSerializer;
begin
  serializer := XmlSerializer.Create(typeof(DeinNamespcae.Einstellungen)); //siehe [1]
  reader := XmlTextReader.Create(fileName);
  try
    einstellungen := serializer.Deserialize(reader) as Einstellungen;
  finally
    reader.Dispose();
  end;
end;

[1] Ich hoffe es reicht den namespace vor den Typen zu packen um einen Name clash zu vermeiden.
Falls nicht musst du dir wohl irgendeinen komischen Variablennamen ausdenken. D.Nets compiler kann nicht untercheiden wann etwas ein Typ eine Variable oder Property ist. ;)

[kiar]

Moin Robert,

Erstmal Dank, das du dich meiner annimmst :mrgreen:

Das mir dem Serialisieren habe ich schon in Delphi hingekriegt, ich konnte auch deine Klasse Versicherter serialisieren, bei den anderen hatte ich immer das Problem mit List<>.

wenn ich aber

Delphi-Quellcode:

System.Xml

eingegeben habe wurde mir generic nicht vorgeschlagen. Deshalb bin ich da auch nicht weitergekommen.
nun ist ja Delphi 2005 nicht mit einer Hilfe ausgestattet(bei mir), so dass ich nur die Hilfe in #d , dank an <Rober_G> simmatze </Rober_G>, zur Verfügung habe :mrgreen: .

Zitat:

Zitat von Robert_G

Du schreibst diese Klassen in c# und kannst den typed collection wizard benutzen.
Die Assembly benutzt du dann von D.Net.

Diese Variante werde ich wohl nehmen müssen.

Zitat:

Zitat von Robert_G

Da du einen gewissen masochistischen Hang offenbarst,

Um dies unter Beweis zu stellen gucke ich jetzt Fussball :mrgreen: anderseits hat mir meine Frau auch keine Wahl gelassen entweder Laptop oder Fussball :shock:
jetzt werde ich bloss noch ein verstohlendes F5 machen können. Ich werde mir morgen aber den 1. Weg zu Gemüte führen und dich wahrscheinlich weiterhin nerven.

der Masochist