net biblio thek

hrsg. von dr. holger SCHWICHTENBERG
.NET BIBLIOTHEK
walter DOBERENZ
matthias FISCHER
jana FRANK
thomas GEWINNUS
jörg KRAUSE
patrick a. LORENZ
jörg NEUMANN
dr. holger SCHWICHTENBERG
.NET 3.5
WPF, WCF, LINQ, C# 2008,
VB 2008 und ASP.NET AJAX
Inhaltsverzeichnis
Geleitwort
Vorwort
...................................................................................
15
.......................................................................................
17
Danksagung
.................................................................................
Über dieses Buch
..........................................................................
19
21
Teil I: Einführung
1
Einführung in LINQ
1.1
1.2
1.3
1.4
.......................................................................
27
Was ist LINQ? ..........................................................................
1.1.1
Ein Überblick .................................................................
1.1.2
LINQ als Werkzeugsammlung ...............................................
1.1.3
LINQ als Spracherweiterung ................................................
Warum brauchen wir LINQ? ...........................................................
1.2.1
Allgemeine Probleme ........................................................
1.2.2
Zur Fehlanpassung zwischen den Paradigmen ..............................
1.2.3
LINQ als Retter in der Not ...................................................
Entwurfsziele und Ursprünge von LINQ ..............................................
1.3.1
Die Ziele des LINQ-Projekts ................................................
1.3.2
Ein historischer Rückblick ...................................................
Die ersten Schritte mit LINQ to Objects ..............................................
1.4.1
Was wir für den Start brauchen ..............................................
1.4.2
Hello LINQ to Objects .......................................................
28
28
29
30
32
33
35
40
42
42
43
45
45
47
6
Inhaltsverzeichnis
1.5
1.6
1.7
2
Erste Schritte mit LINQ to XML ......................................................
1.5.1
Warum brauchen wir LINQ to XML? .......................................
1.5.2
Hello LINQ to XML .........................................................
Erste Schritte mit LINQ to SQL .......................................................
1.6.1
Überblick über die LINQ to SQL-Features ..................................
1.6.2
Hello LINQ to SQL ..........................................................
1.6.3
Ein genauerer Blick auf LINQ to SQL ......................................
Zusammenfassung .....................................................................
Spracherweiterungen in C# und VB
2.1
2.2
2.3
2.4
2.5
2.6
2.7
51
51
53
58
58
59
63
63
.................................................
65
Die neuen Spracherweiterungen erkunden ............................................
2.1.1
Eine Liste der laufenden Prozesse generieren ...............................
2.1.2
Gruppieren der Ergebnisse in einer Klasse ..................................
Implizit typisierte lokale Variablen ....................................................
2.2.1
Die Syntax ....................................................................
2.2.2
Beispiel mit implizit typisierten lokalen Variablen ..........................
Objekt- und Collection-Initialisierer ...................................................
2.3.1
Warum wir Objektinitialisierer brauchen ....................................
2.3.2
Collection-Initialisierer ......................................................
2.3.3
Verbesserung unseres Beispiels mit Objektinitialisierer ....................
Lambda-Ausdrücke ....................................................................
2.4.1
Eine Auffrischung zu Delegates .............................................
2.4.2
Anonyme Methoden .........................................................
2.4.3
Einführung in die Lambda-Ausdrücke ......................................
Erweiterungsmethoden .................................................................
2.5.1
Beispiel für das Erzeugen einer Erweiterungsmethode .....................
2.5.2
Weitere Beispiele zu den LINQ Standard-Abfrageoperatoren ..............
2.5.3
Erweiterungsmethoden im Einsatz ..........................................
2.5.4
Einsatzbeschränkungen ......................................................
Anonyme Typen ........................................................................
2.6.1
Anonyme Typen zum Gruppieren von Daten ...............................
2.6.2
Namenlose Typen sind trotzdem Typen .....................................
2.6.3
Verbesserung unseres Beispiels durch anonyme Typen .....................
2.6.4
Einschränkungen .............................................................
Zusammenfassung .....................................................................
65
66
68
69
69
70
72
72
73
74
76
76
78
78
84
84
87
89
90
93
93
93
94
95
97
7
Inhaltsverzeichnis
3
Der LINQ-Baukasten
3.1
3.2
3.3
3.4
3.5
3.6
3.7
.....................................................................
101
Wie .NET mit LINQ erweitert wird ...................................................
3.1.1
Die grundlegenden Spracherweiterungen ...................................
3.1.2
Die Schlüsselelemente der LINQ-Foundation ...............................
Einführung von Sequenzen ............................................................
3.2.1
IEnumerable<T> .............................................................
3.2.2
Mehr über Iteratoren .........................................................
3.2.3
Verzögerte Ausführung von Abfragen .......................................
Einführung in die Abfrageoperatoren ..................................................
3.3.1
Was macht eigentlich ein Abfrageoperator? .................................
3.3.2
Die Standard-Abfrageoperatoren ............................................
Einführung in Abfrageausdrücke ......................................................
3.4.1
Was ist ein Abfrageausdruck? ................................................
3.4.2
Schreiben von Abfrageausdrücken ..........................................
3.4.3
Standard-Abfrageoperatoren versus Abfrageausdrücke .....................
3.4.4
Einschränkungen .............................................................
Einführung in die Expression Trees ...................................................
3.5.1
Die Rückkehr der Lambda-Ausdrücke ......................................
3.5.2
Was sind Expression-Trees? .................................................
3.5.3
IQueryable und verzögertes Ausführen von Abfragen ......................
LINQ-DLLs und -Namensräume ......................................................
Zusammenfassung .....................................................................
101
101
103
103
104
105
107
111
111
114
115
115
116
118
120
122
122
123
125
126
128
Teil II: LINQ to Objects
4
Arbeiten mit LINQ to Objects
4.1
4.2
4.3
..........................................................
131
Einführung in unsere Beispielanwendung .............................................
4.1.1
Unsere Ziele ..................................................................
4.1.2
Features .......................................................................
4.1.3
Die Geschäfts-Entitäten ......................................................
4.1.4
Datenbankschema ............................................................
4.1.5
Beispieldaten .................................................................
LINQ für In-Memory-Collections .....................................................
4.2.1
Was können wir abfragen? ...................................................
4.2.2
Unterstützte Operationen ....................................................
LINQ mit ASP.NET und Windows Forms ............................................
4.3.1
Datenbindung für Webanwendungen ........................................
131
132
132
133
134
134
136
137
141
142
142
8
Inhaltsverzeichnis
4.4
4.5
4.6
5
4.3.2
Datenbindung für Windows Forms-Applikationen .........................
Die wichtigsten Standard-Abfrageoperatoren .........................................
4.4.1
Der Einschränkungs-Operator Where .......................................
4.4.2
Verwendung von Projektions-Operatoren ...................................
4.4.3
Anwendung von Distinct ....................................................
4.4.4
Anwenden von Konvertierungsoperatoren ..................................
4.4.5
Verwendung von Aggregat-Operatoren ......................................
Sichten auf einen Objektgraphen im Speicher ........................................
4.5.1
Sortierung ....................................................................
4.5.2
Eingebettete Abfragen .......................................................
4.5.3
Gruppieren ...................................................................
4.5.4
Verwenden von Joins .........................................................
4.5.5
Partitionieren .................................................................
Zusammenfassung .....................................................................
Jenseits der Standardabfragen
5.1
5.2
5.3
5.4
149
154
155
156
159
160
161
162
162
164
167
168
174
179
........................................................
181
Allgemeine Szenarien ..................................................................
5.1.1
Abfrage nichtgenerischer Collections .......................................
5.1.2
Gruppieren nach Mehrfachkriterien .........................................
5.1.3
Dynamische Abfragen .......................................................
5.1.4
LINQ to Text Files ...........................................................
Entwurfsmuster ........................................................................
5.2.1
Funktionale Konstruktion – ein Pattern .....................................
5.2.2
Das ForEach-Pattern .........................................................
Betrachtungen zur Performance .......................................................
5.3.1
Streaming-Strategie ..........................................................
5.3.2
Vorsicht bei sofortiger Ausführung ..........................................
5.3.3
Verschlechtert LINQ to Objects die Performance? ..........................
5.3.4
Gedanken zum Overhead von LINQ to Objects ............................
5.3.5
Performance versus Kürze – ein Dilemma? .................................
Zusammenfassung .....................................................................
181
182
184
187
197
200
200
203
205
206
208
210
213
216
217
Teil III: LINQ to SQL
6
Der Einstieg in LINQ to SQL
6.1
............................................................
221
Start mit LINQ to SQL .................................................................
6.1.1
Zuordnung (Mapping) der Objekte ..........................................
222
225
9
Inhaltsverzeichnis
6.2
6.3
6.4
6.5
6.6
6.7
7
Details zu LINQ to SQL
7.1
7.2
7.3
7.4
8
6.1.2
Einrichten des DataContext ..................................................
Lesen von Daten mit LINQ to SQL ...................................................
Verfeinern unserer LINQ-Abfragen ...................................................
6.3.1
Filtern .........................................................................
6.3.2
Sortieren und gruppieren .....................................................
6.3.3
Aggregation ..................................................................
6.3.4
Joining ........................................................................
Arbeiten mit Objektbäumen ...........................................................
Wann werden meine Daten geladen? ..................................................
6.5.1
Träges Laden (lazy loading) .................................................
6.5.2
Sofortiges Laden von Detaildaten ...........................................
Aktualisieren der Daten ................................................................
Zusammenfassung .....................................................................
...................................................................
251
Mapping von Objekten mit relationalen Daten ........................................
7.1.1
Inline-Attribute ...............................................................
7.1.2
Mapping mit externen XML-Dateien ........................................
7.1.3
Das SqlMetal-Tool ...........................................................
7.1.4
Der LINQ to SQL-Designer .................................................
Übersetzen von Abfrageausdrücken nach SQL .......................................
7.2.1
IQueryable ....................................................................
7.2.2
Ausdrucksbäume ............................................................
Der Lebenszyklus der Entitäten ........................................................
7.3.1
Verfolgen von Änderungen ..................................................
7.3.2
Änderungen durchführen ....................................................
7.3.3
Arbeiten mit verbindungslosen Daten ......................................
Zusammenfassung .....................................................................
251
252
257
259
262
264
264
266
269
270
271
274
276
Erweiterte LINQ to SQL-Features
8.1
8.2
227
228
232
232
234
236
237
240
243
243
245
247
249
.....................................................
277
Umgang mit simultanen Änderungen .................................................
8.1.1
Pessimistische Konkurrenz ..................................................
8.1.2
Optimistische Konkurrenz ...................................................
8.1.3
Behandlung von Konkurrenz-Ausnahmen ..................................
8.1.4
Auflösen von Konflikten mittels Transaktionen .............................
Fortgeschrittene Datenbankfeatures ...................................................
8.2.1
SQL pass-through: Rückgabe von Objekten aus SQL Abfragen ...........
8.2.2
Arbeiten mit gespeicherten Prozeduren .....................................
277
278
278
281
284
286
287
288
10
Inhaltsverzeichnis
8.3
8.4
8.5
8.2.3
Benutzerdefinierte Funktionen ..............................................
Verbesserungen auf Geschäftsebene ...................................................
8.3.1
Kompilierte Abfragen ........................................................
8.3.2
Partielle Klassen für unsere Geschäftslogik .................................
8.3.3
Vorzüge partieller Methoden .................................................
8.3.4
Vererbung von Objekten ....................................................
Ein kurzer Abstecher nach LINQ to Entities ..........................................
Zusammenfassung .....................................................................
296
300
300
301
303
305
310
313
Teil IV: LINQ to XML
9
Einführung in LINQ to XML
9.1
9.2
9.3
9.4
9.5
9.6
.............................................................
317
Was ist die LINQ to XML-API? .......................................................
Wozu brauchen wir noch eine API? ...................................................
Die Entwurfsprinzipien von LINQ to XML ...........................................
9.3.1
Schlüsselkonzept: Funktionale Konstruktion ................................
9.3.2
Schlüsselkonzept: kontext-freie XML-Erzeugung ..........................
9.3.3
Schlüsselkonzept: Vereinfachte Namen .....................................
Die LINQ to XML-Klassenhierarchie .................................................
XML mit LINQ verarbeiten ...........................................................
9.5.1
XML laden ...................................................................
9.5.2
XML parsen ..................................................................
9.5.3
XML erzeugen ...............................................................
9.5.4
XML mit den Visual Basic XML-Literalen erzeugen .......................
9.5.5
XML-Dokumente erstellen ..................................................
9.5.6
Content in XML einfügen ....................................................
9.5.7
Content aus XML-Dokumenten löschen ....................................
9.5.8
Inhalte ändern ................................................................
9.5.9
Die Verwendung von Attributen .............................................
9.5.10 XML speichern ...............................................................
Zusammenfassung .....................................................................
317
318
319
321
322
322
325
327
328
330
331
335
337
340
342
343
345
346
346
10 XML abfragen und transformieren
10.1
...................................................
349
Die LINQ to XML-Achsen-Methoden ................................................
10.1.1 Element .......................................................................
10.1.2 Attribute ......................................................................
10.1.3 Elements ......................................................................
350
352
352
354
11
Inhaltsverzeichnis
10.2
10.3
10.4
10.5
10.1.4 Descendants (Nachkommen) ................................................
10.1.5 Ancestors (Vorfahren) ........................................................
10.1.6 Weitere Achsenmethoden ....................................................
10.1.7 Visual Basic XML-Achseneigenschaften ...................................
Die Standard-Abfrageoperatoren ......................................................
10.2.1 Projektionen mit Select ......................................................
10.2.2 Filtern mit Where ............................................................
10.2.3 Sortieren und Gruppieren ....................................................
LINQ to XML-Objekte mit XPath abfragen ..........................................
XML transformieren ...................................................................
10.4.1 Transformieren mit LINQ to XML ..........................................
10.4.2 LINQ to XML-Objekte mit XSLT transformieren ..........................
Zusammenfassung .....................................................................
11 Diverse LINQ to XML-Szenarien
11.1
11.2
11.3
11.4
11.5
11.6
11.7
355
357
359
360
363
365
366
368
371
373
373
376
378
.......................................................
379
Objekte aus XML-Daten erzeugen ....................................................
11.1.1 Aufgabenstellung .............................................................
11.1.2 Implementierung .............................................................
XML aus Objektbäumen erzeugen ....................................................
11.2.1 Aufgabenstellung .............................................................
11.2.2 Implementierung .............................................................
XML aus Datenbankinformationen erzeugen .........................................
11.3.1 Aufgabenstellung .............................................................
11.3.2 Implementierung .............................................................
Filtern/Mischen von relationalen und XML-Daten ...................................
11.4.1 Aufgabenstellung .............................................................
11.4.2 Implementierung .............................................................
XML-Daten in relationale Daten umwandeln .........................................
11.5.1 Aufgabenstellung .............................................................
11.5.2 Implementierung .............................................................
Textdateien nach XML transformieren ................................................
11.6.1 Aufgabenstellung .............................................................
11.6.2 Implementierung .............................................................
Zusammenfassung .....................................................................
379
380
382
385
385
386
391
391
393
397
398
398
402
403
404
417
417
418
420
12
Inhaltsverzeichnis
Teil V: Diverse LINQ-Techniken
12 LINQ erweitern
12.1
12.2
12.3
12.4
12.5
12.6
.............................................................................
425
Die Erweiterungsmechnismen von LINQ .............................................
12.1.1 LINQ-Flavours als LINQ-Implementierungen ..............................
12.1.2 Vorschläge für kundenspezifische LINQ-Erweiterungen ...................
Erstellen benutzerdefinierter Abfrageoperatoren ......................................
12.2.1 Verbesserungen der Standard-Abfrageoperatoren ...........................
12.2.2 Hilfs- oder bereichsspezifische Abfrageoperatoren .........................
Neuimplementierungen der Basis-Abfrageausdrücke .................................
12.3.1 Wiederholung: Der Übersetzungsmechanismus für Abfragen ..............
12.3.2 Spezifizierung des Musters für Abfrageausdrücke ..........................
12.3.3 Beispiel 1: Verfolgen der Ausführung von Standard-Abfrageoperatoren ...
12.3.4 Einschränkung: Kollision von Abfrageausdrücken .........................
12.3.5 Beispiel 2: Nichtgenerische, domänenspezifische Operatoren ..............
12.3.6 Beispiel 3: Non-Sequence Operator ........................................
Abfragen eines Webdienstes: LINQ to Amazon ......................................
12.4.1 Einführung in LINQ to Amazon .............................................
12.4.2 Anforderungen ...............................................................
12.4.3 Implementierung .............................................................
IQueryable und IQueryProvider: LINQ to Amazon erweiterte Version ..............
12.5.1 Die IQueryable- und IQueryProvider- Schnittstellen .......................
12.5.2 Implementierung .............................................................
12.5.3 Was genau passiert ...........................................................
Zusammenfassung .....................................................................
426
426
428
429
429
432
436
437
438
440
442
443
445
447
447
449
450
458
458
462
463
464
13 LINQ auf allen Ebenen
13.1
13.2
13.3
...................................................................
465
Überblick über die LinqBooks-Applikation ...........................................
13.1.1 Features .......................................................................
13.1.2 Überblick über die Benutzerschnittstelle ....................................
13.1.3 Das Datenmodell .............................................................
LINQ to SQL und die Datenzugriffsschicht ...........................................
13.2.1 Auffrischungskurs zur traditionellen 3-Schichten-Architektur .............
13.2.2 Brauchen wir eine extra Datenzugriffsschicht oder genügt LINQ to SQL?
13.2.3 Beispielanwendungen von LINQ to SQL in LinqBooks ....................
Einsatz von LINQ to XML ............................................................
13.3.1 Datenimport von Amazon ....................................................
13.3.2 Generieren von RSS-Feeds ..................................................
465
465
466
468
469
469
471
476
483
483
485
13
Inhaltsverzeichnis
13.4
13.5
13.6
13.7
13.8
Einsatz von LINQ to DataSet ..........................................................
Einsatz von LINQ to Objects ..........................................................
Erweiterbarkeit .........................................................................
13.6.1 Benutzerspezifische Abfrageoperatoren .....................................
13.6.2 Erzeugen und Verwenden benutzerspezifischer LINQ-Provider ...........
Ein Blick in die Zukunft ...............................................................
13.7.1 Kundenspezifische LINQ-Flavours ..........................................
13.7.2 LINQ to XSD – das typisierte LINQ to XML ...............................
13.7.3 PLINQ: LINQ und Parallel Computing .....................................
13.7.4 LINQ to Entities – LINQ für das ADO.NET Entity Framework ...........
Zusammenfassung .....................................................................
14 Arbeiten mit LINQ to DataSet
14.1
14.2
14.3
14.4
14.5
14.6
14.7
14.8
486
489
490
490
491
491
492
493
494
494
495
..........................................................
497
Übersicht zu LINQ to DataSet .........................................................
Kleiner Auffrischungskurs zu DataSets ...............................................
14.2.1 Anwendungsfälle und Features ..............................................
14.2.2 Was sind DataSets? ..........................................................
14.2.3 Änderungen in .NET 3.5 für LINQ to DataSet ..............................
Abfrage untypisierter DataSets ........................................................
14.3.1 Daten in DataSets laden ......................................................
14.3.2 Abfragen von DataSets ohne LINQ .........................................
14.3.3 Abfragen untypisierter DataSets mit LINQ to DataSet .....................
Abfrage typisierter DataSets ...........................................................
14.4.1 Ein typisiertes DataSet erzeugen ............................................
14.4.2 Daten in ein typisiertes DataSet laden .......................................
14.4.3 Abfragen typisierter DataSets mit LINQ to DataSet ........................
Binden der Abfrageergebnisse an die Steuerelemente ................................
14.5.1 Verwendung von CopyToDataTable .........................................
14.5.2 Zwei-Wege-Datenbindung mit AsDataView ................................
Verwendung der Abfrageoperatoren ...................................................
14.6.1 Field<T>- und SetField<T>-Operatoren für DataRows ....................
Set-Operatoren und DataRow-Vergleich ..............................................
Zusammenfassung .....................................................................
497
498
498
499
503
503
504
508
509
514
515
518
520
523
523
526
528
528
529
531
14
Inhaltsverzeichnis
Anhang
A Die Standard-Abfrageoperatoren
.....................................................
535
..................................................................
539
..........................................................................................
543
B Weitere Informationen
Index
1
Einführung in LINQ
Kapitel
1
Einführung in LINQ
Software ist eigentlich eine simple Sache, sie lässt sich auf zwei Dinge reduzieren: Code und
Daten. Das Entwickeln von Software ist allerdings nicht mehr ganz so einfach, hauptsächlich muss
man dabei Code schreiben, der sich mit Daten beschäftigt.
Für das Schreiben von Code können wir zwischen einer Vielzahl von Programmiersprachen
wählen. Welche Sprache wir nehmen, hängt von der Aufgabenstellung, unseren Vorlieben, von den
Fähigkeiten des Entwickler-Teams, vom Betriebssystem oder von Firmenrichtlinien ab.
Egal für welche Sprache Sie sich letztendlich entscheiden, ab einem bestimmten Punkt müssen Sie
damit auf Daten zugreifen. Diese Daten können in Dateien, Datenbanktabellen oder XML-Dokumenten enthalten sein, oder sie können aus dem Web stammen. Häufig handelt es sich aber um eine
Kombination dieser verschiedenen Datenquellen. Das Verwalten von Daten ist eine ultimative
Anforderung eines jeden Software-Projekts, mit dem Sie es zu tun haben.
Da das Verwalten von Daten zu den allgemeinen Aufgaben eines jeden Software-Entwicklers
gehört, erwarten wir von entsprechenden Entwicklungsplattformen, wie dem .NET Framework,
dass sie uns bei der Lösung dieser Aufgabe behilflich sind. In .NET wurde mittlerweile eine tiefere
Integration von Sprache und Daten erreicht. Wir meinen damit LINQ to Objects, LINQ to XML
und LINQ to SQL.
Die Technologien, die wir Ihnen in diesem Buch präsentieren, offerieren einen neuen Weg zum
Schreiben von Code. Da dieses Buch von Programmierern für Programmierer geschrieben wurde,
können Sie unbesorgt sein: Sie werden nicht lange auf Ihre ersten Zeilen LINQ-Code warten müssen! In diesem Kapitel werden wir schnell die obligatorischen "Hello World"-Codefragmente hinter
uns lassen und Sie darauf einstimmen, was Sie im Rest des Buchs erwartet. Unser Ziel ist es, dass
Sie es am Ende des Buchs kaum erwarten können, reale Projekte in Angriff zu nehmen, weil Sie
davon überzeugt sind, dass das Arbeiten mit LINQ Spaß macht.
Absicht dieses ersten Kapitels ist es, Ihnen eine Übersicht zu vermitteln und Ihnen zu zeigen, unter
welchen Bedingungen Sie LINQ einsetzen können. Wir beginnen mit einem Überblick über LINQ
und die verschiedenen LINQ-Werkzeuge, welche LINQ to Objects, LINQ to XML und LINQ to
SQL umfassen. Dann vermitteln wir Ihnen einige Hintergrundinformationen, damit Sie verstehen,
warum wir LINQ brauchen und woher es kommt. In der zweiten Hälfte dieses Kapitels werden wir
Sie bei Ihren ersten Schritten beim Schreiben von LINQ-Code begleiten.
28
1 Einführung in LINQ
1.1 Was ist LINQ?
Nehmen wir mal an, Sie schreiben gerade eine .NET-Anwendung. Die Wahrscheinlichkeit ist hoch,
dass Sie an einer bestimmten Stelle Objekte in einer Datenbank abspeichern, die Datenbank abfragen und die Ergebnisse zurück in die Objekte laden müssen. Das Problem ist, dass sich in den
meisten Fällen – zumindest bei relationalen Datenbanken – eine tiefe Kluft zwischen Ihrer Programmiersprache und der Datenbank auftut. Es wurden viele gut gemeinte Versuche mit objektorientierte Datenbanken unternommen, da diese näher an objektorientierten Plattformen und an
Programmiersprachen wie C# und VB.NET angesiedelt sind. Trotzdem, auch heute sind relationale
Datenbanken immer noch dominierend, und Sie haben in Ihren Programmen nach wie vor mit den
Problemen der Inkonsistenz beim objektorientierten Datenzugriff und bei der Datenpersistenz zu
kämpfen.
Die ursprüngliche Motivation für LINQ zielte auf die konzeptionellen und technischen Schwierigkeiten, wie sie beim Datenbankzugriff mit .NET-Programmiersprachen auftreten. Mit LINQ wollte
Microsoft das Problem des objektrelationalen Mappings lösen und die Interaktion zwischen Objekten und Datenquellen vereinfachen. LINQ entwickelte sich zu einer allgemein verwendbaren,
direkt in die Sprache integrierten Sammlung von Abfragewerkzeugen. Diese Werkzeugsammlung
kann benutzt werden um auf Daten zuzugreifen, die von Objekten aus dem Arbeitsspeicher (LINQ
to Objects), aus Datenbanken (LINQ to SQL), aus XML Dokumenten (LINQ to XML), aus dem
Dateisystem oder aus irgendeiner anderen Quelle kommen.
Zunächst geben wir Ihnen einen Überblick über die LINQ-Philosophie, danach betrachten wir die
Werkzeuge, die uns LINQ zur Verfügung stellt. Außerdem lernen Sie das Prinzip kennen, wie
LINQ vorhandene Programmiersprachen erweitert.
1.1.1 Ein Überblick
LINQ soll die bislang vermisste Verbindung zwischen der Welt der Daten und der Welt der Programmiersprachen herstellen. LINQ vereinheitlicht den Datenzugriff – egal um welche Datenquelle es sich handelt – und erlaubt das Mixen von Daten aus unterschiedlichen Quellen. Es
ermöglicht Abfrage- und Aktualisierungsoperationen, die den SQL-Anweisungen für Datenbanken
ähneln. LINQ integriert mittels einer Reihe von Spracherweiterungen diese Abfragen direkt in
.NET-Sprachen wie C# und Visual Basic: LINQ bedeutet Language-INtegrated Query.
In der Zeit vor LINQ mussten Sie innerhalb C# oder VB.NET mit anderen Sprachen wie SQL,
XML oder XPath jonglieren, zusammen mit verschiedenen Technologien und APIs, wie ADO.NET
oder System.Xml. Es versteht sich, dass diese Vorgehensweise bestimmte Nachteile mit sich
brachte1. LINQ führt verschiedene Welten zusammen. Es hilft Ihnen, die Hindernisse zu umgehen,
die auf der Verbindungsstraße zwischen diesen Welten liegen. Das Zusammenführen von XML mit
Objekten, von Objekten mit relationalen Daten und von relationalen Daten mit XML sind einige
der Aufgaben, die LINQ deutlich vereinfacht.
1
"Es war so, als würden Sie Ihre Speisen in der einen und Ihre Getränke in der anderen Sprache bestellen" sagte Jason
McConnell, der Produktmanager für Visual Studio bei Microsoft. "Der direkte Nutzen ist der, dass die Programmierer
produktiver werden, weil sie nun einen einheitlichen Zugang für das Abfragen und Aktualisieren von Daten innerhalb
ihrer Programmiersprache haben."
1.1 Was ist LINQ?
29
Einer der Schlüsselaspekte von LINQ ist der, dass es für jeden beliebigen Objekttyp und für jede
beliebige Datenquelle mit dem Ziel konzipiert wurde, ein konsistentes Programmiermodell zur Verfügung zu stellen. Unabhängig von den verschiedenen Anwendungsmöglichkeiten bleiben Syntax
und Konzept dieselben: Wenn Sie wissen, wie man LINQ auf ein Array oder eine Collection
anwendet, dann kennen Sie auch die Konzepte, mit denen man mit LINQ auf eine Datenbank oder
eine XML-Datei zugreift.
Ein weiterer wichtiger Aspekt ist der, dass Sie mit LINQ in einer streng typisierten Welt arbeiten.
Die damit verbundenen Vorteile sind die, dass Ihre Abfragen bereits beim Kompilieren geprüft
werden und dass Sie bei deren Entwurf von Visual Studios Intellisense profitieren.
LINQ wird einige Aspekte Ihres bislang gewohnten Umgangs mit Daten in Ihren Applikationen
und Komponenten grundlegend ändern. Sie werden selbst bald feststellen, dass LINQ einen Schritt
vorwärts in die Richtung eines mehr deklarativen Programmiermodells bedeutet. Möglicherweise
wundern Sie sich auch darüber, warum Sie bislang so viele Zeilen Code für etwas geschrieben
haben, was sich mit LINQ in einer einzigen Zeile unterbringen lässt.
LINQ hat dualen Charakter. Sie können sich LINQ so vorstellen, als würde es aus zwei komplementären Teilen bestehen: eine Sammlung von Werkzeugen für das Arbeiten mit Daten und eine
Menge von Spracherweiterungen.
Zuerst werden wie Ihnen LINQ als Werkzeugsammlung für das Arbeiten mit Objekten, XMLDokumenten, relationalen Datenbanken oder anderen Arten von Daten vorstellen. Danach werden
Sie sehen, dass LINQ außerdem eine Erweiterung für bereits existierende Programmiersprachen,
wie C# und VB.NET, ist.
1.1.2 LINQ als Werkzeugsammlung
LINQ bietet Ihnen zahlreiche Möglichkeiten. In diesem Buch werden wir detailliert auf drei grundlegende LINQ-Provider eingehen – LINQ to Objects, LINQ to SQL und LINQ to XML. Genauer
tun wir das in den Teilen 2, 3 und 4. Diese drei LINQ-Provider bilden eine Familie von Werkzeugen, die einerseits separat für spezielle Aufgaben eingesetzt werden können, andererseits aber auch
zu leistungsfähigen Lösungen kombinierbar sind.
Obwohl wir uns in diesem Buch auf LINQ to Objects, LINQ to SQL und LINQ to XML konzentrieren, ist LINQ offen für neue Datenquellen. Die drei grundlegenden LINQ-Provider, wie sie
Gegenstand dieses Buchs sind, entstanden auf Basis der allgemeinen LINQ Foundation. Diese
besteht aus einer Menge von Bausteinen, wie Abfrageoperatoren, Abfrageausdrücke und Ausdrucks-Bäume (expression trees), die eine Erweiterbarkeit des LINQ-Toolsets ermöglichen.
Weitere LINQ-Varianten können für andere Arten von Daten erzeugt werden. Neue LINQ-Implementierungen werden nicht nur von Software-Herstellern entwickelt, auch Sie selbst können eigene
LINQ-Varianten kreieren (siehe Kapitel 12, LINQ-Erweiterungen). Sie können eine breite Vielfalt
von Datenquellen mit LINQ in Verbindung bringen, wie beispielsweise das Dateisystem, Active
Directory, WMI, das Windows Ereignisprotokoll oder irgendeine andere Datenquelle oder API.
Das ist exzellent, weil Sie von den LINQ-Features täglich profitieren können, egal mit welcher
Datenquelle Sie es gerade zu tun haben. Tatsächlich bietet Microsoft heute bereits mehr LINQ-
30
1 Einführung in LINQ
Provider an, als LINQ to Objects, LINQ to SQL und LINQ to XML. Zwei davon sind LINQ to
DataSet und LINQ to Entities (für die Arbeit mit dem neuen ADO.NET Entity Framework). Wir
werden diese Tools im zweiten und dritten Teil dieses Buchs besprechen. Doch zunächst sollten Sie
Ihre Aufmerksamkeit auf die folgende Abbildung richten.
Abbildung 1.1 LINQ-Konstrukte, LINQ-Provider und Datenquellen, die mit LINQ abgefragt werden können
Die LINQ-Provider in Abbildung 1.1 sind keine für sich allein stehenden Tools, sie können direkt
in Ihre Programmiersprache eingebunden werden. Dies ist möglich, weil das LINQ-Framework
eine Menge von Spracherweiterungen umfasst. Diesem zweiten Aspekt von LINQ werden wir uns
im nächsten Abschnitt widmen.
1.1.3 LINQ als Spracherweiterung
LINQ ermöglicht es Ihnen, in einer Programmiersprache Ihrer Wahl Abfragen für verschiedenste
Datenquellen zu schreiben und bietet dabei dieselben Fähigkeiten wie SQL. Das ist einfach großartig, denn dieser deklarative Ansatz erlaubt kürzeren und prägnanteren Code.
Listing 1.1 zeigt LINQ-Beispielcode in C#.
Listing 1.1
Abfrage einer Datenbank und Erzeugen eines XML-Dokuments mit LINQ
Customers aus der Datenbank lesen:
var contacts =
from customer in db.Customers
where customer.Name.StartsWith("A") && customer.Orders.Count > 0
orderby customer.Name
select new { customer.Name, customer.Phone };
C#
1.1 Was ist LINQ?
31
XML-Daten aus der Customers-Liste generieren:
var xml =
new XElement("contacts",
from contact in contacts
select new XElement("contact",
new XAttribute("name", contact.Name),
new XAttribute("phone", contact.Phone)
)
);
Das Listing zeigt alles was Sie brauchen, um Daten aus einer Datenbank zu extrahieren und daraus
ein XML-Dokument zu erzeugen. Stellen Sie sich einmal vor, wie Sie dasselbe Problem ohne
LINQ lösen würden, und Sie werden erkennen, dass es mit LINQ viel einfacher und natürlicher
geht. In Kürze werden Sie noch mehr LINQ Abfragen kennen lernen, jetzt aber wollen wir unseren
Fokus auf die sprachlichen Aspekte richten. Aus den from-, where-, orderby- und select-Schlüsselwörtern im obigen Listing geht klar hervor, dass die Sprache C# mit LINQ-Fähigkeiten erweitert
wurde.
Wir haben Ihnen gerade Code gezeigt, der in C# geschrieben wurde, aber LINQ stellt eine allgemeine Abfrage-Architektur für alle .NET-Programmiersprachen zur Verfügung. Das funktioniert
mit C# 3.0 und mit VB.NET 9.0 (VB 2008). Der Code erfordert allerdings angepasste Compiler,
kann aber nach anderen .NET Sprachen portiert werden. Dies ist bereits der Fall für F#, eine funktionelle .NET-Sprache von Microsoft Research, in Zukunft ist LINQ-Support für weitere .NETSprachen zu erwarten.
Abbildung 1.2 LINQ als Spracherweiterung und als ein Gateway zu verschiedensten Datenquellen
Index
Index
.NET Framework-Support 45
.NET Reflector 94
1:1-Beziehungen 256
3-Schichten-Architektur 469
A
Abfrageausdrücke 115, 264
Abfragen zur Laufzeit 195
Abfrageoperatoren 111, 528
Achseneigenschaften 360
Action 127
Active Directory 492
Add 341
AddAfterSelf 326, 341
AddAnnotation 325
AddBeforeSelf 326, 341
AddFirst 326, 341
AddWithValue 33
ADO.NET 221
ADO.NET Entity Framework 494
ADO.NET-API 40
Aggregat-Operatoren 161
Aggregate 114
Aggregation 114, 236
All 114, 118, 241
Amazon 483
Amazon.com-Webdienst 457
AmazonBook 456
AmazonBookExpressionVisitor 452, 463
AmazonBookSearch 458
AmazonHelper 456
AmazonHelper.cs 457
Ancestors 326, 357
AncestorsAndSelf 326, 357
Änderungen durchführen 271
Änderungen verfolgen 270
Annotation 326
Annotations 326
Anonyme Methoden 65, 78
Anonyme Typen 93
ANSI-82 SQL-Syntax 237
ANSI-92 SQL-Syntax 237
Any 114, 118, 241
Array 137
AsDataView 526
AsEnumerable 114
ASP.NET 142
ASP.NET-Session 487
ASP.NET-Website 142
AsQueryable 114
Association 241, 252
Association-Attribut 256
Attach 274
Attribute 345, 352
Attribute-Achseneigenschaft 363
AuditTracking 292
Ausdrucksbäume 65, 266
Author 133
Author.aspx.cs 482
AutoSync 253
Average 114, 118
544
Index
B
Base Class Discriminator 307
Basis-Abfrageausdrücke 436
Basisklasse 305
Bedingungsabhängige Abfragen 192
BeginTransaction 285
Beispielanwendung 131
Benutzerdefinierte Funktionen 296
Benutzerdefinierte Sortierung 189
Benutzerspezifische Abfrageoperatoren 429, 490
Beziehungen 522
Book 133
Books 434
Books.aspx.cs 480
C
C-Omega-Sprache 43
C# 46
CanBeNull 253
Cast 114, 118, 182
catch 282
ChangeConflictException 280, 281
CheckRules 303
Child-Achseneigenschaft 361
CiteSeer 492
Client 222
Collection-Initialisierer 73
Column 225, 252
Column-Attribut 253
CompiledQuery.Compile 300
CommandText 33
Compiler 45
Concat 114
Concatenation 114
Conceptual Schema Definition Language 312
Console 228
Constant 267
Constraint 500
Contains 114, 233, 448
Content 332
Content einfügen 340
Content löschen 342
ContinueOnConflict 282, 285
Conversion 114
CopyToDataTable 507, 523
Count 114, 118, 162, 168
CreateCommand 33
CreateDatabase 254
CreateMethodCallQuery<T> 299
CreateNavigator 371
CreateQuery 265
CreateWriter 376
Cross Join 172, 238
CRUD 226, 292
CSDL 312
CSV 198, 417
CustomImplementation 440
CustomSort 190
CȦ 43
D
DAL 470, 473
DataLoadOptions 246
DataAdapter 504
Database 252
DataBind 145, 177
DataColumn 500
DataContext 60, 227
DataGridView 505, 523
DataList 142, 145
DataRelation 500
DataRow 500, 510, 528
DataRow-Vergleich 529
DataRowComparer 529
DataSet 486, 497, 498
DataSet-Designer 516
DataSource 144, 505
DataTable 500
DataTable.Select 508
DataTables verknüpfen 512
DataView 509, 526
Daten lesen 288
Datenbankschema 134
Datenbanksystem 221
Datenbankzugriff 33
Datenbindung 142, 149
545
Index
Datenentitäten 471
Datenimport 483
Datenmapping 225
Datenmodell 468
Datenzugriffsschicht 469, 470
DateTime.Parse 234
DB_Linq 492
DBML-Datei 263
DbType 254
DefaultIfEmpty 114, 155, 238
deferred query execution 243
Deklaratives Modell 52
Delegates 76
DeleteOnNull 256
DeleteOnSubmit 248
DeleteRule 256
Derived Class Discriminator 307
DescendantAndSelf 326
Descendants 326, 355
Descendants-Achseneigenschaft 362
DescendantsAndSelf 355
descending 234
Design Pattern 200
Dictionary 139, 140
Discriminator Property 307
Distinct 114, 118, 159, 529
Document Type Definition 322
Dokument-zentriert 52
DOM 40, 320
domänenspezifische Operatoren 443
DropDownList 145
DTD 322
Dynamische Abfragen 187
E
EDM 311
EF 312
Eigenschaftendeklaration 225
Eingebettete Abfragen 164
Einschränkungen 120
Einschränkungs-Operator 155
Element 114, 326, 352
Element-zentriert 52
ElementAt 114, 362
ElementAtOrDefault 114
Elements 326, 354
ElementsAfterSelf 326, 359
ElementsBeforeSelf 326, 359
Empty 114, 155
EndsWith 233
Entitäten 269
Entity Data Model 311
Entity-Klassen 59
Entity-Relationship 311
EntitySpaces 493
Entwurfsmuster 200
Entwurfsziele 42
Enumerable.Where 440
Enumerable.Select 440
Equality 114
ErrorProvider 303
Erste Schritte 51
Erweiterbarkeit 490
Erweiterungsmechnismen 426
Erweiterungsmethoden 84
Escape-Sequenz 199
Except 114, 529
Execute 265
ExecuteMethodCall 290
ExecuteQuery 287
ExecuteReader 33
Expression Tree 196
Expression 127, 254, 265
Expression Trees 122
Extension Indexer 362
F
FailOnFirstConflict 282
Fehlanpassung 35
Field 510
Field<T> 528
Fill 505
Filtering 114
Filtern 232, 366
First 114
FirstOrDefault 114
Flickr 492
ForEach-Pattern 203
546
Index
Format 287
Framework 45
Fremdschlüssel 306
FromReader 259
FromStream 259
FromUrl 259
FromXml 259
Func 127
Function 252
Functional Construction Pattern 57
Funktionale Konstruktion 200, 321
G
Generation 114
Generics 67, 182
Generische Dictionaries 139
Generische Listen 138
Genome 493
Geschäfts-Entitäten 133
Geschäftsebene 300, 469
Geschäftsentität 311
Geschäftslogik 301
Gespeicherte Prozeduren 288, 292
GetChildRows 513
GetCurrentMethod 290
GetParentRow 513
GetParentRows 513
GetProcesses 66, 67
GetQueryText 462
GetStringValue 343
GetTable 228
Google Desktop 492
Google Groups 492
Google Image 492
GreaterThan 267
GridView 142
group 167, 185
GroupBy 114, 119
Grouping 114
GroupJoin 114, 119
Gruppieren 93, 167, 184, 234, 368
Gruppierungs Join 169
GUI-Bindung 523
H
Hello LINQ 47, 53
I
IDataErrorInfo 302
IEnumerable 341
IEnumerable<T> 104
IExecuteResult 291
IGrouping 168
Imperatives Modell 52
Implizit typisierte Variablen 69
Import-Operation 486
In-Memory-Collection 136
In-Memory-Datenbank 497, 499
Index 158
Inhalte ändern 343
Inheritance Default 307
InheritanceMapping 252
Inline-Attribute 252
Inner Join 170, 242
InsertOnSubmit 248, 274
Intersect 114, 529, 530
into 185
IQueryable 125, 264, 458
IQueryable<T> 228
IQueryProvider 458
IsComposable 298
IsDbGenerated 254
IsDiscriminator 308
IsDiscriminator 254
IsExpensive 435
IsForeignKey 256
ISingleResult<T> 291
IsPrimaryKey 226, 254
IsUnique 256
IsVersion 254
Iterator Pattern 105
Iteratoren 65, 105
547
Index
J
Join 114, 119
Joining 237
Joins 168
K
KeepChanges 282
KeepCurrentValues 282
Klassendefinition 301
Klassendiagramm 133
Kollision von Abfrageausdrücken 442
Kompilierte Abfragen 300
Konfliktbehandlung 285
Konkurrenz-Ausnahmen 281
Konvertierungsoperatoren 160
L
Lambda 267
Lambda-Ausdrücke 76, 78
Lambda-Kalkül 76
Lambda-Operator 80
Last 114
LastOrDefault 114
lazy loading 243
Lebenszyklus 269, 313
Left Outer Join 171
LIKE 233
LINQ 28
LINQ to Amazon 447
LINQ to DataSet 486, 497
LINQ to Entities 310, 427, 493, 494
LINQ to Objects 45, 131, 489
LINQ to SQL 58, 221
LINQ to SQL-Designer 252, 262
LINQ to Text Files 197
LINQ to XML 51, 317, 483
LINQ to XSD 493
LINQ-DLLs 126
LINQ-Erweiterung 428
LINQ-Flavours 426
LINQ-Foundation 103
LINQ-Konstrukte 30
LINQ-Projekt 42
LINQ-Provider 30, 447, 491
LinqBooks 131
LinqBooks-Applikation 465
LinqBooksDataSet 515
LinqDataSource 145
LinqInAction.Extensibility 440
List 139
Listenanzeige 145
LLBLGen Pro 493
Load 326, 328
LoadOptions 328
LoadSequence 507, 520
Log 228
Logische Schicht 469
lokale Namen 322
LongCount 114, 119
LongSum 429
M
Mapping 36, 225, 251
Mapping Schema Language 312
Max 114, 119, 162, 168
Mehrfachkriterien 184
Mehrschichtarchitektur 471
Metadaten 300
MetaLinq 492
MethodInfo 290
MethodInvoker 81
Min 114, 119, 162, 168, 434
MSL 312
Muster für Abfrageausdrücke 438
MySql 492
N
Name 254, 256
Namenlose Typen 93
Namensräume 126
Namespace-Kollision 442
Namespace-Präfixe 322, 334
Netzwerkbelastung 222
Neuimplementierung 436
NHibernate 38, 492
nichtgenerische Collection 182
Nodes 326
548
Index
NodesBeforeSelf 359
NodesAfterSelf 326, 359
NodesBeforeSelf 326
Non-Sequence Operator 445
O
O/R-Mapper 251
ObjectDumper 67, 137, 244
ObjectSpaces 42, 44
ObjectTrackingEnabled 273
Objekt-XML-Mapping 39
Objektbäume 240, 385
Objektdefinitionen 133
Objektgraph 162
Objekthierarchie 240
Objektinitialisierer 72
Objektmodell 133
Objektrelationales Mapping 36
OfType 114, 184
OleDbDataAdapter 505
Optimistische Konkurrenz 278
Oracle 492
OracleDataAdapter 505
ORDER BY 234
orderby 114, 119, 163, 234
OrderByDescending 87, 114, 119, 163
OrderedSequence 189
Ordering 114
OtherKey 256
Outer Join 238, 241
Output-Stream 228
OverflowException 429
Overhead 213
OverwriteCurrentValues 282
P
Paging 174
Paradigmenunterschiede 37
Parallel Computing 494
Parameter 252, 267
Parametrierte Abfragen 187
Parent 326, 351
Parse 326
Parsen 199
Partielle Klassen 301
Partielle Methoden 303
Partitionieren 174
Partitioning 114
Performance 205, 210
PerformWebQuery 457
Pessimistische Konkurrenz 278
Pipeline 90
Pipeline-Pattern 126
Platzhalter 336
PLINQ 494
POCO 471
PostgreSQL 492
Präsentationsschicht 469
Predicate<T> 77
PreserveWhitespace 328
Process 67
ProcessData 69
ProcessExpression 453
processing instructions 322
ProcessName 67
Projection 114
Projektion 365
Projektions-Operator 156
Property 267
Protokollfunktion 228
Provider 252
Proxy 290
Publisher 133
Publishers.aspx.cs 477
Q
qualifizierte Namen 322
Quantifiers 114
Query Visualizer 228
QueryProvider 462
R
RAD 471, 472
Range 114, 155
RDF 492
ReadAllLines 198
549
Index
RefreshMode 281, 282
Relationale Daten 251
Relationen 513
remote evaluation 447
Remove 342
RemoveAttributes 326
RemoveAll 326
RemoveAnnotation 325
RemoveNodes 326
Repeat 114, 155
Repeater 142
ReplaceNodes 326, 343
ReplaceWith 344
ResultType 253
ReturnAGeneric 96
Reverse 114, 209
Review 133
RowVersion 280
RSS-Feed 328, 385
RSS-Feeds 485
S
Save 326
Select 114, 119, 156, 365
SelectedIndex 177
SelectedValue 177
SelectMany 114, 119, 157
SequenceEqual 114, 155
Sequenz 103
Set 114
SetBaseUri 328
Set-Operatoren 529
SetAttributeValue 326, 345
SetElementValue 326, 343
SetField<T> 528
SetLineInfo 328
SharePoint 492
Silverlight-Runtime 46
Simultane Änderungen 277
Single 114
SingleOrDefault 114
Skip 114, 119, 176, 230
SkipWhile 114, 119
Slinq 492
Software 45
SortedDictionary 139
SortedList 139
Sortieren 234, 368
Sortierschlüssel 189
Sortierung 162
Sperrmechanismus 278
Split 198, 201
Spracherweiterung 30
Spracherweiterungen 65, 101
SQL 223
SQL pass-through 287
SQL Server 221
SQL Server 2005 46
SQL Server Profiler 228
SqlDataSource 472
SQL-Filteroption 233
SqlConnection 33
SqlDataReader 33
SqlMetal 252, 259
SqlMetal.exe 393
SQLXML 40
SSDL 312
Standard-Abfrageoperatoren 87, 114, 154, 363
StartsWith 233
stdin 90
stdout 90
Storage 254, 256
Store Schema Definition Language 312
Streaming-Strategie 206
StreamReader 206
String 140
Subject 133
SubmitChanges 247, 271
Sum 89, 114, 119, 162, 168
SybaseDataAdapter 505
SyncLINQ 492
System.Predicate<T> 81
System.Action<T> 81
System.Collections.Generic 66
System.Collections.Generic.HashSet<T> 138
System.Collections.Generic.LinkedList<T> 138
System.Collections.Generic.List<T> 138
System.Collections.Generic.Queue<T> 138
System.Collections.Generic.Stack<T> 138
550
Index
System.Collections.ObjectModel.Collection<T> 138
System.ComponentModel.BindingList<T> 138
System.Converter<TInput, TOutput> 81
System.Core.dll 127
System.Data 500
System.Data.DataSet 500
System.Data.Linq.dll 127
System.Data.Linq.Mapping 127
System.Data.Linq.XmlMappingSource 259
System.Data.TypedTableBase 503
System.Diagnostics 66
System.Enumerable.Linq.Join 238
System.Linq 126
System.Linq.Expressions 127
System.Transactions 285
System.Xml.Linq 46, 127
System.Xml.Linq.dll 127
System.Xml.Schema 127
System.Xml.XPath 127, 371
System.Xml.Xsl 376
T
Table 253
Table-Attribut 253
TableAdapter 486, 518
TableMappings 505
Take 88, 114, 119, 176, 230
TakeWhile 114, 119
Textdatei 417
ThenBy 114, 119, 163
ThenByDescending 114, 119, 163
this 84
ThisKey 256
TimeStamp 275
Title 225
ToArray 114, 160, 245
ToDataTable 507
ToDictionary 114, 161, 245
ToList 114, 151, 160, 245
ToLookup 114, 245
ToString 234
TotalPrice 433, 490
Träges Laden 243
TransactionScope 285
Transaktion 284
try 282
Typisierte DataSets 501, 514
U
Übersetzungsmechanismus 437
Union 114, 529
Unterabfrage 211
Unterabfragen 246
Untypisiertes DataSet 503
UpdateCheck 254, 275, 280
User 133, 306
UserBase 306
V
Value 342
Value Extension 362
Vanatec OpenAccess 493
var 69
VB.NET 46
Verbindungslose Daten 274
Verbindungszeichenfolge 227
Vereinfachte Namen 322
Vererbung 305
Vererbungsmodell 310
verzögerte Ausführung 107, 125, 243
Visual Basic 2008 46
Visual C# 2008 46
W
W3C XML-Schema 39
Webanwendungen 142
What You See Is What You Mean 57
WhenChanged 280
WhenChanged 281
Where 111, 114, 119, 155, 187, 232, 237, 366
whitespaces 328
Windows Forms 142, 149
WmiLinq 492
WriteTo 326
WYSIWYM 57
551
Index
X
XAttribute 322, 326, 345
XCData 327
XComment 327, 329, 338, 340
XContainer 326
XDeclaration 327, 329, 338
XDocument 326, 337
XDocumentType 327, 329, 338, 339
XElement 322, 326, 338
XML erzeugen 331
XML laden 328
XML parsen 330
XML speichern 346
XML transformieren 373
XML verarbeiten 327
XML-Abfrage 51
XML-Achsen-Methoden 350
XML-API 317
XML-Baum 393
XML-Dokument 337, 486
XML-DOM 318
XML-Klassenhierarchie 325
XML-Literale 335
XML-Mapping-Datei 257
XmlMappingSource 259
XMLNamespaceManager 324
XmlReader 328
XmlWriter 326, 376
XName 322, 327
XNamespace 327
XNode 326
XObject 325
XPath 40, 318, 371
XPathEvaluate 371
XPathNavigators 371
XPathSelectElement 371
XPathSelectElements 371
XProcessingInstruction 327, 329, 338
XQuery 44, 318
XSD 40
XSL 40
XslCompiledTransform 376
XSLT 376
XStreamingElement 327
XText 327, 332
Z
Zuordnung 225
Zwei Wege-Datenbindung 526