[C#] DataTable als XML Textdatei speichern

private void SaveDataTable(DataTable dt, string filename)
{
    DataSet ds = new DataSet("TestDataSet");
    ds.ExtendedProperties["TimeStamp"] = DateTime.Now;
    ds.ExtendedProperties["Company"] = "TestCompany";

    ds.Tables.Add(dt);
    string xml = ds.GetXml();

    StreamWriter sw = new StreamWriter(filename, false, Encoding.UTF8);
    sw.Write(xml);
    sw.Close();
}

[C#] XML-Daten lesen

// XML-Datenobjekt erzeugen
XmlDocument xml = new XmlDocument();

// XML-Daten von einer URL lesen
xml.Load(new XmlTextReader("www.xmllesen.de"));

// Stringwert einer XML-Node lesen
string city = xml["weatherdata"]["location"]["name"].InnerText;

// testen, ob in einer Node weitere ChildNodes vorhanden sind
if (xml["weatherdata"]["forecast"].HasChildNodes)
{
    // alle ChildNodes durchgehen
    for (int i = 0; i < xml["weatherdata"]["forecast"].ChildNodes.Count; i++)
    {
        // ChildNode anhand des Indexes holen
        XmlNode node = xml["weatherdata"]["forecast"].ChildNodes[i];

        // Attribut der ChildNode lesen
        string wert1 = node.Attributes["from"].Value.ToString();
    }
}

[C#] Formatierte XML-Ausgabe

/// <summary->
/// formatiert XML code
/// </summary->
/// <param name=&quot;xml&quot;->input string mit XML-code</param->
/// <param name=&quot;indentation&quot;->Anzahl Zeichen für die Einrückung</param->
/// <param name=&quot;indentchar&quot;->Einrückungszeichen</param->
/// <returns->formatierter XML-code</returns->
public string FormatXML(string xml, int indentation, char indentchar)
{
    string res = string.Empty;

    MemoryStream ms = null;
    XmlTextWriter tw = null;

    try
    {
        XmlDocument doc = new XmlDocument();

        ms = new MemoryStream();
        tw = new XmlTextWriter(ms, Encoding.Unicode);

        doc.LoadXml(xml);

        tw.Formatting = Formatting.Indented;
        tw.Indentation = indentation;
        tw.IndentChar = indentchar;

        doc.WriteContentTo(tw);

        tw.Flush();
        ms.Flush();

        ms.Position = 0;

        StreamReader sr = new StreamReader(ms);

        res = sr.ReadToEnd();
    }
    catch (XmlException)
    {
    }
    finally
    {
        ms.Close();
        tw.Close();
    }

    return res;
}

XML-Wetterdaten als RSS-Feed von Yahoo! abrufen

Links

Beispielcode

private void btnReadRSS_Click(object sender, EventArgs e)
{
    string sTempVal = string.Empty;

    string sLanguage = string.Empty;

    string sUnitTemperature = string.Empty;
    string sUnitDistance = string.Empty;
    string sUnitPressure = string.Empty;
    string sUnitSpeed = string.Empty;

    // p=GMXX0007 -> LocationID von Berlin
    // u=c -> metrisches System (°C, km/h) verwenden
    string sURLRSSFeed = "http://weather.yahooapis.com/forecastrss?p=GMXX0007&u=c";

    // Wetterdaten als RSS-Feed (XML) von Yahoo! lesen    
    XmlDocument xmlRSS = new XmlDocument();
    xmlRSS.Load(new XmlTextReader(sURLRSSFeed));

    // Daten aus XML lesen und in die RichTextBox eintragen
    rtbContent.Clear();

    // General
    rtbContent.AppendText("General:\n");
    rtbContent.AppendText("* Title:\t" + xmlRSS["rss"]["channel"]["title"].InnerText + "\n");
    rtbContent.AppendText("* Link:\t" + xmlRSS["rss"]["channel"]["link"].InnerText + "\n");
    rtbContent.AppendText("* Description:\t" + xmlRSS["rss"]["channel"]["description"].InnerText + "\n");
    sLanguage = xmlRSS["rss"]["channel"]["language"].InnerText;
    rtbContent.AppendText("* Language:\t" + sLanguage + "\n");
    rtbContent.AppendText("* LastBuildDate:\t" + xmlRSS["rss"]["channel"]["lastBuildDate"].InnerText + "\n");
    
    // Item
    rtbContent.AppendText("\nItem:\n");
    rtbContent.AppendText("* Title:\t" + xmlRSS["rss"]["channel"]["item"]["title"].InnerText + "\n");
    rtbContent.AppendText("* Link:\t" + xmlRSS["rss"]["channel"]["item"]["link"].InnerText + "\n");
    rtbContent.AppendText("* Latitude:\t" + xmlRSS["rss"]["channel"]["item"]["geo:lat"].InnerText + "\n");
    rtbContent.AppendText("* Longitude:\t" + xmlRSS["rss"]["channel"]["item"]["geo:long"].InnerText + "\n");
    rtbContent.AppendText("* Publishing date:\t" + xmlRSS["rss"]["channel"]["item"]["pubDate"].InnerText + "\n");
    
    // Location
    rtbContent.AppendText("\nLocation:\n");
    rtbContent.AppendText("* City:\t" + xmlRSS["rss"]["channel"]["yweather:location"].Attributes["city"].Value + "\n");
    rtbContent.AppendText("* Region:\t" + xmlRSS["rss"]["channel"]["yweather:location"].Attributes["region"].Value + "\n");
    rtbContent.AppendText("* Country:\t" + xmlRSS["rss"]["channel"]["yweather:location"].Attributes["country"].Value + "\n");
    
    // Units
    rtbContent.AppendText("\nUnits:\n");
    sUnitTemperature = "°" + xmlRSS["rss"]["channel"]["yweather:units"].Attributes["temperature"].Value;
    sUnitDistance = xmlRSS["rss"]["channel"]["yweather:units"].Attributes["distance"].Value;
    sUnitPressure = xmlRSS["rss"]["channel"]["yweather:units"].Attributes["pressure"].Value;
    sUnitSpeed = xmlRSS["rss"]["channel"]["yweather:units"].Attributes["speed"].Value;
    rtbContent.AppendText("* Temperature:\t" + sUnitTemperature + "\n");
    rtbContent.AppendText("* Distance:\t" + sUnitDistance + "\n");
    rtbContent.AppendText("* Pressure:\t" + sUnitPressure + "\n");
    rtbContent.AppendText("* Speed:\t" + sUnitSpeed + "\n");
    
    // Condition
    rtbContent.AppendText("\nCondition:\n");
    rtbContent.AppendText("* Text:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:condition"].Attributes["text"].Value + "\n");
    sTempVal = xmlRSS["rss"]["channel"]["item"]["yweather:condition"].Attributes["code"].Value;
    rtbContent.AppendText("* Code:\t" + sTempVal + " (" + ConditionCodeToString(sTempVal) + ")\n");
    rtbContent.AppendText("* Temp:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:condition"].Attributes["temp"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* Date:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:condition"].Attributes["date"].Value + "\n");
    
    // Wind
    rtbContent.AppendText("\nWind:\n");
    rtbContent.AppendText("* Chill:\t" + xmlRSS["rss"]["channel"]["yweather:wind"].Attributes["chill"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* Direction:\t" + xmlRSS["rss"]["channel"]["yweather:wind"].Attributes["direction"].Value + "°" + "\n");
    rtbContent.AppendText("* Speed:\t" + xmlRSS["rss"]["channel"]["yweather:wind"].Attributes["speed"].Value + " " + sUnitSpeed + "\n");
    
    // Atmosphere
    rtbContent.AppendText("\nAtmosphere:\n");
    rtbContent.AppendText("* Humidity:\t" + xmlRSS["rss"]["channel"]["yweather:atmosphere"].Attributes["humidity"].Value + "%" + "\n");
    float fVisibility = float.Parse(xmlRSS["rss"]["channel"]["yweather:atmosphere"].Attributes["visibility"].Value, System.Globalization.CultureInfo.CreateSpecificCulture(sLanguage));
    fVisibility /= 100.0f;
    rtbContent.AppendText("* Visibility:\t" + fVisibility.ToString() + sUnitDistance + "\n");
    rtbContent.AppendText("* Pressure:\t" + xmlRSS["rss"]["channel"]["yweather:atmosphere"].Attributes["pressure"].Value + sUnitPressure + "\n");
    sTempVal = xmlRSS["rss"]["channel"]["yweather:atmosphere"].Attributes["rising"].Value;
    rtbContent.AppendText("* Rising:\t" + sTempVal + " (" + RisingCodeToString(sTempVal) + ")\n");

    // Astronomy
    rtbContent.AppendText("\nAstronomy:\n");
    rtbContent.AppendText("* Sunrise:\t" + xmlRSS["rss"]["channel"]["yweather:astronomy"].Attributes["sunrise"].Value + "\n");
    rtbContent.AppendText("* Sunset:\t" + xmlRSS["rss"]["channel"]["yweather:astronomy"].Attributes["sunset"].Value + "\n");
    
    // Forecast current day
    rtbContent.AppendText("\nForecast current day:\n");
    rtbContent.AppendText("* Day:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["day"].Value + "\n");
    rtbContent.AppendText("* Date:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["date"].Value + "\n");
    rtbContent.AppendText("* Low:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["low"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* High:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["high"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* Text:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["text"].Value + "\n");
    sTempVal = xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].Attributes["code"].Value;
    rtbContent.AppendText("* Code:\t" + sTempVal + " (" + ConditionCodeToString(sTempVal) + ")\n");
    
    // Forecast next day
    rtbContent.AppendText("\nForecast next day:\n");
    rtbContent.AppendText("* Day:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["day"].Value + "\n");
    rtbContent.AppendText("* Date:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["date"].Value + "\n");
    rtbContent.AppendText("* Low:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["low"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* High:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["high"].Value + sUnitTemperature + "\n");
    rtbContent.AppendText("* Text:\t" + xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["text"].Value + "\n");
    sTempVal = xmlRSS["rss"]["channel"]["item"]["yweather:forecast"].NextSibling.Attributes["code"].Value;
    rtbContent.AppendText("* Code:\t" + sTempVal + " (" + ConditionCodeToString(sTempVal) + ")\n");
    
    // Description (simple HTML)
    rtbContent.AppendText("\nDescription (simple HTML):\n");
    rtbContent.AppendText(xmlRSS["rss"]["channel"]["item"]["description"].InnerText + "\n");
}
/// <summary>
/// konvertiert den Code für Rising (0,1,2) zu einem string
/// </summary>
/// <param name="sRisingCode">0, 1, 2</param>
/// <returns>string</returns>
private string RisingCodeToString(string sRisingCode)
{
    string sRC = string.Empty;

    switch (sRisingCode)
    {
        case "0": sRC = "steady";
            break;
        case "1": sRC = "rising";
            break;
        case "2": sRC = "falling";
            break;
    }

    return sRC;
}
/// <summary>
/// konvertiert Condition zu string
/// </summary>
/// <param name="sConditionCode">Condition</param>
/// <returns>string</returns>
private string ConditionCodeToString(string sConditionCode)
{
    string sCC = string.Empty;

    switch (sConditionCode)
    {
        case "0": sCC = "tornado";
            break;
        case "1": sCC = "tropical storm";
            break;
        case "2": sCC = "hurricane";
            break;
        case "3": sCC = "severe thunderstorms";
            break;
        case "4": sCC = "thunderstorms";
            break;
        case "5": sCC = "mixed rain and snow";
            break;
        case "6": sCC = "mixed rain and sleet";
            break;
        case "7": sCC = "mixed snow and sleet";
            break;
        case "8": sCC = "freezing drizzle";
            break;
        case "9": sCC = "drizzle";
            break;
        case "10": sCC = "freezing rain";
            break;
        case "11": sCC = "showers";
            break;
        case "12": sCC = "showers";
            break;
        case "13": sCC = "snow flurries";
            break;
        case "14": sCC = "light snow showers";
            break;
        case "15": sCC = "blowing snow";
            break;
        case "16": sCC = "snow";
            break;
        case "17": sCC = "hail";
            break;
        case "18": sCC = "sleet";
            break;
        case "19": sCC = "dust";
            break;
        case "20": sCC = "foggy";
            break;
        case "21": sCC = "haze";
            break;
        case "22": sCC = "smoky";
            break;
        case "23": sCC = "blustery";
            break;
        case "24": sCC = "windy";
            break;
        case "25": sCC = "cold";
            break;
        case "26": sCC = "cloudy";
            break;
        case "27": sCC = "mostly cloudy (night)";
            break;
        case "28": sCC = "mostly cloudy (day)";
            break;
        case "29": sCC = "partly cloudy (night)";
            break;
        case "30": sCC = "partly cloudy (day)";
            break;
        case "31": sCC = "clear (night)";
            break;
        case "32": sCC = "sunny";
            break;
        case "33": sCC = "fair (night)";
            break;
        case "34": sCC = "fair (day)";
            break;
        case "35": sCC = "mixed rain and hail";
            break;
        case "36": sCC = "hot";
            break;
        case "37": sCC = "isolated thunderstorms";
            break;
        case "38": sCC = "scattered thunderstorms";
            break;
        case "39": sCC = "scattered thunderstorms";
            break;
        case "40": sCC = "scattered showers";
            break;
        case "41": sCC = "heavy snow";
            break;
        case "42": sCC = "scattered snow showers";
            break;
        case "43": sCC = "heavy snow";
            break;
        case "44": sCC = "partly cloudy";
            break;
        case "45": sCC = "thundershowers";
            break;
        case "46": sCC = "snow showers";
            break;
        case "47": sCC = "isolated thundershowers";
            break;
        case "3200": sCC = "not available";
            break;
    }

    return sCC;
}

Serialisierung abgeleiteter Klassen nach XML

  • möchte man Objekstrukturen, die Listen von abgeleiteten Objekten einer Basisklasse beinhalten, als XML serialisieren, so muss man sich des Attributs [XmlInclude(typeof(MeineAbgeleiteteKlasse))] bedienen
// Typen der abgeleiteten Klassen (auch z.B. enums!) müssen hier
// bei der Basisklasse aufgeführt werden
[XmlInclude(typeof(Auto))]
[XmlInclude(typeof(Fahrrad))]
public class Vehicel
{
    [XmlElement("Name")]
    public string sName;

    public Vehicel()
    {
    }
}

public class Auto : Vehicel
{
    [XmlElement("Räder")]
    public uint uiRaeder = 4;

    public Auto()
        : base()
    {
    }
}

public class Fahrrad : Vehicel
{
    [XmlElement("Gepäckträger")]
    public bool bGepaecktraeger = true;

    public Fahrrad()
        : base()
    {
    }
}

[XmlRoot("Objektliste")]
public class ObjektListe
{
    // ein String
    [XmlElement("Name")]
    public string sListenName;

    // ein List-Array mit Objekten definieren
    [XmlArray("Objekte")]
    [XmlArrayItem("Objekt")]
    public List<Vehicel> Objekte = new List<Vehicel>();

    public ObjektListe()
    {
    }
}

// Objektstruktur als XML speichern
private void btnSave_Click(object sender, EventArgs e)
{
    // Root-Objekt erstellen
    ObjektListe ol = new ObjektListe();
    ol.sListenName = "Fahrzeuge";

    // zwei Objekte erstellen und in die Liste einfügen
    ol.Objekte.Add(new Fahrrad());
    ol.Objekte.Add(new Auto());

    ol.Objekte[0].sName = "Stevens";
    ol.Objekte[1].sName = "BMW";

    // Stream öffnen
    FileStream fs = new FileStream("c:\\ObjektListe2.xml", FileMode.Create);

    // Objekte als XML serialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    xs.Serialize(fs, ol);

    // Stream schließen
    fs.Flush();
    fs.Close();
}

// XML Datei laden und Objekte rekonstruieren
private void btnLoad_Click(object sender, EventArgs e)
{
    // Stream öffnen 
    FileStream fs = new FileStream("c:\\ObjektListe2.xml", FileMode.Open);

    // Objekt deserialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    ObjektListe ol = xs.Deserialize(fs) as ObjektListe;

    if (ol != null)
    {
        for (int i = 0; i < ol.Objekte.Count; i++)
        {
            // Objekte anhand des Basistyps auslesen
            Vehicel v = ol.Objekte[i];

            if (v != null)
            {
                string sTyp = "n/a";

                // prüfen, ob Objekt einem
                // best. abgeleiteten Typ entspricht
                if (v is Auto)
                {
                    sTyp = "Auto";
                }
                else if (v is Fahrrad)
                {
                    sTyp = "Fahrrad";
                }

                Console.WriteLine("[" + sTyp + "] " +v.sName);
            }
        }
    }

    // Stream schließen
    fs.Close();
}

Serialisierung – XML (allgemein)

Allgemein

  • im Beispiel wird ein Objekt mit seinen Unterobjekten als XML serialisiert und als Datei ObjektListe.xml gespeichert
  • Wichtig ist immer die Angabe der Standardkonstruktoren in allen Klassen, sonst werden Exceptions geworfen!
  • alle zu speichernden Elemente müssen public sein
  • Falls Objektreferenzen als public-Variablen verwendet werden, dann sollte man darauf achten, dass keine zirkulären Bezüge auftreten! Ggf. sollte man diese Variablen mit [XmlIgnore] überspringen.
  • ArrayList, List<T> (generische Listen) und ReadOnly-Properties werden nicht serialisiert!
  • Wichtig ist außerdem, dass nicht alle Elemente, z.B. Referenz-Variablen vom Typ “object”, als [XmlAttribute(“Name”)] definiert werden können. Die XMLTags müssen dann häufig in [XmlElement(“Name”)] umgeändert werden.

Beispielcode

using System.IO;
using System.Xml;
using System.Xml.Serialization;

// ein Enumerator, zur Demonstration
public enum ObjektTyp
{
    Viereck, // wird später als "Viereck" gespeichert
    [XmlEnum("D")]
    Dreieck, // wird später als "D" gespeichert
    [XmlEnum("Q")]
    Quadrat // wird später als "Q" gespeichert
}

// Basisobjekt zur Demonstration der Speicherung
// der Basis-Eigenschaften, importiert das abgeleitete
// Objekt "Objekt"
[XmlInclude(typeof(Objekt))]
public class BasisObjekt
{
    // Unterelement string
    [XmlElement("Name")]
    public string sName = "n/a";

    // Standardkonstruktor
    public BasisObjekt()
    {
    }
}

// Listenobjekt was innerhalb von ObjektListe verwaltet wird
// ist von BasisObjekt abgeleitet
public class Objekt : BasisObjekt
{
    // ein Beispiel-Attribut von Objekt
    [XmlAttribute("id")]
    public int iId;

    // private -> wird nicht gespeichert
    private float _a;

    // float-Property, wird erst nach allen lokalen public-Variablen gespeichert,
    // obwohl es von der Reihenfolge her vor _b kommen müsste
    [XmlElement]
    public float a
    {
        get
        {
            return _a;
        }

        set
        {
            _a = value;
        }
    }

    // float-Unterelement
    [XmlElement("b")]
    public float _b;

    // Enumerator-Unterelement
    [XmlElement("Typ")]
    public ObjektTyp otTyp;

    // ein ParameterArray mit 3 int-Parametern definieren
    [XmlArray("ParameterListe")]
    [XmlArrayItem("Parameter")]
    public int[] Params = new int[3];

    // Standardkonstruktor mit Aufruf des Konstruktors der Basisklasse
    public Objekt()
        : base()
    {
    }

    public Objekt(float fa, float fb, int iObjektId, ObjektTyp Typ)
    {
        _a = fa;
        _b = fb;
        iId = iObjektId;
        otTyp = Typ;
    }

    // kleine Ausgabefunktion zur Kontrolle der Objektvariablen nach dem Lesen
    public void Print()
    {
        Console.WriteLine(sName + "[" + otTyp.ToString() + "]");
        Console.WriteLine("ID: {0}", iId);
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Parameter {0}: {1}", i, Params[i]);
        }
        Console.WriteLine("{0} x {1} = {2}", _a, _b, _a * _b);
    }
}

// Rootobjekt [XmlRoot], das geladen und gespeichert werden soll  
[XmlRoot("Objektliste")]
public class ObjektListe
{
    // ein String
    [XmlElement("Name")]
    public string _sListenName;

    // dieses Element wird bei der Serialisierung ignoriert
    [XmlIgnore]
    public int _iID;

    // ein dynamisches List-Array mit Objekten definieren
    [XmlArray("Objekte")]
    [XmlArrayItem("Objekt")]
    public List<Objekt> Objekte = new List<Objekt>();

    // Standardkonstruktor
    public ObjektListe()
    {
    }

    public ObjektListe(string sListenName, int iID)
    {
        _sListenName = sListenName;
        _iID = iID;
    }
}

// Objekt serialisiert speichern 
private void btnSave_Click(object sender, EventArgs e)
{
    // Root-Objekt erstellen
    ObjektListe ol = new ObjektListe("Flächen", 1);

    // drei Listenelemente hinzufügen
    ol.Objekte.Add(new Objekt(1.2f, 3.4f, 1, ObjektTyp.Dreieck));
    ol.Objekte.Add(new Objekt(2.5f, 5.6f, 2, ObjektTyp.Viereck));
    ol.Objekte.Add(new Objekt(4.7f, 8.1f, 3, ObjektTyp.Quadrat));

    // Namen und Parameter des Listenelemente definieren
    ol.Objekte[0].sName = "Fläche 1";
    ol.Objekte[0].Params[0] = 1;
    ol.Objekte[0].Params[1] = 2;
    ol.Objekte[0].Params[2] = 3;

    ol.Objekte[1].sName = "Fläche 2";
    ol.Objekte[1].Params[0] = 4;
    ol.Objekte[1].Params[1] = 5;
    ol.Objekte[1].Params[2] = 6;

    ol.Objekte[2].sName = "Fläche 3";
    ol.Objekte[2].Params[0] = 7;
    ol.Objekte[2].Params[1] = 8;
    ol.Objekte[2].Params[2] = 9;

    // Stream öffnen
    FileStream fs = new FileStream("c:\\ObjektListe.xml", FileMode.Create);

    // Objekte als XML serialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    xs.Serialize(fs, ol);

    // Stream schließen
    fs.Flush();
    fs.Close();
}

// Objekt laden und deserialisieren
private void btnLoad_Click(object sender, EventArgs e)
{
    // Stream öffnen 
    FileStream fs = new FileStream("c:\\ObjektListe.xml", FileMode.Open);

    // Objekt deserialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    Object o = xs.Deserialize(fs);
    ObjektListe ol = o as ObjektListe;

    // wenn die Deserialisierung funktioniert hat  
    // Testdaten ausgeben (Print())
    if (ol != null)
    {
        for (int i = 0; i < ol.Objekte.Count; i++)
        {
            Objekt obj = ol.Objekte[i];

            if (obj != null)
            {
                obj.Print();
            }
        }
    }

    // Stream schließen
    fs.Close();
}
  • die gespeicherte Ausgabedatei ObjektListe.xml sieht wie folgt aus:
<?xml version="1.0"?>
<Objektliste xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Flächen</Name>
  <Objekte>
    <Objekt id="1">
      <Name>Fläche 1</Name>
      <b>3.4</b>
      <Typ>D</Typ>
      <ParameterListe>
        <Parameter>1</Parameter>
        <Parameter>2</Parameter>
        <Parameter>3</Parameter>
      </ParameterListe>
      <a>1.2</a>
    </Objekt>
    <Objekt id="2">
      <Name>Fläche 2</Name>
      <b>5.6</b>
      <Typ>Viereck</Typ>
      <ParameterListe>
        <Parameter>4</Parameter>
        <Parameter>5</Parameter>
        <Parameter>6</Parameter>
      </ParameterListe>
      <a>2.5</a>
    </Objekt>
    <Objekt id="3">
      <Name>Fläche 3</Name>
      <b>8.1</b>
      <Typ>Q</Typ>
      <ParameterListe>
        <Parameter>7</Parameter>
        <Parameter>8</Parameter>
        <Parameter>9</Parameter>
      </ParameterListe>
      <a>4.7</a>
    </Objekt>
  </Objekte>
</Objektliste>
  • nach dem Zurücklesen sollte Folgendes auf der Konsole ausgegeben werden:
Fläche 1[Dreieck]
ID: 1
Parameter 0: 1
Parameter 1: 2
Parameter 2: 3
1,2 x 3,4 = 4,08
Fläche 2[Viereck]
ID: 2
Parameter 0: 4
Parameter 1: 5
Parameter 2: 6
2,5 x 5,6 = 14
Fläche 3[Quadrat]
ID: 3
Parameter 0: 7
Parameter 1: 8
Parameter 2: 9
4,7 x 8,1 = 38,07
  • weiterführender Link: Link