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

Inhaltsverzeichnis
Vorwort zur 6. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Das Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Strukturen und Enumerationen
7 Fehlerbehandlung und Debugging
8 Auflistungsklassen (Collections)
9 Generics – Generische Datentypen
10 Weitere C#-Sprachfeatures
11 LINQ
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 XML
15 Multithreading und die Task Parallel Library (TPL)
16 Einige wichtige .NET-Klassen
17 Projektmanagement und Visual Studio 2012
18 Einführung in die WPF und XAML
19 WPF-Layout-Container
20 Fenster in der WPF
21 WPF-Steuerelemente
22 Elementbindungen
23 Konzepte von WPF
24 Datenbindung
25 Weitere Möglichkeiten der Datenbindung
26 Dependency Properties
27 Ereignisse in der WPF
28 WPF-Commands
29 Benutzerdefinierte Controls
30 2D-Grafik
31 ADO.NET – Verbindungsorientierte Objekte
32 ADO.NET – Das Command-Objekt
33 ADO.NET – Der SqlDataAdapter
34 ADO.NET – Daten im lokalen Speicher
35 ADO.NET – Aktualisieren der Datenbank
36 Stark typisierte DataSets
37 Einführung in das ADO.NET Entity Framework
38 Datenabfragen des Entity Data Models (EDM)
39 Entitätsaktualisierung und Zustandsverwaltung
40 Konflikte behandeln
41 Plain Old CLR Objects (POCOs)
Stichwort

Download:
- Beispiele, ca. 62,4 MB

Buch bestellen
Ihre Meinung?

Spacer
Visual C# 2012 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2012

Visual C# 2012
Rheinwerk Computing
1402 S., 6., aktualisierte und erweiterte Auflage 2013, geb., mit DVD
49,90 Euro, ISBN 978-3-8362-1997-6
Pfeil 14 XML
Pfeil 14.1 Grundlagen
Pfeil 14.2 XML-Dokumente
Pfeil 14.2.1 Wohlgeformte und gültige XML-Dokumente
Pfeil 14.2.2 Die Regeln eines wohlgeformten XML-Codes
Pfeil 14.2.3 Kommentare
Pfeil 14.2.4 Verarbeitungsanweisungen
Pfeil 14.2.5 Reservierte Zeichen in XML
Pfeil 14.2.6 CDATA-Abschnitte
Pfeil 14.2.7 Namensräume (Namespaces)
Pfeil 14.3 Die Gültigkeit eines XML-Dokuments
Pfeil 14.3.1 XML Schema Definition (XSD)
Pfeil 14.3.2 Ein XML-Dokument mit einem XML-Schema verknüpfen
Pfeil 14.3.3 Die Struktur eines XML-Schemas
Pfeil 14.4 Die Klasse »XmlReader«
Pfeil 14.4.1 XML-Dokumente mit einem »XmlReader«-Objekt lesen
Pfeil 14.4.2 Validieren eines XML-Dokuments
Pfeil 14.5 Eigenschaften und Methoden der Klasse »XmlReader«
Pfeil 14.6 Die Klasse »XmlWriter«
Pfeil 14.6.1 Die Methoden der Klasse »XmlWriter«
Pfeil 14.7 Navigation durch XML (XPath)
Pfeil 14.7.1 Die Klasse »XPathNavigator«
Pfeil 14.7.2 XPath-Ausdrücke
Pfeil 14.7.3 Der Kontextknoten
Pfeil 14.7.4 Beispiele mit XPath-Ausdrücken
Pfeil 14.7.5 Knotenmengen mit der »Select«-Methode
Pfeil 14.7.6 Auswerten von XPath-Ausdrücken
Pfeil 14.8 Das Document Object Model (DOM)
Pfeil 14.8.1 Allgemeines
Pfeil 14.8.2 Arbeiten mit »XmlDocument«
Pfeil 14.8.3 »XmlDocument« und »XPathNavigator«
Pfeil 14.8.4 Die Klasse »XmlNode« (Operationen mit Knoten)
Pfeil 14.8.5 Manipulieren einer XML-Struktur
Pfeil 14.8.6 Ändern eines Knotens
Pfeil 14.8.7 Löschen in einem XML-Dokument
Pfeil 14.9 Serialisierung mit »XmlSerializer«
Pfeil 14.9.1 XML-Serialisierung mit Attributen steuern
Pfeil 14.10 LINQ to XML
Pfeil 14.10.1 Allgemeines
Pfeil 14.10.2 Die Klassenhierarchie von LINQ to XML
Pfeil 14.10.3 Die Klasse »XElement«
Pfeil 14.10.4 Die Klasse »XDocument«
Pfeil 14.10.5 Navigation im XML-Dokument
Pfeil 14.10.6 Änderungen am XML-Dokument vornehmen

Galileo Computing - Zum Seitenanfang

14.4 Die Klasse »XmlReader«Zur nächsten Überschrift


Galileo Computing - Zum Seitenanfang

14.4.1 XML-Dokumente mit einem »XmlReader«-Objekt lesenZur nächsten ÜberschriftZur vorigen Überschrift

Das .NET Framework bietet mehrere Möglichkeiten, die von einem XML-Dokument beschriebenen Daten zu lesen. In diesem Abschnitt wollen wir uns mit der einfachsten Variante beschäftigen, nämlich dem Einlesen über ein XmlReader-Objekt.

Ein Objekt vom Typ XmlReader liest die Elemente eines XML-Dokuments einzeln und der Reihe nach einmal ein. Die gelesenen Daten sind schreibgeschützt und bleiben nicht im Arbeitsspeicher. Das mag ein Nachteil sein, hat aber auch zur Folge, dass die Speicherressourcen geschont werden und der Lesevorgang schnell ist. Damit bietet sich die Klasse XmlReader besonders an, wenn es ausreicht, ein XML-Dokument nur sequenziell zu lesen und nicht innerhalb des Dokuments nach bestimmten Daten zu suchen. Die Klasse ist abstract definiert und kann demnach nicht instanziiert werden. Allerdings bietet die Klasse mit der statischen Methode Create die Möglichkeit, sich eine Instanz zu besorgen.

XmlReader reader = XmlReader.Create(@"MeineDaten.xml");

Beachten Sie bitte, dass Sie den Namespace System.Xml mit using bekannt geben sollten.

Nachdem Sie das XmlReader-Objekt erzeugt haben, rufen Sie in einer Schleife die Methode Read auf, die alle Knoten im XML-Dokument nacheinander abruft. Der Rückgabewert der Methode ist true, wenn noch mindestens ein weiterer Knoten eingelesen werden kann.

while(reader.Read())
{
[...]
}

In der Schleife muss zuerst untersucht werden, welcher Knoten aktuell gelesen wird. Hier interessieren vorrangig Typ und Name des Knotens. Den Typ des Knotens rufen Sie mit der Eigenschaft NodeType ab, die durch einen Wert der Enumeration XmlNodeType beschrieben wird. Tabelle 14.2 beschreibt einen Auszug aus dieser Enumeration.

Tabelle 14.2 Auszug aus der Enumeration »XmlNodeType«

Bezeichner Beschreibung

Element

Beschreibt ein Element, z. B. <Artikel>.

Attribute

Beschreibt ein Attribut.

Text

Beschreibt den Textinhalt eines Knotens.

CDATA

Beschreibt einen CDATA-Abschnitt.

ProcessingInstruction

Beschreibt eine Verarbeitungsanweisung, z. B.
<?pi Testanweisung?>
.

Comment

Beschreibt einen Kommentar, z. B.
<!-- Ich bin ein Kommentar -->
.

Whitespace

Beschreibt Leerraum zwischen Markup.

EndElement

Beschreibt ein Endelementtag, z. B. </Artikel>.

XmlDeclaration

Beschreibt die XML-Deklaration, z. B. <?xml version='1.0'?>.

Die Struktur einer Schleife könnte also wie folgt codiert sein:

while (reader.Read()) {
switch (reader.NodeType) {
case XmlNodeType.XmlDeclaration:
[...]
break;
case XmlNodeType.CDATA:
[...]
break;
[...]
}
}

Die Untersuchung des Knotentyps hat eine besondere Bedeutung hinsichtlich der Auswertung, denn je nach Typ möchten Sie entweder den Knotenbezeichner oder den von einem Knoten beschriebenen Inhalt auswerten. Dazu dienen die beiden Eigenschaften Name und Value des XmlReader-Objekts.

Mit Value rufen Sie den Inhalt des aktuellen Knotens ab. Von den in Tabelle 14.2 angeführten Knotentypen können nur Attribute, CDATA, Comment, ProcessingInstruction, Text, Whitespace und XmlDeclaration einen Wert zurückgeben. Alle anderen Knoten liefern String.Empty.

Die Eigenschaft Name hingegen liefert den Bezeichner des aktuellen Knotens. Auch diese Eigenschaft ist auf bestimmte Knotentypen beschränkt. Dazu gehören Attribute, Element, EndElement, ProcessingInstruction und XmlDeclaration.

Die Attribute eines Elements auswerten

Eine »spezielle« Behandlung erfahren die Attribute eines Knotens vom Typ XmlNodeType.Element. Eigentlich würde man erwarten, dass ein Attribut als Knoten erkannt wird und das XmlReader-Objekt sich bei jedem Aufruf von Read auch von Attribut zu Attribut hangelt. Tatsächlich aber liest der XmlReader ein XmlNodeType.Element samt seinen Attributen komplett ein, so dass die Attribute beim nächsten Aufruf der Read-Methode nicht mehr im Datenstrom enthalten sind. Sie haben dann zwar den Inhalt des Elements ausgewertet, aber die Attribute unberücksichtigt gelassen.

Ist nicht exakt bekannt, ob und wie viele Attribute ein Element hat, hilft Ihnen die Eigenschaft HasAttributes des XmlReader-Objekts weiter, die true oder false zurückliefert. Diese Eigenschaft wird aufgerufen, wenn es sich bei dem aktuellen Knoten um den Typ XmlNodeType.Element handelt. Mit der Eigenschaft AttributeCount lässt sich die Anzahl der Attribute in Erfahrung bringen. Den zurückgelieferten Wert können Sie in einer for-Schleife verwenden. Die Methode GetAttribute unter Angabe entweder des Index oder des Attributbezeichners liefert den Wert des Attributs.

[...]
case XmlNodeType.Element:
if (reader.HasAttributes) {
for (int i = 0; i < reader.AttributeCount; i++) {
Console.WriteLine(reader.GetAttribute(i));
}
}
break;
[...]

Listing 14.24 Struktur der Auswertung einer Liste von Attributen (1)

Alternativ können Sie auch mit der Methode MoveToNextAttribute durch die Liste der Attribute navigieren. Ähnlich der Read-Methode des XmlReader-Objekts liefert auch diese Methode true zurück, falls das Element noch ein weiteres Attribut enthält.

[...]
case XmlNodeType.Element:
if (reader.HasAttributes) {
while (reader.MoveToNextAttribute()) {
[...]
}
}
break;
[...]

Listing 14.25 Struktur der Auswertung einer Liste von Attributen (2)

Beispielprogramm

Wir wollen uns nun die bisherigen Erkenntnisse in einem kompletten Beispielprogramm ansehen. Dazu bedarf es einer XML-Datei. Um nicht nur die XML-Datei, sondern auch deren Analyse und Ausgabe nicht zu aufwendig zu gestalten, wird mit dem Dokument nur eine Person mit den wichtigsten Eckdaten beschrieben.

<?xml version="1.0" encoding="utf-8" ?>
<!-- Liste von Personen-->
<Personen>
<Person>
<Befehl><![CDATA[Ich stehe unter CDATA]]></Befehl>
<Vorname>Manfred</Vorname>
<Telefon/>
<Zuname>Fischer</Zuname>
<Alter>45</Alter>
<Adresse Ort="Bonn" Strasse="Neuestr.34"></Adresse>
</Person>
</Personen>

Listing 14.26 XML-Dokument für das Beispielprogramm »XmlReaderSample«

Auf eine genaue Erklärung des folgenden Programmbeispiels werde ich an dieser Stelle verzichten. Es enthält ausschließlich Passagen, die bereits zuvor erläutert worden sind. Sie sollten den Code jedoch einmal mit der Konsolenausgabe, die Sie in Abbildung 14.5 sehen, vergleichen.

// Beispiel: ..\Kapitel 14\XmlReaderSample

static void Main(string[] args) {
XmlReader reader = XmlReader.Create(@"..\..\Personen.xml");
while (reader.Read()) {
switch (reader.NodeType) {
case XmlNodeType.XmlDeclaration:
Console.WriteLine("{0,-20}<{1}>", "DEKLARATION", reader.Value);
break;
case XmlNodeType.CDATA:
Console.WriteLine("{0,-20}{1}", "CDATA", reader.Value);
break;
case XmlNodeType.Whitespace:
Console.WriteLine("{0,-20}","WHITESPACE");
break;
case XmlNodeType.Comment:
Console.WriteLine("{0,-20}<!--{1}-->","COMMENT", reader.Value);
break;
case XmlNodeType.Element:
if (reader.IsEmptyElement)
Console.WriteLine("{0,-20}<{1} />","EMPTY_ELEMENT", reader.Name);
else {
Console.WriteLine("{0,-20}<{1}>", "ELEMENT", reader.Name);

// Prüfen, ob der Knoten Attribute hat

if (reader.HasAttributes) {

// Durch die Attribute navigieren

while (reader.MoveToNextAttribute()) {
Console.WriteLine("{0,-20}{1}",
"ATTRIBUT", reader.Name + "=" + reader.Value);
}
}
}
break;
case XmlNodeType.EndElement:
Console.WriteLine("{0,-20}</{1}>", "END_ELEMENT", reader.Name);
break;
case XmlNodeType.Text:
Console.WriteLine("{0,-20}{1}", "TEXT", reader.Value);
break;
}
}

Console.ReadLine();
}

Listing 14.27 Das Beispielprogramm »XmlReaderSample«

Abbildung

Abbildung 14.5 Ausgabe des Beispielprogramms »XmlReaderSample«

Die Daten eines XML-Dokuments verarbeiten

Das folgende Beispiel zeigt, wie die Daten eines XML-Dokuments dazu benutzt werden können, Objekte zu erstellen, die die gelesenen Daten in einem sinnvollen Kontext speichern. Ausgangspunkt sei wieder eine XML-Datei, die in diesem Fall aber nicht nur eine, sondern mehrere Personen beschreibt. Eine Person sei durch Vorname, Zuname, Alter sowie eine Adresse beschrieben.

<Person>
<Vorname>Manfred</Vorname>
<Zuname>Fischer</Zuname>
<Alter>45</Alter>
<Adresse Ort="Bonn" Strasse="Neuestr.34"></Adresse>
</Person>

Listing 14.28 XML-Struktur einer »Person« für das nächste Beispielprogramm

Die Daten zu einer Person sollen in einem Objekt vom Typ Person gespeichert werden. Für die Angaben der Adresse einer Person steht eine weitere Klasse Adresse zur Verfügung, die mit Ort und Strasse zwei Eigenschaften hat.

// Beispiel: ..\Kapitel 14\UsingXmlData

static void Main(string[] args) {
XmlReader reader;
reader = XmlReader.Create(@"..\..\Personen.xml");
List<Person> liste = new List<Person>();
Person person = null;
Adresse adresse = null;

while (reader.Read()) {

// Prüfen, ob es sich aktuell um ein Element handelt

if (reader.NodeType == XmlNodeType.Element) {

// Alle relevanten Elemente untersuchen

switch(reader.Name) {
case "Person":

// Neue Person erzeugen und in Liste eintragen

person = new Person();
liste.Add(person);
break;
case "Vorname":
person.Vorname = reader.ReadString();
break;
case "Zuname":
person.Zuname = reader.ReadString();
break;
case "Alter":
person.Alter = reader.ReadElementContentAsInt();
break;
case "Adresse":

// Neue Adresse erzeugen und der Person zuordnen

adresse = new Adresse();
person.Adresse = adresse;
if (reader.HasAttributes) {

// Attributsliste durchlaufen

while (reader.MoveToNextAttribute())
{
if (reader.Name == "Ort")
adresse.Ort = reader.Value;
else if (reader.Name == "Strasse")
adresse.Strasse = reader.Value;
}
}
break;
}
}
}

// Liste an der Konsole ausgeben

GetList(liste);
reader.Close();
Console.ReadLine();
}

// Ausgabe der Listeneinträge

static void GetList(List<Person> liste) {
foreach (Person temp in liste)
{
Console.WriteLine("Vorname: {0}\nZuname: {1}\nAlter: {2}",
temp.Vorname, temp.Zuname, temp.Alter);
Console.WriteLine("Ort: {0}\nStrasse: {1}\n",
temp.Adresse.Ort, temp.Adresse.Strasse);
}
}

Listing 14.29 Das Beispielprogramm »UsingXmlData«

In der while-Schleife interessieren im Zusammenhang mit der Aufgabenstellung nur die Elemente, die Daten beschreiben. Trifft der Reader auf einen Knoten vom Typ XmlNodeType.Element, wird mit einer switch-Anweisung der Elementbezeichner ausgewertet. In den case-Zweigen wird der beschriebene Wert des Elements ermittelt und der entsprechenden Eigenschaft eines Person-Objekts zugewiesen, das bei Erreichen des Elements Person erzeugt und einer generischen Liste hinzugefügt wird. Trifft die Laufzeit auf das Element Adresse, wird ein Objekt der gleichnamigen Klasse erzeugt und die Liste der Attribute des Elements ausgewertet.

Den vollständigen Code einschließlich der Klassen Person und Adresse finden Sie auf der Buch-DVD.


Galileo Computing - Zum Seitenanfang

14.4.2 Validieren eines XML-DokumentsZur nächsten ÜberschriftZur vorigen Überschrift

Die XML-Dokumente in den beiden zuvor gezeigten Beispielprogrammen sind wohlgeformt. Sie erkennen das daran, dass die gesamte Datei eingelesen wird, ohne dass es zu einer Ausnahme vom Typ XmlException kommt. Das bedeutet aber noch nicht, dass das Dokument valide, also gültig ist. Wie Sie wissen, bedarf es dazu einer XML-Schemadatei. Mit dem Tool xsd.exe oder Visual Studio ist eine solche sehr einfach zu erzeugen.

Um ein XML-Dokument, das mit einem XmlReader-Objekt sequenziell eingelesen wird, zu validieren, müssen wir auf eine Überladung der Methode Create der Klasse XmlReader zurückgreifen, die in einem zweiten Parameter nach einem Objekt vom Typ XmlReaderSettings verlangt.

public static XmlReader Create(string, XmlReaderSettings)

Ein XmlReaderSettings-Objekt dient nicht nur dazu, die Validierung vorzuschreiben. Es kann darüber hinaus das XmlReader-Objekt mit spezifischen Eigenschaften ausstatten. Beispielsweise könnte das XmlReaderSettings-Objekt das Einlesen der Kommentare oder die Berücksichtigung der Whitespaces unterbinden.

Doch widmen wir uns hier der Validierung. Zunächst müssen wir die Klasse XmlReaderSettings instanziieren und anschließend die Eigenschaft ValidationType einstellen. Wollen wir das Dokument gegen ein XML-Schema validieren, müssen wir ValidationType.Schema angeben, z. B.:

XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ValidationType = ValidationType.Schema;

Im nächsten Schritt ist das XML-Schema zu benennen. Da es sich auch um mehrere handeln könnte, kommt eine Auflistung ins Spiel, der alle XML-Schemata hinzugefügt werden. Die Referenz auf diese Auflistung erhalten wir über die Eigenschaft Schemas des XmlReaderSettings-Objekts. Darauf rufen wir die Methode Add auf, die im ersten Parameter den im Schema angegebenen targetNamespace erwartet. Enthält das XML-Schema kein Attribut targetNamespace oder legen Sie auf den Namespace der im XML-Schema beschriebenen Elemente keinen Wert, können Sie dem ersten Parameter auch null übergeben. Dem zweiten Parameter teilen Sie den URI der XML-Schemadatei mit.

readerSettings.Schemas.Add(null, @"..\..\Personen.xsd");

Sollte bei der Validierung des XML-Dokuments ein Fehler auftreten, wird das XmlReaderSettings-Objekt das Ereignis ValidationEventHandler auslösen. Wir müssen bei dem Objekt jetzt nur noch einen passenden Ereignishandler registrieren.

readerSettings.ValidationEventHandler += ValidationCallback;

Scheitert die Validierung, wird die Überprüfung des XML-Dokuments abgebrochen. Der Rest des Dokuments wird zwar weiterhin eingelesen, bleibt aber ungeprüft, und folgende Validierungsfehler werden nicht mehr erkannt. Besser ist es, im Fall des Scheiterns der Validierung eine Ausnahme auszulösen. Dies ermöglicht uns der Parameter vom Typ ValidationEventArgs des Ereignishandlers, der drei spezifische Eigenschaften hat, die Sie der Tabelle 14.3 entnehmen können.

Tabelle 14.3 Die Eigenschaften des »ValidationEventArgs«-Objekts

Eigenschaft Beschreibung

Exception

Ruft die dem Validierungsfehler zugeordnete Exception vom Typ XmlSchemaException ab.

Message

Liefert eine textuelle Beschreibung des aufgetretenen Validierungsfehlers.

Severity

Ruft den Schweregrad des Validierungsfehlers ab. Dabei werden zwei Schweregrade unterschieden: Warning, falls kein XML-Schema vorhanden ist, anhand dessen validiert werden kann, und Error, wenn ein Validierungsfehler auftritt.

Bitte beachten Sie, dass die Klasse ValidationEventArgs im Namespace System.Xml.Schema enthalten ist, der über using bekannt gegeben werden sollte.

Nachdem nun alle vorbereitenden Maßnahmen ergriffen worden sind, müssen wir zum Schluss noch dem XmlReader-Objekt das konfigurierte XmlReaderSettings-Objekt übergeben.

XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings);

Beispielprogramm zur Validierung

Die XML-Datei aus dem Beispiel XmlReaderSample soll nun anhand eines XML-Schemas validiert werden. Tritt ein Validierungsfehler auf, soll eine Ausnahme ausgelöst werden, die wir dem zweiten Parameter des Ereignishandlers entnehmen.

Darüber hinaus interessieren uns in der Ausgabe weder die Kommentare noch die Whitespaces. Diese werden durch die Einstellungen IgnoreWhitespace und IgnoreComments des XmlReaderSettings-Objekts ignoriert.

// Beispiel: ..\Kapitel 14\ValidationSample

static void Main(string[] args) {
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.IgnoreWhitespace = true;
readerSettings.IgnoreComments = true;
readerSettings.ValidationType = ValidationType.Schema;
readerSettings.Schemas.Add(null, @"..\..\Personen.xsd");
readerSettings.ValidationEventHandler += ValidationCallback;
XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings);
try {
while (reader.Read()) {

// Code wie im Beispielprogramm "XmlReaderSample"

}
}
catch(Exception ex) {
Console.WriteLine("Validierung fehlgeschlagen. \n{0}", ex.Message);
}
reader.Close();
Console.ReadLine();
}

// Ereignishandler

static void ValidationCallback(object sender, ValidationEventArgs e)
{
throw e.Exception;
}

Listing 14.30 Beispielprogramm zur Validierung von XML

Die XSD-Datei zu diesem Beispielprogramm liegt im Verzeichnis der Sourcecode-Dateien. Die Validierung wird zunächst ergeben, dass das XML-Dokument wohlgeformt und gültig ist. Sie können, um eine fehlgeschlagene Validierung zu simulieren, in der XML-Schemadatei beispielsweise das Element Befehl in Befehl1 ändern.



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# 2012

Visual C# 2012
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 2013
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.


[Rheinwerk Computing]

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