Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 16 XML
Pfeil 16.1 XML-Dokumente
Pfeil 16.1.1 Wohlgeformte und gültige XML-Dokumente
Pfeil 16.1.2 Regeln für wohlgeformten XML-Code
Pfeil 16.1.3 Kommentare
Pfeil 16.1.4 Verarbeitungsanweisungen
Pfeil 16.1.5 Reservierte Zeichen in XML
Pfeil 16.1.6 CDATA-Abschnitte
Pfeil 16.1.7 Namensräume (Namespaces)
Pfeil 16.2 Gültigkeit eines XML-Dokuments
Pfeil 16.2.1 XML Schema (XSD)
Pfeil 16.2.2 XML-Dokument mit einem XML Schema verknüpfen
Pfeil 16.2.3 Struktur eines XML Schemas
Pfeil 16.3 Die Klasse »XmlReader«
Pfeil 16.3.1 XML-Dokumente mit einem »XmlReader«-Objekt lesen
Pfeil 16.3.2 Validieren eines XML-Dokuments
Pfeil 16.4 Eigenschaften und Methoden der Klasse »XmlReader«
Pfeil 16.4.1 Navigation mit dem »XmlReader«
Pfeil 16.4.2 Eigenschaften und Methoden im Zusammenhang mit Attributen
Pfeil 16.4.3 Eigenschaften und Methoden im Zusammenhang mit Namespaces
Pfeil 16.4.4 Daten lesen
Pfeil 16.5 Die Klasse »XmlWriter«
Pfeil 16.5.1 Die Methoden der Klasse »XmlWriter«
Pfeil 16.6 Navigation durch XML (XPath)
Pfeil 16.6.1 Die Klasse »XPathNavigator«
Pfeil 16.6.2 XPath-Ausdrücke
Pfeil 16.6.3 Kontextknoten
Pfeil 16.6.4 Beispiele mit XPath-Ausdrücken
Pfeil 16.6.5 Knotenmengen mit der »Select«-Methode
Pfeil 16.6.6 Auswerten von XPath-Ausdrücken
Pfeil 16.7 Document Object Model (DOM)
Pfeil 16.7.1 Allgemeines
Pfeil 16.7.2 Arbeiten mit XmlDocument
Pfeil 16.7.3 XmlDocument und XPathNavigator
Pfeil 16.7.4 Die Klasse »XmlNode« (Operationen mit Knoten)
Pfeil 16.7.5 XML-Struktur manipulieren
Pfeil 16.7.6 Knoten ändern
Pfeil 16.7.7 Löschen in einem XML-Dokument
Pfeil 16.8 Serialisierung mit »XmlSerializer«
Pfeil 16.8.1 XML-Serialisierung mit Attributen steuern
Pfeil 16.9 LINQ to XML
Pfeil 16.9.1 Klassenhierarchie von LINQ to XML
Pfeil 16.9.2 Die Klasse »XElement«
Pfeil 16.9.3 Die Klasse »XDocument«
Pfeil 16.9.4 Navigation im XML-Dokument
Pfeil 16.9.5 Änderungen am XML-Dokument vornehmen


Galileo Computing - Zum Seitenanfang

16.8 Serialisierung mit »XmlSerializer« Zur nächsten ÜberschriftZur vorigen Überschrift

Bisher sind wir immer davon ausgegangen, dass die Daten bereits im XML-Format vorliegen. Das .NET Framework bietet zahlreiche Möglichkeiten, Daten in ein XML-Format zu überführen. Das können Sie sogar mit den Daten x-beliebiger Objekte umsetzen. Diese Technik wird als XML-Serialisierung bezeichnet.


Hinweis

In Kapitel 13, »Binäre Serialisierung«, wurde bereits die binäre Serialisierung besprochen, die nun in diesem Abschnitt ihre Fortsetzung findet.


Für die XML-Serialisierung ist die Klasse XmlSerializer zuständig, die zum Namespace System.Xml.Serialization.XmlSerializer gehört. Um Objektdaten in das XML-Format überführen zu können, sind einige Einschränkungen zu beachten:

  • Die zu serialisierende Klasse muss als public definiert sein.
  • Es werden nur als public deklarierte Felder oder Eigenschaften serialisiert. Die Eigenschaften müssen den lesenden und schreibenden Zugriff zulassen.
  • Die zu serialisierende Klasse muss einen öffentlichen, parameterlosen Konstruktor haben.
  • Die Steuerung der XML-Serialisierung erfolgt mit Attributen, die im Namespace System.Xml.Serialization zu finden sind. Damit ist es beispielsweise möglich, bestimmte Felder vom Serialisierungsprozess auszuschließen.
  • Im Gegensatz zu BinaryFormatter (siehe Kapitel 13) ist das Serializable-Attribut nicht zwingend vorgeschrieben.

Im folgenden Beispiel wird das Prinzip der XML-Serialisierung gezeigt.


// ---------------------------------------------------------
// Beispiel: ...\Kapitel 16\XMLSerialisierung
// ---------------------------------------------------------
using System;
using System.IO;
using System.Xml.Serialization;
class Program {
  static XmlSerializer serializer;
  static FileStream stream;
  static void Main(string[] args) {
    serializer = new XmlSerializer(typeof(Person));
    Person person = new Person("Jutta Speichel", 34);
    SerializeObject(person);
    Person oldPerson = DeserializeObject();
    Console.WriteLine("Name: " + oldPerson.Name);
    Console.WriteLine("Alter: " + oldPerson.Alter);
    Console.ReadLine();  
  }
  // Objekt serialisieren
  public static void SerializeObject(object obj) {
    stream = new FileStream(@"D:\PersonData.xml", FileMode.Create);
    serializer.Serialize(stream, obj);
    stream.Close();
}
  // Objekt deserialisieren
  public static Person DeserializeObject() {
    stream = new FileStream(@"D:\PersonData.xml", FileMode.Open);
    return (Person)serializer.Deserialize(stream);
  }
}
// zu serialisierende Klasse
public class Person {
  // Felder
  public int Alter { get; set; }
  private string _Name;
  // ----- Konstruktoren -----
  public Person() { }
  public Person(string name, int alter) {
    Name = name;
    Alter = alter;
  }
  // Eigenschaft
  public string Name {
    get { return _Name; }
    set { _Name = value; }
  }
}

Zur Einleitung des Serialisierungsprozesses wird der Konstruktor von XmlSerializer aufgerufen, der die Type-Angabe über das zu serialisierende Objekt entgegennimmt.


XmlSerializer serializer = new XmlSerializer(typeof(Person));

Wie bei der binären Serialisierung mit der Klasse BinaryFormatter werden die Objekte mit der Methode Serialize serialisiert. Sehen wir uns den Inhalt der XML-Datei an:


<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Alter>34</Alter>
  <Name>Jutta Speichel</Name>
</Person>

Mit Deserialize werden die XML-Daten serialisiert und in ein Objekt geschrieben. Da Deserialize den Typ Object ausliefert, müssen wir abschließend nur noch eine Typumwandlung in Person vornehmen.


Galileo Computing - Zum Seitenanfang

16.8.1 XML-Serialisierung mit Attributen steuern topZur vorigen Überschrift

Die XML-Serialisierung lässt sich auch mit zusätzlichen Attributen steuern, um das Ausgabeformat der serialisierten Daten zu bestimmen. Diese Attribute gehören zum Namespace System.Xml.Serialization. Die wichtigsten Attribute sehen Sie in Tabelle 16.19.


Tabelle 16.19 Attribute zur Steuerung der Ausgabe in einer XML-Datei

Attribut Beschreibung

XmlArray

Gibt an, dass ein bestimmtes Klassen-Member als Array serialisiert werden soll.

XmlArrayItem

Legt den Bezeichner in der XML-Datei für den vom Array verwalteten Typ fest.

XmlAttribute

Die Eigenschaft wird als XML-Attribut und nicht als XML-Element serialisiert.

XmlElement

Dieses Attribut legt den Elementnamen in der XML-Datei fest. Standardmäßig wird der Bezeichner des Feldes verwendet.

XmlIgnore

Legt fest, dass die Eigenschaft nicht serialisiert werden soll.

XmlRoot

Legt den Bezeichner des Wurzelelements der XML-Datei fest. Standardmäßig wird der Bezeichner der zu serialisierenden Klasse verwendet.


Am folgenden Beispiel wollen wir uns die Wirkungsweise der Attribute verdeutlichen. In der Anwendung ist erneut eine Klasse Person definiert. Mehrere Objekte vom Typ Person können von einem Objekt der Klasse PersonenListe verwaltet werden.


// -------------------------------------------------------------
// Beispiel: ...\Kapitel 16\XMLAttributeSample
// -------------------------------------------------------------
using System.Xml.Serialization;
using System.IO; 
...
[XmlRoot("PersonenListe")]
public class PersonenListe {
  [XmlElement("Listenbezeichner")]
  public string Listenname;    
  [XmlArray("PersonenArray")]
  [XmlArrayItem("PersonObjekt")]
  public Person[] Personen;
  // Konstruktoren
  public PersonenListe() { }
  public PersonenListe(string name) {
    this.Listenname = name;
  }
}
public class Person {
  [XmlElement("Name")]
  public string Zuname;
  [XmlElement("Wohnort")]
  public string Ort;
  [XmlElement("Alter")]
  public int Lebensalter;
  [XmlAttribute("PersID", DataType = "string")]
  public string ID;
  // Konstruktoren
  public Person() { }
  public Person(string zuname, string ort, int alter, string id) {
    this.Zuname = zuname;
    this.Ort = ort;
    this.Lebensalter = alter;
    this.ID = id;
  }
}

Ehe wir uns die Auswirkung der Attributierung ansehen, folgt hier zuerst der Code, der Person-Objekte mit XmlSerializer serialisiert:


class Program {
  static void Main(string[] args) {
    PersonenListe catalog = new PersonenListe("Teilnehmerliste");
    catalog.Listenname = "Teilnehmerliste";
    Person[] persons = new Person[2];
    // Personen erzeugen
    persons[0] = new Person("Peter", "Berlin", 45, "117");
    persons[1] = new Person();
    persons[1].Zuname = "Franz-Josef";
    persons[1].Ort = "Aschaffenburg";
    catalog.Personen = persons;
    // serialisieren
    XmlSerializer serializer = new XmlSerializer(typeof(PersonenListe));
    FileStream fs = new FileStream("Personenliste.xml", FileMode.Create);
    serializer.Serialize(fs, catalog);
    fs.Close();
    catalog = null;
    // deserialisieren
    fs = new FileStream("Personenliste.xml", FileMode.Open);
    catalog = (PersonenListe)serializer.Deserialize(fs);
    serializer.Serialize(Console.Out, catalog);
    Console.ReadLine();
  }
}

Das Array persons beschreibt ein Array von Person-Objekten, das zwei Objekte dieses Typs enthält. Die Referenz auf persons wird der Eigenschaft Personen eines PersonenListe-Objekts zugewiesen. Danach erfolgt die Serialisierung mit XmlSerializer in eine XML-Datei.

Nach der Serialisierung wird die Datei deserialisiert und ein serialisierender Datenstrom erzeugt, der in der Konsole seinen Abnehmer findet. So können wir uns den Inhalt des XML-Stroms direkt im Konsolenfenster ansehen, ohne die XML-Datei öffnen zu müssen.


<?xml version="1.0" encoding="ibm850"?>
<PersonenListe xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
               xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Listenbezeichner>Teilnehmerliste</Listenbezeichner>
  <PersonenArray>
    <PersonObjekt PersID="117">
      <Name>Peter</Name>
      <Wohnort>Berlin</Wohnort>
      <Alter>45</Alter>
    </PersonObjekt>
    <PersonObjekt>
      <Name>Franz-Josef</Name>
      <Wohnort>Aschaffenburg</Wohnort>
      <Alter>0</Alter>
    </PersonObjekt>
  </PersonenArray>
</PersonenListe>

Beachten Sie, wie die Verwendung der Attribute Einfluss auf die Elementbezeichner in der XML-Ausgabe nimmt.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern