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

Inhaltsverzeichnis
1 Einführung
2 Grundlagen der Sprachsyntax
3 Klassendesign
4 Weitere Datentypen
5 Multithreading
6 Collections und LINQ
7 Eingabe und Ausgabe
8 Anwendungen: Struktur und Installation
9 Code erstellen und debuggen
10 Einige Basisklassen
11 Windows-Anwendungen erstellen
12 Die wichtigsten Steuerelemente
13 Tastatur- und Mausereignisse
14 MDI-Anwendungen
15 Grafiken mit GDI+
16 Drucken
17 Entwickeln von Steuerelementen
18 Programmiertechniken
19 WPF – Grundlagen
20 Layoutcontainer
21 WPF-Steuerelemente
22 Konzepte von WPF
23 Datenbankverbindung mit ADO.NET
24 Datenbankabfragen mit ADO.NET
25 DataAdapter
26 Offline mit DataSet
27 Datenbanken aktualisieren
28 Stark typisierte DataSets
A Anhang: Einige Übersichten
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual Basic 2008 von Andreas Kuehnel, Stephan Leibbrandt
Das umfassende Handbuch
Buch: Visual Basic 2008

Visual Basic 2008
3., aktualisierte und erweiterte Auflage, geb., mit DVD
1.323 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1171-0
Pfeil 6 Collections und LINQ
Pfeil 6.1 Sammlungsschnittstellen
Pfeil 6.1.1 IEnumerable
Pfeil 6.1.2 ICollection
Pfeil 6.1.3 IDictionary
Pfeil 6.1.4 IList
Pfeil 6.2 Sammlungsklassen
Pfeil 6.2.1 Collection
Pfeil 6.2.2 List
Pfeil 6.2.3 Wörterbücher
Pfeil 6.2.4 Schlangen
Pfeil 6.2.5 Gleichheit
Pfeil 6.3 Array
Pfeil 6.3.1 Die Eigenschaften eines Array-Objekts
Pfeil 6.3.2 Methoden von Array
Pfeil 6.4 LINQ
Pfeil 6.4.1 Neue Sprachkonzepte
Pfeil 6.4.2 Erweiterungsmethoden
Pfeil 6.4.3 Abfragesyntax
Pfeil 6.4.4 Abfrageoperatoren
Pfeil 6.4.5 From-Klausel
Pfeil 6.4.6 Der Restriktionsoperator Where
Pfeil 6.4.7 Projektionsoperatoren
Pfeil 6.4.8 Sortieroperatoren
Pfeil 6.4.9 Gruppieren mit GroupBy
Pfeil 6.4.10 Verknüpfungen mit Join
Pfeil 6.4.11 Die Set-Operator-Familie
Pfeil 6.4.12 Die Familie der Aggregatoperatoren
Pfeil 6.4.13 Generierungsoperatoren
Pfeil 6.4.14 Quantifizierungsoperatoren
Pfeil 6.4.15 Aufteilungsoperatoren
Pfeil 6.4.16 Die Elementoperatoren


Rheinwerk Computing - Zum Seitenanfang

6.2 Sammlungsklassen Zur nächsten ÜberschriftZur vorigen Überschrift

Der folgende Ausschnitt aus der Vererbungshierarchie zeigt einige spezifische Sammlungen und mit ihnen zusammenhängende Klassen. Um die Übersicht kurz zu halten sind optionale Namensteile in eckige Klammern gesetzt.

Object 
  +  1-+Comparer(Of T) 
  |    +[Sorted]Dictionary(Of TKey,TValue) 
  |    +EqualityComparer(Of T) 
  |    +HashSet(Of T) 
  |    +LinkedList[Node](Of T) 
  |    +[Sorted]List(Of T) 
  |    +Queue(Of T) 
  |    +Stack(Of T) 
  |    +SynchronizedCollection(Of T) 
  |    | + 1--SynchronizedKeyedCollection(Of String,ClientOperation|...) 
  |    +SynchronizedCollection(Of IExtension(Of T As 
  |    | |                                   {IExtensibleObject(Of T)})})) 
  |    | + 4--ExtensionCollection(Of T As {IExtensibleObject(Of T)})}) 
  |    +SynchronizedReadOnlyCollection(Of T) 
  +  2-+Collection(Of T) 
       | +  2-+KeyedCollection(Of TKey, TItem) 
       | |    | + 1--KeyedByTypeCollection(Of TItem) 
       | |    +ObservableCollection(Of T) 
       | +  3--BindingList(Of T) 
       +ReadOnlyCollection(Of T) 
         +  2--ReadOnlyObservableCollection(Of T)

   1: System.Collections.Generic 
   2: System.Collections.ObjectModel 
   3: System.ComponentModel 
   4: System.ServiceModel

Bevor wir einige Klassen im Detail anschauen, zeigt Tabelle 6.5 erst einmal eine Übersicht über einige Sammlungen. Auch hier sind optionale Teile in eckige Klammern gesetzt.


Tabelle 6.5 Generische Sammlungen in »System.Collections.Generic« ([ ] = optional, Collection mit [ ] außer »Synchronized« in »System.Collections.ObjectModel«)

Klasse Beschreibung

[Synchronized][ReadOnly] Collection(Of T)

Werteliste, die threadsicher (Synchronized) und/oder schreibgeschützt (ReadOnly) sein kann

[ReadOnly] ObservableCollection(Of T)

[Schreibgeschützte] Werteliste, die automatisch über Änderungen informiert, und mit Methoden zum Bewegen von Elementen und Kopieren in ein Array

[Sorted]List(Of T)

[Sortierte] Werteliste mit Indexzugriff und Methoden zum Suchen und Kopieren in ein Array

HashSet(Of T)

Wertemenge ohne Doubletten (Hashcode durch Comparer) mit Mengenoperationen (Vereinigung, Komplement, Schnitt, Teilmenge) und Kopie in ein Array

[Sorted]Dictionary (Of Key,Value)

Hashbasierte [sortierte] Schlüssel (durch Comparer berechnet) werden auf Werte abgebildet, Doubletten und Nothing-Schlüssel sind verboten.

KeyedCollection (Of TKey, TItem)

Liste von TItem Werten, die einen TKey Schlüssel enthalten (Kombination von IList und IDictionary).

LinkedList(Of T) LinkedListNode(Of T)

Doppelt verkettete Liste aus Knoten (Node) mit Methoden zum Löschen/Einfügen an den Enden sowie relativ zu einem Eintrag, Wertsuche von den Enden, Kopie in ein Array

Queue(Of T)

FiFo-Schlange mit Methoden zum Einstellen, Auslesen, Abholen und Kopieren in ein Array

Stack(Of T)

LiFo-Stapel mit Methoden zum Einstellen, Auslesen, Abholen und Kopieren in ein Array

Comparer(Of T)

Sortierer, für zum Beispiel SortedList(Of Key,Val), SortedDictionary(Of Key,Val), List(Of T).Sort und List(Of T).BinarySearch.

Implementiert IComparer(Of T). Eigenschaft Default liefert Standardsortierer.

EqualityComparer(Of T)

Vergleicher, zum Beispiel für Schlüssel, Eigenschaft Default liefert Standardvergleicher und verwendet IEquatable(Of T) bzw. Object.Equals und Object.GetHashCode.

Implementiert IEqualityComparer(Of T) .



Rheinwerk Computing - Zum Seitenanfang

6.2.1 Collection Zur nächsten ÜberschriftZur vorigen Überschrift

Die einfachste Implementierung einer Sammlung ist Collection(Of T). Über die implementierten Schnittstellen IList(Of T), ICollection(Of T), IEnumerable(Of T), IList, ICollection und IEnumerable hinaus stellt sie keine zusätzliche Funktionalität zur Verfügung. Die dem Konstruktor übergebene optionale Sammlung wird direkt verwendet, es wird also mit dem Original gearbeitet. Die Schnittstellenfunktionalität ist in Abschnitt 6.1, »Sammlungsschnittstellen«, beschrieben.

Etwas mehr Komfort bietet ObservableCollection(Of T) durch die Implementierung der Schnittstellen INotifyCollectionChanged und INotifyPropertyChanged mit der Möglichkeit, Änderungen an der Sammlung zu verfolgen. Die Klasse ist in Tabelle 6.6 aufgelistet und ist in der Bibliothek WindowsBase.dll definiert, die gegebenenfalls dem Projekt hinzugefügt werden muss.


Tabelle 6.6 ObservableCollection(Of T) ([ ] = optional)

Klasse Beschreibung

New([list As List(Of T)])

Öffentlicher Konstruktor

CollectionChanged As NotifyCollectionChangedEventHandler

Auslösung bei Änderung der Zusammensetzung der Sammlung (Registrierung automatisch)

PropertyChanged As PropertyChangedEventHandler

Auslösung bei Änderung eines Elements (nach manueller Registrierung)

Move(old As Integer, new As Integer)

Element verschieben


Wie das folgende Beispiel zeigt, kann die Überwachung auch sehr gut außerhalb von Benutzeroberflächen genutzt werden.


'...\Sammlungen\Klassen\ObservableCollection.vb

Option Strict On 
Imports System.Collections.ObjectModel 
Imports System.Collections.Specialized 
Namespace Sammlungen 
  Module Observable 
    Public Sub CollectionChanged(ByVal sender As Object, _ 
      ByVal ev As NotifyCollectionChangedEventArgs) 
      If ev.NewItems IsNot Nothing Then 
        For Each el As String In ev.NewItems 
          Console.Write("Hallo {0} ", el) : Next 
      End If 
      If ev.OldItems IsNot Nothing Then 
        For Each el As String In ev.OldItems 
          Console.Write("Tschö {0} ", el) : Next 
      End If 
    End Sub

    Sub Test() 
      Dim feier As ObservableCollection(Of String) = _ 
        New ObservableCollection(Of String)() 
      AddHandler feier.CollectionChanged, AddressOf CollectionChanged 
      feier.Add("Ganymed") : feier.Add("Europa") : feier.Add("Io") 
      feier.Add("Kallisto") : feier.Remove("Io") : feier.Remove("Europa") 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Reaktion auf Änderungen der Collection erfolgt automatisch.

Hallo Ganymed Hallo Europa Hallo Io Hallo Kallisto Tschö Io Tschö Europa

Rheinwerk Computing - Zum Seitenanfang

6.2.2 List Zur nächsten ÜberschriftZur vorigen Überschrift

Deutlich umfangreicher und komfortabler ist List(Of T) (und damit auch ArrayList). Es implementiert dieselben Schnittstellen wie Collection. Um Tabelle 6.7 möglichst kurz zu halten, habe ich kleingeschriebene Parameternamen und großgeschriebene Typen gemischt.


Tabelle 6.7 Methoden der Klasse List(Of T) ( [ ] = optional, | = Alternativen)

Klasse Beschreibung

New([capacity | IEnumerable(Of T)])

Öffentlicher Konstruktor

TrimExcess()

Kapazität der Ist-Größe anpassen

AddRange(IEnumerable(Of T)) InsertRange(index, IEnumerable(Of T))

Andere Liste anhängen bzw. einfügen

RemoveRange(index, count) RemoveAll(Predicate(Of T)) As Integer

Bereiche nach Index oder Kriterium löschen

BinarySearch([from, count, ]item [, IComparer(Of T)]) As Integer Find[Last]Index([from, [count,]] Predicate(Of T)) As Integer [Last]IndexOf(item [,index [,count]]) As Integer

Position eines Elements mittels Vergleich durch implementierende Klasse oder Delegate (IndexOf nutzt EqualityComparer(Of T).Default).

Find[Last](Predicate(Of T)) As T

Element, das das Kriterium erfüllt

FindAll(Predicate(Of T)) As List(Of T)

Elemente, die das Kriterium erfüllen

AsReadOnly() As ReadOnlyCollection(Of T)

Schreibgeschützte Referenz (Original ist änderbar)

Reverse([index, count])

Elementreihenfolge umdrehen

Sort([[index, count, ] IComparer(Of T)]) Sort(comparison(Of T))

Umsortierung mit implementierender Klasse oder Delegate

CopyTo([sourceIndex,] array, [arrayIndex [, count]]) ToArray() As T()

Flache Kopie in ein eindimensionales Feld mit Array.Copy

GetRange(index, count) As List(Of T)

Flache Kopie eines Bereichs der Liste

ConvertAll(Converter(Of T,TOutput)) As List(Of TOutput)

Neue Liste, elementweise mit converter konvertiert

ForEach(Action(Of T))

Aktion elementweise anwenden

Exists(Predicate(Of T)) As Boolean

Ein Element genügt dem Kriterium.

TrueForAll(Predicate(Of T)) As Boolean

Alle Element genügen dem Kriterium.


Insbesondere hat diese Auflistung die Möglichkeiten, Elemente zu suchen sowie die gesamte Auflistung zu sortieren. Fangen wir mit dem Sortieren an. Jede Sortiermethode muss zu sortierende Elemente vergleichen. Bei der großen Vielfalt an Typen gibt es keine allgemeingültigen Kriterien, nach denen sortiert werden könnte. Daher setzt die Methode Sort dazu die in der Schnittstelle IComparable definierte Methode CompareTo voraus und überlässt es implementierenden Klassen, zu definieren, was kleiner und größer ist. Sie sind sowieso die einzigen, die das überhaupt entscheiden können.


Public Interface IComparable(Of T) 
    Function CompareTo(ByVal other As T) As Integer 
End Interface

Die Methode liefert einen negativen Wert, wenn das aktuelle Objekt »kleiner« als das übergebene ist. Analog ist der Wert positiv, wenn es »größer« ist. Sind beide »gleich«, ist der Rückgabewert Null. Die absoluten Zahlenwerte spielen keine Rolle. Zum Beispiel sind die Rückgabewerte -27 und -1 gleichwertig. Der Typ der implementierenden Klasse muss nicht mit dem des Typparameters übereinstimmen.

Im folgenden Beispiel werden Bücher aufgrund ihrer Seitenzahl sortiert. Die Klasse Buch implementiert die Vergleichsschnittstelle. Anstatt selbst den Vergleich durchzuführen, reicht CompareTo den Vergleich an den Typ Integer durch, der die Schnittstelle auch implementiert. Lediglich der Fall einer Nullreferenz ist gesondert zu behandeln.


'...\Sammlungen\Klassen\Sortieren.vb

Option Strict On 
Namespace Sammlungen 
  Module Sortieren

    Class Buch : Implements IComparable(Of Buch) 
      Private titel As String 
      Private seitenzahl As Integer 
      Sub New(ByVal t As String, ByVal s As Integer) 
        titel = t : seitenzahl = s 
      End Sub

      Public Function CompareTo(other As Buch) As Integer 
      Implements IComparable(Of Buch).CompareTo 
        If other Is Nothing Then Return 100 
        Return seitenzahl.CompareTo(other.seitenzahl) 
      End Function

      Public Overrides Function ToString() As String 
        Return titel & " (" & seitenzahl & ")" 
      End Function 
    End Class

    Sub Test() 
      Dim Bücher As New List(Of Buch) 
      Bücher.Add(New Buch("Fähnrich Hornblower", 317)) 
      Bücher.Add(New Buch("Der Kapitän", 245)) 
      Bücher.Add(Nothing) 
      Bücher.Add(New Buch("Der Kommodore", 351)) 
      Bücher.Add(New Buch("Lord Hornblower", 301)) 
      For Each b As Buch In Bücher 
        Console.Write(If(b Is Nothing, "-", b.ToString()) & " ") : Next 
      Console.WriteLine() 
      Bücher.Sort() 
      For Each b As Buch In Bücher 
        Console.Write(If(b Is Nothing, "-", b.ToString()) & " ") : Next 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Ausgabe zeigt die korrekte Sortierung nach der Seitenzahl.

Fähnrich Hornblower (317) Der Kapitän (245) – Der Kommodore (351) 
  Lord Hornblower (301)

- Der Kapitän (245) Lord Hornblower (301) Fähnrich Hornblower (317) 
  Der Kommodore (351)

Eine andere Möglichkeit, zu vergleichen, besteht in der Übergabe eines Objekts, das den Vergleich durchführt. Das vergleichende Objekt muss die Schnittstelle IComparer implementieren, die IComparable sehr ähnlich ist.


Public Interface IComparer(Of T) 
    Function [Compare](ByVal x As T, ByVal y As T) As Integer 
End Interface

Der Rückgabewert ist genauso organisiert wie bei IComparable. Daher ist das folgende Beispiel dem letzten sehr ähnlich:


'...\Sammlungen\Klassen\Sortierung.vb

Option Strict On 
Namespace Sammlungen 
  Module Sortierung

    Class Buch 
      Private titel As String 
      Friend seitenzahl As Integer 
      Sub New(t As String, s As Integer) 
        titel = t : seitenzahl = s 
      End Sub

      Public Overrides Function ToString() As String 
        Return titel & " (" & seitenzahl & ")" 
      End Function 
    End Class

    Class Vergleich : Implements IComparer(Of Buch) 
      Public Function Compare(x As Buch, y As Buch) As Integer _ 
      Implements System.Collections.Generic.IComparer(Of Buch).Compare 
        If x Is Nothing AndAlso y Is Nothing Then Return 0 
        If x Is Nothing Then Return –1 
        If y Is Nothing Then Return 1 
        Return x.seitenzahl.CompareTo(y.seitenzahl) 
      End Function 
    End Class

    Sub Test() 
      Dim Bücher As New List(Of Buch) 
      Bücher.Add(New Buch("Fähnrich Hornblower", 317)) 
      Bücher.Add(New Buch("Der Kapitän", 245)) 
      Bücher.Add(Nothing) 
      Bücher.Add(New Buch("Der Kommodore", 351)) 
      Bücher.Add(New Buch("Lord Hornblower", 301)) 
      For Each b As Buch In Bücher 
        Console.Write(If(b Is Nothing, "-", b.ToString()) & " ") : Next 
      Console.WriteLine() 
      Bücher.Sort(New Vergleich()) 
      For Each b As Buch In Bücher 
        Console.Write(If(b Is Nothing, "-", b.ToString()) & " ") : Next 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Sortierung ist identisch zur letzten:

Fähnrich Hornblower (317) Der Kapitän (245) – Der Kommodore (351) 
  Lord Hornblower (301)

- Der Kapitän (245) Lord Hornblower (301) Fähnrich Hornblower (317) 
  Der Kommodore (351)

Einige Suchfunktionen arbeiten mit einer Testfunktion. Sowie diese True zurückgibt, gilt der als Argument übergebe Wert als der gefundene. Die Testfunktion kann als Delegate oder als Funktionsobjekt gegeben werden, wie im folgenden Beispiel. Dort wird die erste Zahl gesucht, die größer als 70 ist.


'...\Sammlungen\Klassen\Finden.vb

Option Strict On 
Namespace Sammlungen 
  Module Finden

    Function Siebzig(ByVal z As Integer) As Boolean 
      Return z > 70 
    End Function

    Sub Test() 
      Dim rnd As New Random(1) 
      Dim zahlen As New List(Of Integer)() 
      For i As Integer = 0 To 10 
        zahlen.Add(rnd.Next(0, 100)) 
      Next 
      For Each z As Integer In zahlen : Console.Write(z & " ") : Next 
      Console.WriteLine()

      Console.WriteLine("Erste größer als 70: {0}", _ 
                        zahlen.Find(Function(z As Integer) z > 70)) 
      Console.WriteLine("Erste größer als 70: {0}", _ 
                        zahlen.Find(AddressOf Siebzig)) 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Zahl wird auf beide Arten korrekt gefunden:

24 11 46 77 65 43 35 94 10 64 2 
Erste größer als 70: 77 
Erste größer als 70: 77

Rheinwerk Computing - Zum Seitenanfang

6.2.3 Wörterbücher Zur nächsten ÜberschriftZur vorigen Überschrift

Alle Wörterbuchklassen implementieren die Schnittstelle IDictionary, die bereits im Abschnitt 6.1, »Sammlungsschnittstellen«, vorgestellt wurde. Hier möchte ich noch auf ein Problem sortierter Auflistungen hinweisen, da Wörterbücher oft sortiert gespeichert werden. Der Sortiervorgang setzt einen Vergleich der Elemente der Auflistung voraus. Wenn Sie dem Konstruktor kein Objekt vom Typ IComparer(Of T) übergeben, wird ein Standardvergleich durchgeführt, der nicht immer passend ist.

Die einzelnen Einträge sind Paare von Schlüsseln und Werten. Wenn Sie ein Wörterbuch durchlaufen, ist der Typ des Elements weder der des Schlüssels noch der des Wertes, sondern des Paares. Im folgenden Beispiel werden Paare von Zeichenketten und Zahlen verarbeitet.


'...\Sammlungen\Klassen\Paar.vb

Option Strict On 
Namespace Sammlungen 
  Module Paar 
    Sub Test() 
      Dim tab As New Dictionary(Of String, Integer)() 
      tab.Add("Perm", 299) : tab.Add("Kreide", 145) 
      tab.Add("Karbon", 360) : tab.Add("Jura", 200) 
      For Each p As KeyValuePair(Of String, Integer) In tab 
        Console.Write("Beginn {0} vor {1} Mio Jahren ", p.Key, p.Value) 
      Next 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Ausgabe bestätigt die korrekte Arbeitsweise:

Beginn Perm vor 299 Mio Jahren Beginn Kreide vor 145 Mio Jahren 
Beginn Karbon vor 360 Mio Jahren Beginn Jura vor 200 Mio Jahren

Rheinwerk Computing - Zum Seitenanfang

6.2.4 Schlangen Zur nächsten ÜberschriftZur vorigen Überschrift

Eine Gruppe von Auflistungen ist dadurch gekennzeichnet, dass nur auf die Elemente an einem der beiden Enden zugegriffen werden kann. Aufgrund der Art von Änderungen werden zwei Ausprägungen unterschieden:

  • FiFo (first in first out): Das erste hinzugefügte Element wird auch als Erstes wieder entnommen, implementiert von der Klasse Queue(Of T) .
  • LiFo (last in first out): Das letzte hinzugefügte Element wird als Erstes wieder entnommen, implementiert von der Klasse Stack(Of T) .

Im folgenden Beispiel werden dieselben Zahlen mit Push in einem Stack und mit Enqueue in einer Queue abgelegt und mit Pop bzw. Dequeue wieder ausgelesen.


'...\Sammlungen\Klassen\Schlangen.vb

Option Strict On 
Namespace Sammlungen 
  Module Schlangen 
    Sub Test() 
      Dim st As New Stack(Of Integer), qu As New Queue(Of Integer) 
      For Each no As Integer In New Integer() {17, 45, 7, 82, 8} 
        Console.Write(no & " ") : st.Push(no) : qu.Enqueue(no) 
      Next 
      Console.WriteLine()

      While st.Count > 0 
        Console.Write(st.Pop() & " ") 
      End While 
      Console.WriteLine()

      While qu.Count > 0 
        Console.Write(qu.Dequeue() & " ") 
      End While 
      Console.ReadLine() 
    End Sub 
  End Module 
End Namespace

Die Ausgabe zeigt, dass Stack die Reihenfolge umkehrt und Queue sie beibehält.

17 45 7 82 8 
8 82 7 45 17 
17 45 7 82 8

Rheinwerk Computing - Zum Seitenanfang

6.2.5 Gleichheit topZur vorigen Überschrift

Die Schnittstellen IEquatable(Of T) und IComparable(Of T) werden leicht vergessen, wenn es darum geht, was unter Gleichheit von Objekten zu verstehen ist. Sie sind jedoch wichtig in Zusammenhang mit Sammlungen.



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 Basic 2008
Visual Basic 2008
Jetzt bestellen


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

 Buchempfehlungen
Zum Katalog: Visual Basic 2012






 Visual Basic 2012


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2009
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