Inhaltsverzeichnis
Vorwort
1
................................................................................
Erste Schritte
..........................................................................
Unsere Werkstatt ........................................................................
Betriebssystem .......................................................................
Visual Studio 2012 ...................................................................
Anforderungen an Hard- und Software ................................................
SQL Server oder LocalDB .............................................................
Microsoft Access .....................................................................
Visual Basic und die Datenbankprogrammierung ..........................................
Zur Geschichte des universellen Datenzugriffs .........................................
Merkmale webbasierter Anwendungen ................................................
Ein Wort zum .NET-Sicherheitskonzept ...............................................
Was ist neu in .NET 4.5/Visual Studio 2012? ...............................................
ADO.NET und SQL-Server ...........................................................
Die neue Visual Studio 2012 Entwicklungsumgebung ..................................
Neuheiten im .NET Framework 4.5 ...................................................
VB 2012 – Sprache und Compiler ....................................................
Ein wenig Datenbanktheorie .............................................................
Normalisieren von Tabellen ...........................................................
Verknüpfen von Tabellen .............................................................
Weitere wichtige Begriffe .............................................................
Einführungsbeispiele ....................................................................
1.1 ... auf eine lokale Access-Datenbank zugreifen? ...................................
1.2 ... mit dem SQL Server arbeiten? .................................................
1.3 ... eine einfache LINQ to SQL-Anwendung schreiben? .............................
1.4 ... eine einfache ASP.NET-Webanwendung entwickeln? ............................
1.5 ... meine erste WPF-Anwendung erstellen? .......................................
1.6 ... einen einfachen WCF-Dienst entwickeln? ......................................
Die Qual der Wahl ......................................................................
DataReader – der schnelle Lesezugriff .................................................
DataSet – die Datenbank im Hauptspeicher ............................................
Objektrelationales Mapping – die Zukunft? ............................................
Die Exoten ..........................................................................
2
Einführung in LINQ
....................................................................
Die LINQ-Philosophie ...................................................................
OOP-Modell versus relationales Modell ...............................................
Besonderheiten beim ORM ...........................................................
Ein erstes LINQ-Beispiel .............................................................
Der Weg zu LINQ ....................................................................
Die neuen Sprachfeatures ................................................................
Typinferenz ..........................................................................
Nullable-Typen ......................................................................
Objekt-Initialisierer ..................................................................
33
37
38
38
38
40
41
42
42
43
44
47
49
49
50
52
52
53
53
58
62
64
64
70
72
74
79
82
85
85
85
86
87
89
90
90
91
92
94
97
97
99
100
6
Inhaltsverzeichnis
3
Anonyme Typen .....................................................................
Erweiterungsmethoden ...............................................................
Lambda-Ausdrücke ..................................................................
Abfragen mit LINQ to Objects ...........................................................
Grundlegende Syntax ................................................................
Übersicht der wichtigsten Abfrageoperatoren ..........................................
Die Projektionsoperatoren Select und SelectMany ......................................
Der Restriktionsoperator Where ......................................................
Die Sortierungsoperatoren OrderBy und ThenBy ......................................
Der Gruppierungsoperator GroupBy ..................................................
Verknüpfen mit Join .................................................................
Aggregatoperatoren ..................................................................
Verzögertes Ausführen von LINQ-Abfragen ............................................
Konvertierungsmethoden .............................................................
Der Zuweisungsoperator Let ..........................................................
Abfragen mit PLINQ .................................................................
How-to-Beispiele ........................................................................
2.1 ... LINQ-Abfragen verstehen? ...................................................
2.2 ... nichtgenerische Collections abfragen? .........................................
2.3 ... Datenbankabfragen mit LINQ und ADO.NET vergleichen? .....................
101
102
103
106
106
108
110
112
112
114
115
116
118
118
119
120
123
123
125
128
ADO.NET-Grundlagen
131
132
132
133
136
136
137
137
138
139
142
143
143
144
145
147
148
149
149
150
150
151
151
154
156
157
157
158
.................................................................
Die wichtigsten Klassen in ADO.NET .....................................................
Klassenhierarchie ....................................................................
Die Klassen der Datenprovider ........................................................
Klassen im DataSet ...................................................................
Das Zusammenspiel der ADO.NET-Klassen ............................................
Das Connection-Objekt ..................................................................
Allgemeiner Aufbau ..................................................................
OleDbConnection ...................................................................
SqlConnection ......................................................................
Fehlerbehandlung beim Öffnen einer Verbindung ......................................
Schließen einer Verbindung ...........................................................
Verbindungspooling .................................................................
Transaktionen .......................................................................
Eigenschaften des Connection-Objekts ................................................
Methoden des Connection-Objekts ...................................................
Ereignisse des Connection-Objekts ....................................................
Der ConnectionStringBuilder .........................................................
ConnectionString in den Anwendungseinstellungen speichern ..........................
Das Command-Objekt ...................................................................
Erzeugen und Anwenden eines Command-Objekts .....................................
Erzeugen mittels CreateCommand-Methode ...........................................
Eigenschaften des Command-Objekts .................................................
Methoden des Command-Objekts ....................................................
Freigabe von Connection- und Command-Objekten ...................................
Parameter-Objekte ......................................................................
Erzeugen und Anwenden eines Parameter-Objekts .....................................
Eigenschaften des Parameter-Objekts ..................................................
Inhaltsverzeichnis
Das CommandBuilder-Objekt ............................................................
Erzeugen ............................................................................
Anwenden ...........................................................................
Einsatzbeschränkungen ..............................................................
Einige Regeln .......................................................................
Optimistisches Konkurrenzmodell ....................................................
Das DataReader-Objekt ..................................................................
DataReader erzeugen .................................................................
Daten lesen ..........................................................................
Eigenschaften des DataReaders ........................................................
Methoden des DataReaders ...........................................................
Das DataAdapter-Objekt .................................................................
DataAdapter erzeugen ................................................................
Command-Eigenschaften .............................................................
Fill-Methode ........................................................................
Update-Methode .....................................................................
UpdateCommand und Parameter-Objekte .............................................
InsertCommand und DeleteCommand ...............................................
MissingSchemaAction-Eigenschaft ....................................................
RowUpdating- und RowUpdated-Ereignis .............................................
Zugriff auf Excel-Arbeitsmappen .........................................................
Zugriffsmöglichkeiten ................................................................
OLE DB-Connectionstring ...........................................................
Zugriff auf Excel 2007/2010-Arbeitsmappen ...........................................
Neue Mappen erstellen ...............................................................
Daten in ein Tabellenblatt eintragen ...................................................
Daten aktualisieren ..................................................................
Daten auslesen .......................................................................
Zugriff auf Tabellenbereiche ..........................................................
OLE-Automation ....................................................................
Weitere Features des Datenzugriffs ........................................................
Auslesen von Datenbankschemas ......................................................
Providerfabriken .....................................................................
Task-orientierte asynchrone Programmierung .........................................
How-to-Beispiele ........................................................................
3.1 ... wichtige ADO.NET-Objekte schnell kennen lernen? ............................
3.2 ... eine Aktionsabfrage ausführen? ...............................................
3.3 ... Daten direkt zur Datenbank hinzufügen oder löschen? ..........................
3.4 ... eine Access-Auswahlabfrage ausführen? .......................................
3.5 ... parametrierte Abfragen ausführen? ............................................
3.6 ... die Datenbank aktualisieren? ..................................................
3.7 ... RowUpdating-/RowUpdated-Ereignisse verstehen? .............................
3.8 ... Schemainformationen von der Datenbank abrufen? ............................
3.9 ... einen Connectionstring verschlüsseln? .........................................
3.10 ... die neuen asynchronen Methoden nutzen? .....................................
3.11 ... eine klassische Datenzugriffsschicht entwickeln? ................................
Übersichten .............................................................................
Datentypen ..........................................................................
Connection-Objekt ..................................................................
7
159
159
160
160
161
161
162
162
162
163
164
164
164
165
166
167
168
170
172
173
175
175
176
177
178
179
180
180
182
183
185
185
186
187
189
189
191
193
196
198
201
206
208
211
214
217
222
222
223
8
Inhaltsverzeichnis
Command-Objekt ...................................................................
Parameter-Objekt ....................................................................
DataReader-Objekt ..................................................................
DataAdapter .........................................................................
CommandBuilder ....................................................................
4
Das DataSet-Objekt im Detail
.........................................................
Einführung .............................................................................
Das Objektmodell ....................................................................
Methoden zum Erzeugen eines DataSets ...............................................
Weitere wichtige Methoden des DataSets ..............................................
Die XML-Fähigkeiten des DataSets ....................................................
Das DataTable-Objekt ...................................................................
DataTable erzeugen ..................................................................
Spalten hinzufügen ..................................................................
Berechnete Spalten ...................................................................
Primärschlüssel ergänzen .............................................................
Einbinden von Constraints ...........................................................
Hinzufügen von Relationen ...........................................................
Zeilen zur DataTable hinzufügen ......................................................
Auf den Inhalt einer DataTable zugreifen ..............................................
Weitere Hinweise zum Bearbeiten von Zeilen ..........................................
Zeilen löschen .......................................................................
Zeilenstatus und Zeilenversion ........................................................
Ereignisse des DataTable-Objekts .....................................................
Datenansichten mit DataView ...........................................................
Erzeugen eines DataView .............................................................
Sortieren und Filtern von Datensätzen .................................................
Suchen von Datensätzen ..............................................................
Zeilenansicht mit DataRowView ......................................................
Weitere DataSet-Features ................................................................
Umwandlungen zwischen DataSet und DataReader ....................................
Binäre Serialisierung für DataSet/DataTable ............................................
Die DataTable kann mehr XML .......................................................
Schnelles Laden von DataSets .........................................................
Typisierte DataSets ......................................................................
Was ist ein typisiertes DataSet? ........................................................
Das Datenquellen-Konzept ...........................................................
Typisierte DataSets und TableAdapter .................................................
LINQ to DataSet ........................................................................
Untypisierte DataSets abfragen .......................................................
Typisierte DataSets abfragen ..........................................................
Abhängigkeiten zwischen den Tabellen auflösen ........................................
How-to-Beispiele ........................................................................
4.1 ... eine DataTable erzeugen und in einer Binärdatei speichern? .....................
4.2 ... eine DataTable in einer XML-Datei abspeichern? ...............................
4.3 ... Master-Detailbeziehungen im DataGrid anzeigen? ..............................
4.4 ... in einem DataView sortieren und filtern? ......................................
4.5 ... nach Datensätzen suchen? ....................................................
223
224
225
225
226
229
230
230
232
234
235
237
237
238
239
240
241
243
246
247
250
251
252
255
256
257
257
258
259
260
260
262
262
262
263
263
265
266
268
269
270
271
273
273
277
277
279
281
9
Inhaltsverzeichnis
5
4.6 ... vereinfacht nach Datensätzen suchen? .........................................
4.7 ... zwischen DataTable und DataReader umwandeln? ..............................
4.8 ... große Datenmengen in ein DataSet laden? .....................................
4.9 ... ein DataSet binär serialisieren? ................................................
4.10 ... ein DataSet in einen XML-String konvertieren? ................................
4.11 ... ein untypisiertes in ein typisiertes DataSet laden? ...............................
4.12 ... ein typisiertes DataSet mit LINQ abfragen? ....................................
4.13 ... mit LINQ to DataSet die Datenbank aktualisieren? .............................
Übersichten .............................................................................
DataSet .............................................................................
DataTable ...........................................................................
DataColumn ........................................................................
DataRow ............................................................................
DataView ............................................................................
283
285
287
289
291
296
300
302
305
305
306
307
308
309
Windows Forms-Datenbindung
311
312
313
316
317
318
318
319
319
319
319
320
321
321
322
323
323
324
326
328
329
331
334
335
336
336
336
340
346
347
353
358
361
366
.......................................................
Einführung .............................................................................
Manuelle Datenbindung an einfache Datenfelder .......................................
Manuelle Datenbindung an Listen und Tabelleninhalte .................................
Entwurfszeit-Datenbindung an ein typisiertes DataSet ..................................
Drag & Drop-Datenbindung .............................................................
Navigieren im DataSet ...................................................................
Vor- und Rückwärtsblättern ..........................................................
Hinzufügen und Löschen .............................................................
Aktualisieren und Abbrechen .........................................................
BindingNavigator ....................................................................
Die Anzeige formatieren .................................................................
Das DataGridView .......................................................................
Vom DataGrid zum DataGridView ....................................................
Grundlegende Datenbindung .........................................................
Standardmäßige Anzeige und Bedienung ..............................................
Wichtige Spalteneinstellungen ........................................................
Automatische Größenanpassungen ....................................................
Selektieren von Zellen ...............................................................
Columns- und Rows-Auflistungen ....................................................
DataGridViewCellStyle-Objekte ......................................................
Spaltentypen ........................................................................
Editieren im DataGridView ...........................................................
Fehlerbehandlung ....................................................................
Eingabeprüfung ......................................................................
How-to-Beispiele ........................................................................
5.1 ... eine Objekt-Datenquelle verwenden? ..........................................
5.2 ... Steuerelemente an einen Objektbaum binden? .................................
5.3 ... Detailinformationen mit ListBox/ComboBox anzeigen? .........................
5.4 ... Steuerelemente manuell an ein DataSet binden? ................................
5.5 ... zwei Formulare an eine Datenquelle binden? ...................................
5.6 ... mittels ComboBox zwei Tabellen verknüpfen? .................................
5.7 ... ein typisiertes DataSet manuell binden? ........................................
5.8 ... 1:n-Beziehungen per Drag & Drop-Datenbindung anzeigen? ....................
10
Inhaltsverzeichnis
5.9
5.10
5.11
5.12
5.13
5.14
6
... die Spalten im DataGridView formatieren? .....................................
... mit DataReader und ListView arbeiten? ........................................
... Bilder aus der Datenbank anzeigen? ...........................................
... das DataGridView als Datenbank-Frontend verwenden? ........................
... Datenbindung mit LINQ to SQL realisieren? ...................................
... den DataRepeater für die Anzeige verwenden? ..................................
Datenbindung – WPF
.................................................................
Grundprinzip ...........................................................................
Bindungsarten .......................................................................
Wann wird eigentlich die Quelle aktualisiert? ..........................................
Geht es auch etwas langsamer? ........................................................
Bindung zur Laufzeit realisieren .......................................................
Binden an Laufzeit-Objekte ..............................................................
Objekte im Code instanziieren ........................................................
DataContext – die universelle Alternative zur Source ...................................
Verwenden der Instanz im VB-Quellcode ..............................................
Aktive Datenbindung – Anforderungen an die Quell-Klasse .............................
Instanziieren von Objekten per VB-Code ..............................................
Datenbindung von Collections ...........................................................
Anforderung an die Collection ........................................................
Einfache Anzeige .....................................................................
Navigation zwischen den Objekten ...................................................
Einfache Anzeige in einer ListBox .....................................................
DataTemplates zur Anzeigeformatierung ..............................................
Mehr zu List- und ComboBox ........................................................
Verwendung der ListView ............................................................
Probleme mit der Datenübernahme ...................................................
Ein Blick hinter die Kulissen ..............................................................
Navigieren in den Daten ..............................................................
Sortieren ............................................................................
Filtern ...............................................................................
Gruppieren ..........................................................................
Live Shaping .........................................................................
Die Anzeige von Datenbankinhalten ......................................................
DataSet .............................................................................
LINQ to SQL ........................................................................
Entity Framework ....................................................................
Formatieren von Werten .................................................................
IValueConverter .....................................................................
BindingBase.StringFormat-Eigenschaft ................................................
Validieren von Nutzereingaben ...........................................................
Validieren per Daten – oder Geschäftsobjekt ...........................................
Den Fehler optisch darstellen .........................................................
Wann wird eigentlich validiert? .......................................................
ValidationRule – die Alternative .......................................................
Validierungsfehler per Ereignis auswerten .............................................
IDataErrorInfo ......................................................................
369
371
374
377
382
386
389
390
391
392
393
394
395
395
397
397
398
399
400
400
401
402
404
405
406
408
410
412
412
414
414
415
417
419
419
420
425
429
429
431
433
433
434
436
437
439
439
11
Inhaltsverzeichnis
7
Das DataGrid als Universalwerkzeug ......................................................
Grundlagen der Anzeige ..............................................................
Spalten selbst definieren ..............................................................
Vom Betrachten zum Editieren .......................................................
UI-Virtualisierung ...................................................................
How-to-Beispiele ........................................................................
6.1 ... Drag & Drop-Bindung für Master/Detail-Beziehungen umsetzen? ...............
6.2 ... Collections in Hintergrundthreads füllen? .....................................
6.3 ... das MVVM-Pattern am einfachen Beispiel verstehen? ...........................
6.4 ... mit Commands den MVVM-Code optimieren? ................................
6.5 ... mit MVVM und Collections arbeiten? .........................................
Tipps & Tricks ...........................................................................
Datenbindung von Null-Values .......................................................
Fallback-Values zuweisen .............................................................
Asynchrone Datenbindung von Einzelwerten ..........................................
Datenbindung an statische Werte .....................................................
Datenbindung an Settings ............................................................
441
441
442
445
445
445
445
449
452
456
459
464
464
465
465
466
466
Microsoft SQL Server-Einstieg
469
470
470
472
472
473
475
477
481
481
482
483
484
485
486
487
487
488
490
490
491
495
498
502
502
504
505
505
506
506
507
.........................................................
Übersicht ...............................................................................
SQL Server LocalDB .................................................................
SQL Server Express ..................................................................
SQL Server Compact .................................................................
Unterschiede SQL Server/SQL Server Express/LocalDB/Jet-Engine ......................
Client- versus Fileserver-Programmierung .............................................
Die wichtigsten Tools von SQL Server .................................................
Vordefinierte Datenbanken ...........................................................
Einschränkungen ....................................................................
Weitere SQL Server-Funktionen im Kurzüberblick .....................................
Zugriff aus Visual Basic ...............................................................
Einrichten der Anbindung (Assistent) .................................................
Einrichten der Verbindung (Quellcode) ...............................................
Datenbanken mit DMO verwalten ........................................................
SQL Server Management Objects (SMO) .................................................
Einbindung ..........................................................................
Einführungsbeispiel ..................................................................
Anmelden am Server .................................................................
Datensicherheit auf dem Microsoft SQL Server ............................................
Überblick Sicherheitsmodell ..........................................................
Verwalten mit dem SQL Server Management Studio ....................................
Verwalten mit T-SQL .................................................................
How-to-Beispiele ........................................................................
7.1 ... den Netzwerkzugriff für den SQL Server Express aktivieren? ....................
7.2 ... die SQL Server Express-Version erkennen? .....................................
7.3 ... die SQL Server Express-Version administrieren? ................................
7.4 ... alle Nutzer einer Datenbank ermitteln? ........................................
7.5 ... alle registrierten Microsoft SQL Server ermitteln? ..............................
7.6 ... alle Datenbanken und deren Tabellen ermitteln? ................................
7.7 ... eine Tabelle löschen? .........................................................
12
Inhaltsverzeichnis
7.8
7.9
7.10
7.11
7.12
7.13
7.14
7.15
7.16
7.17
7.18
7.19
7.20
7.21
7.22
7.23
7.24
7.25
7.26
8
... eine Tabelle mit den SMO erzeugen? ...........................................
... die Anzahl der Datensätze beschränken? .......................................
... Platzhalterzeichen in T-SQL verwenden? .......................................
... Teilstrings erzeugen? .........................................................
... Leerzeichen entfernen? .......................................................
... mit DROP INDEX jeden Index löschen? ......................................
... @@ERROR korrekt verarbeiten? ..............................................
... die Anzahl der Datensätze einer Abfrage bestimmen? ...........................
... mit Bedingungen Feldinhalte formatieren? .....................................
... Abfragen mit Platzhaltern beschleunigen? ......................................
... das Ergebnis einer Stored Procedure speichern? ................................
... eine Datenbank umbenennen? ................................................
... eine Datenbank zwischen Servern verschieben? .................................
... eine Datenbankstruktur kopieren? .............................................
... nach dem Löschen IDENTITY auf 0 setzen? ....................................
... eine Tabellenspalte umbenennen? .............................................
... Unterschiede zwischen temporären Tabellen erkennen? .........................
... Daten aus verschiedenen Datenbanken anzeigen? ...............................
... die PRINT-Anweisung in VB anzeigen? ........................................
Microsoft SQL Server-Programmierung
...............................................
Praktisches Arbeiten mit dem SQL Server .................................................
Erstellen von SQL Server-Datenbanken ................................................
Erzeugen und Verwalten von Tabellen .................................................
Datentypen ..........................................................................
Datenbankdiagramme ................................................................
Erzeugen und Verwenden von Sichten (Views) .........................................
Gespeicherte Prozeduren verwenden ..................................................
Table Value Parameters (TVP) ........................................................
Programmierung/Verwendung von Triggern ...........................................
Volltextabfragen .....................................................................
Die Verwendung von FileStream-Storage ..............................................
FileTable ............................................................................
Massenkopieren .....................................................................
Datenbanken sichern und wiederherstellen ............................................
Fehlerbehandlung .......................................................................
Das Fehlermodell ....................................................................
Verwenden von @@ERROR ...........................................................
Verwenden von RAISEERROR ........................................................
Fehlerbehandlung mit TRY...CATCH ..................................................
Fehlerbehandlung mit ADO.NET .....................................................
Weitere Features des Datenzugriffs unter ADO.NET .......................................
Alle verfügbaren SQL Server ermitteln .................................................
Klassische asynchrone Befehlsausführung ..............................................
Benachrichtigungen über Datenänderungen ...........................................
Multiple Active Resultsets (MARS) ....................................................
CLR-Integration im SQL Server ..........................................................
Grundsätzlicher Ablauf ...............................................................
CLR-Unterstützung aktivieren ........................................................
507
509
510
510
511
511
511
512
512
512
513
513
514
514
516
516
516
517
517
519
520
520
524
527
532
533
535
538
539
543
548
554
559
561
566
566
567
567
568
570
571
571
572
574
574
575
575
576
13
Inhaltsverzeichnis
9
Assembly erstellen ...................................................................
Ein erstes Beispiel ....................................................................
Benutzerdefinierte Funktionen (UDF) .................................................
Stored Procedures ....................................................................
Aggregat-Funktionen ................................................................
Trigger in VB realisieren ..............................................................
Mehr Sicherheit .....................................................................
Fazit ................................................................................
XML-Unterstützung .....................................................................
Der XML-Datentyp ..................................................................
XML-Daten mit SELECT erzeugen ....................................................
XML-Abfragen ......................................................................
Der Clientzugriff auf die XML-Daten .................................................
How-to-Beispiele ........................................................................
8.1 ... Aktualisierungs- und Löschweitergaben realisieren? ............................
8.2 ... Änderungen in Tabellen protokollieren? .......................................
8.3 ... SQL-Anweisungen debuggen? .................................................
8.4 ... ein SqlConnection-Objekt programmieren? ....................................
8.5 ... eine Gespeicherte Prozedur aufrufen? ..........................................
8.6 ... mit Table Value-Parametern arbeiten? .........................................
8.7 ... mit Stapel-Abfragen arbeiten? .................................................
8.8 ... Query Notifications einrichten und auswerten? ................................
8.9 ... die MARS-Technologie kennen lernen? ........................................
8.10 ... Row-Constructors verwenden? ................................................
576
579
581
582
588
590
591
592
592
593
594
598
600
603
603
603
604
606
609
612
614
616
620
624
SQL Server Compact
625
626
626
627
628
628
629
629
630
632
632
632
634
635
637
640
640
641
643
643
644
644
645
...................................................................
Einsatzszenarien .........................................................................
Einschränkungen ....................................................................
Die »tolle« neue Version 4.0 ...........................................................
Fähigkeiten/Vorteile ..................................................................
Installation ..............................................................................
Books Online ........................................................................
SQL Server Compact 3.5 SP2 .........................................................
SQL Server Compact Toolbox .........................................................
Weitere Downloads ..................................................................
Datenbanken erstellen, verwalten und einbinden ..........................................
Visual Studio ........................................................................
SQL Server Management Studio ......................................................
Codebasiert mit VB ..................................................................
Tabellen und Referenzen erstellen .....................................................
Zusammenarbeit mit dem DataSet ........................................................
Datenzugriff mit SqlCeResultSet ..........................................................
Datenbindung .......................................................................
Das ResultSet konfigurieren ..........................................................
Datensätze löschen ...................................................................
Datensätze einfügen ..................................................................
Datensätze bearbeiten ................................................................
Navigation zwischen den Datensätzen .................................................
14
Inhaltsverzeichnis
10
Zugriff mit LINQ to SQL ................................................................
Anbinden einer vorhandenen Datenbank ..............................................
Erstellen einer neue Datenbank .......................................................
Ergänzungen ........................................................................
Zugriff per Entity Data Model ............................................................
Der Einsatz als Local Database Cache .....................................................
Beispiel Einweg Synchronisation ......................................................
Bidirektionale Synchronisation .......................................................
Tipps & Tricks ...........................................................................
Migration von Version 3.5 auf 4.0 .....................................................
Datenbank auf Remotelaufwerk nutzen ................................................
Performance verbessern ..............................................................
Datenbank von schreibgeschütztem Medium starten ...................................
Datenbankinformationen abrufen .....................................................
Datenbank reparieren ................................................................
Datenbank komprimieren ............................................................
Die Datenbank nachträglich verschlüsseln .............................................
Ein Datenbank-Backup realisieren ....................................................
Fehler in der Visual Studio-IDE vermeiden ............................................
Distribution ........................................................................
Fazit ....................................................................................
646
646
648
649
649
650
650
653
657
657
658
658
659
659
660
661
662
662
662
662
664
SQLite – Ein Mini ganz groß
667
668
669
670
670
670
671
672
672
673
675
677
677
678
679
681
683
684
686
688
688
692
694
695
696
697
702
..........................................................
Was ist eigentlich SQLite? ................................................................
Vorteile .............................................................................
Nachteile ............................................................................
Vorbereitungen ..........................................................................
Download/Installation ...............................................................
Integration in Ihr VB-Projekt .........................................................
Datenbank-Tools ........................................................................
Verwalten von SQLite-Datenbanken mit Visual Studio ..................................
Database .NET .......................................................................
SQLite Administrator ................................................................
Praktische Aufgabenstellungen ...........................................................
Datenbank/Datenbankobjekte per Code erstellen .......................................
Mögliche Connectionstring-Parameter ................................................
Tabellen erzeugen ....................................................................
Datenbankzugriff per DataSet realisieren ..............................................
Besonderheit: InMemory-Datenbank ..................................................
Datenzugriff mit dem Entity Framework ..............................................
Die Bedeutung von Transaktionen bei SQLite ..........................................
SOUNDEX verwenden ...............................................................
Volltextabfragen realisieren ...........................................................
Eigene skalare Funktionen in VB realisieren ............................................
Eigene Aggregat-Funktionen in VB realisieren ..........................................
SQLite – die Datenbank für Windows Store Apps ..........................................
Installation in einem WinRT-Projekt ..................................................
Erstellen der Datenbank ..............................................................
Daten einfügen, lesen und abfragen ...................................................
15
Inhaltsverzeichnis
11
Tipps & Tricks ...........................................................................
Für Liebhaber der Kommandozeile – Sqlite3.exe .......................................
Eine SQLite-Datenbank reparieren ....................................................
Eine Beispieldatenbank herunterladen .................................................
Eine Datenbank ver- und entschlüsseln ................................................
Eine verschlüsselte Datenbank öffnen .................................................
Testen ob Tabelle vorhanden ist .......................................................
Die Datenbank defragmentieren ......................................................
Mehrere Datenbanken verknüpfen ....................................................
Testen, ob eine Tabelle vorhanden ist ..................................................
Eine Abfrage/Tabelle kopieren ........................................................
Backup/Restore implementieren ......................................................
Tabellen zwischen Datenbanken kopieren ..............................................
Ersatz für TOP .......................................................................
Metadaten auswerten .................................................................
Timestamp als Defaultwert verwenden ................................................
Export in XML-Format ...............................................................
Fazit ....................................................................................
703
703
704
705
706
706
706
707
707
708
708
709
711
711
712
713
714
715
Datenbanken in der Cloud
717
718
718
720
722
723
723
724
728
729
729
731
731
734
736
739
741
741
744
746
747
748
749
750
755
756
759
759
760
761
............................................................
Einführung in SQL Azure-Datenbanken ..................................................
Das Grundprinzip der »Webdatenbank« ...............................................
Der Azure-Server ....................................................................
Die Frage nach den Kosten ...........................................................
Einrichten des Servers ...................................................................
Die zentrale Organisationsstruktur ....................................................
Einen Server und eine Datenbank erstellen .............................................
IP-Filter konfigurieren ...............................................................
Bemerkungen zum neu erstellten Account .............................................
Die drei konzeptionellen Zugriffsmodelle ..............................................
Administrieren von Azure SQL-Datenbanken .............................................
Zugriff mit dem SQL Server Management Studio ......................................
Weitere Accounts erstellen ............................................................
Lokalen Datenbanken mit dem Management Studio migrieren ..........................
Visual Studio 2012 als Management-Tool ..............................................
Praktische Umsetzung in einer VB-Anwendung ............................................
Verbindung aufbauen ................................................................
Datenbank erstellen ..................................................................
Den aktuellen »Füllstand« abrufen ....................................................
Was passiert, wenn die Datenbank zu klein wird? .......................................
Eine Datenbankkopie erstellen ........................................................
Tabelle(n) erstellen ...................................................................
Daten schreiben/lesen ................................................................
Stored Procedures ....................................................................
Implementieren einer temporären Fehlerbehandlung ...................................
Abschließende Hinweise .................................................................
Synchronisieren ......................................................................
Performance-Tipps ..................................................................
Die Firewall per T-SQL konfigurieren .................................................
16
Inhaltsverzeichnis
Arbeiten mit sqlcmd .................................................................
Migrieren von Access-Datenbanken ...................................................
12
Arbeiten mit dem Entity Framework
..................................................
Das Grundkonzept ......................................................................
Konzeptionelle Schicht ...............................................................
Logische Schicht .....................................................................
Zuordnungsschicht ..................................................................
Wie erstelle ich die Schema-Dateien? ..................................................
Das Gesamtmodell im Überblick ......................................................
Wie kann mit dem EDM gearbeitet werden? ...........................................
Die Entwurfsmöglichkeiten im Überblick .................................................
Database-First .......................................................................
Model-First ..........................................................................
Code-First ...........................................................................
Noch ein Wort zur Code-Erzeugung ...................................................
Überblick zu den Neuigkeiten für Umsteiger ..............................................
Entity Framework 5 ..................................................................
Entity Framework 6 ..................................................................
Der Database-First/Model-First-Entwurf ..................................................
Unsere Beispieldatenbank ............................................................
Der EDM-Assistent ..................................................................
Der EDM-Designer ..................................................................
Weitere Fenster des EDM-Designers ...................................................
Stored Procedures importieren ........................................................
Komplexe Typen .....................................................................
Verwendung von Enums ..............................................................
Die erzeugten Klassen/partielle Klassen ................................................
Aktualisieren des Modells .............................................................
Besonderheit des Model-First-Entwurfs ...............................................
Code-First – Ein erster Einstieg ...........................................................
Vom Code zur Datenbank – unser erster Versuch .......................................
Wir machen es besser und nutzen Annotations .........................................
Festlegen der Zieldatenbank ..........................................................
Entity Framework Power Tools ........................................................
Einsatz des EntityClient für die Datenabfrage ..............................................
Ein Überblick ........................................................................
Einsatzbeispiel ......................................................................
Connection aufbauen ................................................................
Parameterabfragen realisieren .........................................................
Wann sollten Sie diese Variante nutzen? ................................................
Verwenden der Objektdienste ............................................................
Eine Übersicht .......................................................................
Verwendung von eSQL ...............................................................
Verwendung von LINQ to Entities ....................................................
Kurzeinführung in Entity SQL (eSQL) ....................................................
Für den Umsteiger: Unterschiede zu T-SQL ............................................
Für den Einsteiger ....................................................................
762
762
767
768
769
771
772
772
773
774
775
775
776
776
778
778
779
779
780
780
783
785
788
790
792
794
796
798
799
801
801
805
808
809
811
811
811
813
813
814
814
815
815
816
819
819
820
17
Inhaltsverzeichnis
13
Praktisches Arbeiten mit dem EDM .......................................................
Skalare Werte abfragen ...............................................................
Abfrage mit Projektion ...............................................................
Detaildaten/Verwendung der Navigationseigenschaften .................................
Lazy Loading ........................................................................
Wie funktioniert das explizite Laden? ..................................................
Was passiert beim vorzeitigen Laden (Eager-Load)? ....................................
Delay Loaded ........................................................................
Zugriff mit Paging ...................................................................
Abrufen einzelner Entitäten ...........................................................
Lokale Datenaktualisierung per DbContext ............................................
Einfaches Einfügen von Datensätzen ..................................................
Abrufen eines Identity-Wertes nach dem Einfügen .....................................
Einfügen von Datensätzen in 1:n/m:n-Beziehungen ....................................
Bearbeiten von Entitäten .............................................................
Übernahme der Daten mit SaveChanges ...............................................
Löschen von Daten ...................................................................
Verwendung von Stored Procedures ...................................................
Funktionsimporte ....................................................................
Verwenden des ChangeTrackers .......................................................
Anhängen von Objekten ..............................................................
Arbeiten mit Vererbung ..............................................................
Validierung ..........................................................................
Verwenden der partiellen Klassen .....................................................
How-to-Beispiele ........................................................................
12.1 ... den ConnectionString anpassen? ..............................................
12.2 ... ChangeTracking deaktivieren? ................................................
12.3 ... Objekt per Schlüssel löschen, ohne diese zu laden? ..............................
12.4 ... LINQPad verwenden? ........................................................
12.5 ... die Entity Framework Extended Library verwenden? ............................
12.6 ... SQL-Anweisungen analysieren? ...............................................
12.7 ... direkte SQL-Statements an den Server senden? .................................
827
827
828
828
829
831
832
834
835
835
836
837
838
839
840
841
843
844
847
848
851
853
856
858
860
860
862
862
863
866
867
867
Reporting Services
869
870
870
870
871
871
872
876
880
880
881
883
884
886
.....................................................................
Übersicht ...............................................................................
Report Designer .....................................................................
Report Viewer .......................................................................
Wichtige Änderungen gegenüber der Vorgängerversion .................................
Einführungsbeispiele ....................................................................
Der erste Bericht – so einfach geht das! ................................................
Ein zweiter Bericht – weg mit dem Assistenten! ........................................
Unsere Werkzeuge für den Berichtsentwurf ................................................
Oberfläche des Report-Designers .....................................................
Werkzeugkasten .....................................................................
Bericht-Menü .......................................................................
Berichtsdaten-Fenster ................................................................
Programmieren mit Visual Basic ......................................................
18
Inhaltsverzeichnis
14
Sortieren, Gruppieren und Filtern von Datensätzen ........................................
Vorbereitungen ......................................................................
Sortieren ............................................................................
Gruppieren ..........................................................................
Filtern ...............................................................................
Kreuztabellenberichte ....................................................................
Einfache Matrix ......................................................................
Zeilen- und Spaltensummen anzeigen .................................................
Zusätzliche berechnete Spalten einfügen ...............................................
Matrix mit zwei Zeilengruppen .......................................................
Bilder im Bericht anzeigen ...............................................................
Ein Bild einbetten ....................................................................
Bilder aus einer Datenbank ...........................................................
Externe Bilder .......................................................................
Hintergrundbilder ...................................................................
Diagramme darstellen ...................................................................
Diagrammtypen .....................................................................
Säulendiagramm .....................................................................
Weitere Gruppen hinzufügen .........................................................
Weitere Diagramme ..................................................................
Parameter anwenden ....................................................................
Parameterdefinition ..................................................................
Einbau von Parametern in den Berichtsentwurf ........................................
Parameterwerte an Bericht übergeben .................................................
Berichtsvariablen ........................................................................
Master-Detail-Reports ...................................................................
Subreports ..........................................................................
Eingebettete Datenregionen ..........................................................
Noch mehr Reporting ....................................................................
Hyperlink realisieren .................................................................
Verwenden von ReportViewer-Ereignissen .............................................
Hinzufügen von benutzerdefiniertem Code ...............................................
Variante 1: Eingebetteter Visual Basic-Code ............................................
Variante 2: Benutzerdefinierte Assembly ...............................................
Ergänzungen zum ReportViewer .........................................................
Local Mode versus Server Mode .......................................................
RDL- versus RDLC-Format ...........................................................
Übersicht Datenbindung .............................................................
How-to-Beispiele ........................................................................
13.1 ... einen Bericht mit dem Berichtsassistenten erstellen? ............................
13.2 ... einen Unterbericht einsetzen? .................................................
13.3 ... eine Rechnung anzeigen? .....................................................
13.4 ... das Drillthrough-Event behandeln? ............................................
13.5 ... das Messgerät zur Anzeige nutzen? ............................................
889
889
890
892
894
895
895
895
896
897
898
898
899
899
899
900
900
900
902
903
904
904
905
906
907
908
908
908
908
909
910
912
912
913
914
914
914
915
917
917
920
927
933
936
Das Microsoft Chart-Control
939
940
940
941
..........................................................
Allgemeine Chart-Features ...............................................................
Serien/Reihen und Datenpunkte direkt erzeugen .......................................
Den Diagrammtyp ändern ............................................................
19
Inhaltsverzeichnis
3D-Darstellung ......................................................................
Farben für Serien und Datenpunkte ...................................................
Leere Datenpunkte ...................................................................
Diagramm drucken ..................................................................
Diagramm exportieren/abspeichern ...................................................
Einführung in die Chart-Datenbindung ...................................................
Manuelle Datenbindung mittels Points.AddXY-Methode ...............................
Übersicht über die speziellen Datenbindungsmethoden ................................
Unterstützte Datenquellen ............................................................
Spezielle Chart-Datenbindungsmethoden ................................................
Die DataBindTable-Methode .........................................................
DataBind-Methode/DataSource-Eigenschaft ..........................................
Die DataBindCrossTable-Methode ....................................................
Die Points.DataBind-Methode ........................................................
Die Points.DataBind(X)Y-Methoden ..................................................
How-to-Beispiele ........................................................................
14.1 ... das Chart-Control zur Laufzeit mit Daten füllen? ...............................
14.2 ... das Chart mit einer LINQ to SQL-Abfrage verbinden? ..........................
14.3 ... mit ASP.NET und Entity Framework ein Diagramm anzeigen? ..................
943
944
945
946
946
947
947
949
949
950
950
952
954
956
957
959
959
962
964
A
Glossar
969
B
Wichtige Dateiendungen
................................................................................
Stichwortverzeichnis
..............................................................
975
...................................................................
977
Bonuskapitel im E-Book
Vorwort
15
................................................................................
Access-Datenbanken
..................................................................
Ein erster Blick auf Microsoft Access-Datenbanken ........................................
Warum Access? ......................................................................
Access-Datentypen ...................................................................
Beschränkungen .....................................................................
Der Zugriff aus Visual Basic ..............................................................
Warum nicht nur ADO.NET? .........................................................
Die ADOX-Library ...................................................................
Die JRO-Library .....................................................................
ADO MD ...........................................................................
Einbinden von ADOX und JRO in VB .................................................
Parameter für ADO.NET-Connectionstrings ..........................................
Access-Datenbankpasswort ...........................................................
Access-Datenbanksicherheit (Benutzer-/Gruppenebene) ................................
Datenbankzugriff auf schreibgeschützte Medien (CD, DVD) ...........................
Datenbanken erstellen ...................................................................
Die Create-Methode .................................................................
Weitere Parameter ...................................................................
Jet-spezifische Optionen ..............................................................
Tabellen/Indizes erstellen/verwalten .......................................................
Tabellendefinition ....................................................................
Indexdefinition ......................................................................
Erstellen von Prozeduren und Sichten .................................................
Tabellen verknüpfen (Relationen) .....................................................
Zugriffsschutz in Access-Datenbanken ....................................................
Grundlagen .........................................................................
Sichern auf Datenbankebene ..........................................................
Erstellen neuer Benutzer und Gruppen ................................................
Vergabe von Rechten .................................................................
Verschlüsseln von Datenbanken .......................................................
Einbinden externer Tabellen ..............................................................
Erstellen einer Verbindung ............................................................
Aktualisieren einer Verbindung .......................................................
Löschen einer Verbindung ............................................................
Replizieren von Datenbanken ............................................................
Datenbankanalyse .......................................................................
Verwendung von GetSchema .........................................................
Datenbankeigenschaften mit ADOX ermitteln .........................................
Tabellen mit ADOX bestimmen .......................................................
Sichten/Abfragen mit ADOX bestimmen ..............................................
Nutzer und Nutzergruppen auslesen ..................................................
Nutzer- und Gruppenberechtigungen ermitteln ........................................
1003
1005
1006
1006
1007
1008
1008
1009
1009
1010
1010
1012
1013
1013
1014
1015
1015
1016
1016
1016
1018
1018
1023
1025
1026
1028
1028
1029
1030
1031
1033
1035
1035
1036
1037
1037
1037
1037
1040
1041
1044
1047
1048
22
Bonuskapitel im E-Book
16
Weitere Aufgabenstellungen ..............................................................
Access-Datenbanken reparieren/komprimieren ........................................
Distribution von Access-Datenbanken .................................................
Access 2007-Datenbanken ................................................................
Zugriff auf die Datenbanken ..........................................................
Neuer Connectionstring ..............................................................
Übersicht neue Datentypen ...........................................................
Arbeiten mit den DAOs ..............................................................
Memofeld mit Archiv-Funktion .......................................................
Anlage-Feld .........................................................................
Rich-Text-Feld .......................................................................
Multivalue-Feld (MVF) ..............................................................
Access 2010-/2013-Datenbanken .........................................................
Download/Installation Access 2010 Database Engine ...................................
Berechnete Spalten ...................................................................
Trigger/Datenmakros .................................................................
Unterschiede Access 2007/2010/2013 ..................................................
How-to-Beispiele ........................................................................
15.1 ... ADO installieren? ............................................................
15.2 ... Access-Datenbanken exklusiv öffnen? ..........................................
15.3 ... die Zugriffsgeschwindigkeit auf Access-Datenbanken erhöhen? ..................
15.4 ... Access-Datenbanken im Netzwerk verwenden? .................................
15.5 ... alle aktiven Verbindungen zur Datenbank auflisten? ............................
15.6 ... eine Spalte mit eindeutigen Zufallswerten erzeugen? ............................
15.7 ... das Datenbank-Kennwort ändern? ............................................
15.8 ... Abfragen über mehrere Datenbanken realisieren? ...............................
15.9 ... die Beschreibung von Datenbankfeldern abrufen? ..............................
15.10 … ohne Access auf Access-Datenbanken zugreifen? ...............................
1050
1050
1051
1051
1052
1052
1053
1053
1054
1056
1062
1064
1067
1068
1068
1071
1073
1073
1073
1073
1073
1074
1074
1075
1075
1076
1076
1077
Jet-SQL in Theorie und Praxis
1079
1080
1081
1083
1083
1084
1085
1087
1087
1088
1088
1089
1090
1096
1097
1098
1102
1103
1103
1105
.........................................................
Einführung .............................................................................
Kategorien von SQL-Anweisungen ....................................................
Testprogramm und Beispieldatenbank ....................................................
Hinweise zur Bedienung ..............................................................
Unsere Beispieldatenbank im Überblick ...............................................
Alternative Varianten für die SQL-Abfrage .............................................
Bemerkungen ........................................................................
Daten abfragen ..........................................................................
Abfragen mit SELECT ................................................................
Alle Spalten auswählen ...............................................................
Auswahl der Spalten ..................................................................
Filtern ...............................................................................
Beschränken der Ergebnismenge ......................................................
Eindeutige Records/doppelte Datensätze ...............................................
Tabellen verknüpfen .................................................................
Tabellen vereinigen ...................................................................
Datensätze sortieren ..................................................................
Datensätze gruppieren ...............................................................
Unterabfragen .......................................................................
23
Bonuskapitel im E-Book
17
Daten manipulieren .....................................................................
Einfügen einzelner Datensätze ........................................................
Einfügen von Abfragedaten ...........................................................
Exportieren/Importieren von Abfragedaten ............................................
Aktualisieren/Ändern ................................................................
Löschen .............................................................................
Erweiterte SQL-Funktionen ..............................................................
Berechnete/Formatierte Spalten .......................................................
Berechnungsfunktionen ..............................................................
NULL-Werte ........................................................................
Datum und Zeit in SQL-Abfragen .....................................................
Datentypumwandlungen .............................................................
Kreuztabellenabfragen ................................................................
Datenbankverwaltung mit SQL (DDL) ....................................................
Datenbanken ........................................................................
Tabellen .............................................................................
Indizes ..............................................................................
Tabellen/Indizes löschen oder verändern ..............................................
Sichten (Views) ......................................................................
Nutzer- und Rechteverwaltung ........................................................
Datenbankentwurf optimieren ...........................................................
Indizes ..............................................................................
Abfrageoptimierung .................................................................
Weitere Möglichkeiten ...............................................................
Jet-SQL in der Visual Basic-Praxis ........................................................
Ausführen oder abfragen? ............................................................
Einfügen von Strings zur Laufzeit .....................................................
Datumseingabe ......................................................................
Parameterübergabe ..................................................................
How-to-Beispiele ........................................................................
16.1 ... nach einem INSERT das Zählerfeld abfragen? ..................................
16.2 ... die Anzahl der Datensätze ermitteln? ..........................................
16.3 ... Datumsteile in SQL zur Suche nutzen? .........................................
16.4 ... die Groß-/Kleinschreibung berücksichtigen? ...................................
16.5 ... WITH OWNERACCESS OPTION verwenden? ................................
16.6 ... Datensätze richtig verknüpfen? ................................................
16.7 ... doppelte Datensätze aus einer Tabelle löschen? .................................
16.8 ... die IFF-Funktion ersetzen? ....................................................
16.9 ... ein einfaches SQL-Abfrageprogramm erstellen? ................................
16.10 ... Aggregatfunktionen auswerten? ...............................................
16.11 ... die Access 2007-Datenbankfeatures unterstützen? ..............................
Übersichten .............................................................................
Die wichtigsten SQL-Befehle .........................................................
Unterschiede ANSI-SQL und Access-SQL ..............................................
1110
1110
1111
1113
1116
1116
1117
1118
1125
1127
1128
1134
1135
1137
1137
1138
1139
1142
1142
1144
1147
1147
1148
1149
1149
1149
1151
1151
1152
1154
1154
1154
1155
1155
1156
1157
1158
1159
1159
1162
1163
1163
1163
1164
T-SQL in Theorie und Praxis
1167
...........................................................
Einführung ............................................................................. 1168
Kategorien von SQL-Anweisungen .................................................... 1169
Schreibweise ......................................................................... 1171
24
Bonuskapitel im E-Book
Kommentare ........................................................................
Zeichenketten .......................................................................
Variablen deklarieren/verwenden .....................................................
Bedingungen mit IF/ELSE auswerten ..................................................
Verwenden von CASE ................................................................
CHOOSE ...........................................................................
Verwenden von WHILE … BREAK/CONTINUE .......................................
Datum und Uhrzeit in T-SQL .........................................................
Verwenden von GOTO ...............................................................
Fehlerbehandlung ....................................................................
Testprogramm und Beispieldatenbank ....................................................
Hinweise zur Bedienung ..............................................................
Unsere Beispieldatenbank im Überblick ...............................................
Alternative Varianten für die SQL-Abfrage .............................................
Bemerkungen ........................................................................
Daten abfragen ..........................................................................
Abfragen mit SELECT ................................................................
Alle Spalten auswählen ...............................................................
Auswahl der Spalten ..................................................................
Filtern ...............................................................................
Beschränken der Ergebnismenge ......................................................
Eindeutige Records/doppelte Datensätze ...............................................
Tabellen verknüpfen .................................................................
Tabellen vereinigen ...................................................................
Datensätze sortieren ..................................................................
Datensätze gruppieren ...............................................................
Unterabfragen .......................................................................
Daten manipulieren .....................................................................
Einfügen einzelner Datensätze ........................................................
Einfügen von Abfragedaten ...........................................................
Exportieren/Importieren von Abfragedaten ............................................
Aktualisieren/Ändern ................................................................
Löschen .............................................................................
Erweiterte T-SQL-Funktionen ............................................................
Berechnete/Formatierte Spalten .......................................................
Berechnungsfunktionen ..............................................................
NULL-Werte ........................................................................
Datum und Zeit in SQL-Abfragen .....................................................
Datentypumwandlungen .............................................................
Kreuztabellenabfragen ................................................................
Datenbankverwaltung mit T-SQL (DDL) ..................................................
Datenbankentwurf optimieren ...........................................................
Indizes ..............................................................................
Abfrageoptimierung .................................................................
Weitere Möglichkeiten ...............................................................
SQL in der Visual Basic-Praxis ............................................................
Ausführen oder abfragen? ............................................................
Einfügen von Strings zur Laufzeit .....................................................
1171
1171
1172
1173
1174
1175
1175
1175
1176
1176
1177
1177
1178
1179
1181
1181
1182
1182
1183
1185
1192
1193
1194
1199
1199
1200
1202
1207
1207
1209
1211
1212
1213
1214
1214
1222
1224
1225
1230
1232
1234
1235
1235
1235
1236
1237
1237
1238
25
Bonuskapitel im E-Book
18
Parameterübergabe ..................................................................
Datumseingabe ......................................................................
How-to-Beispiele ........................................................................
17.1 ... nach einem INSERT das Zählerfeld abfragen? ..................................
17.2 ... die Anzahl der Datensätze ermitteln? ..........................................
17.3 ... Datumsteile in SQL zur Suche nutzen? .........................................
17.4 ... die Groß-/Kleinschreibung berücksichtigen? ...................................
17.5 ... Datensätze richtig verknüpfen? ................................................
17.6 ... doppelte Datensätze aus einer Tabelle löschen? .................................
17.7 ... die IFF-Funktion ersetzen? ....................................................
17.8 ... Aggregatfunktionen auswerten? ...............................................
17.9 ... SQL-Injection verhindern? ....................................................
17.10 ... ein SQL-Abfrageprogramm erstellen ..........................................
Übersichten .............................................................................
Die wichtigsten SQL-Befehle .........................................................
1240
1241
1242
1242
1244
1244
1245
1246
1247
1248
1249
1250
1255
1262
1262
LINQ to SQL
1263
1264
1264
1265
1266
1267
1269
1269
1269
1270
1272
1274
1275
1277
1277
1279
1280
1280
1280
1281
1281
1282
1283
1284
1284
1286
1287
1287
1290
1290
1290
1291
1292
...........................................................................
Übersicht ...............................................................................
Das LINQ to SQL-Datenmodell .......................................................
Der DataContext .....................................................................
Die Entitäts-Klassen ..................................................................
Umstiegsbeispiel für den »ehemaligen« SQL-Programmierer ............................
Datenbank-Entwurfskonzepte ........................................................
Der schnelle Weg zu den SQL Server-Daten ...............................................
Der LINQ to SQL-Designer ...........................................................
Die .DBML-Datei ....................................................................
Die Designer.vb-Datei ................................................................
Ein erster Test und ein Blick unter die Motorhaube .....................................
SQL-Debugging leicht gemacht .......................................................
Der steinige Weg zur Persistenz ...........................................................
Das Datenmodell entwickeln .........................................................
Erzeugen der Datenbank und Herstellen der Verbindung ...............................
Ein paar Gedanken zum Erstellen neuer Datenbanken ..................................
Datenauswahl/Datentypen ...............................................................
Einfache Datentypen .................................................................
IQueryable(Of T) ....................................................................
Datenauswahl basierend auf Detaildaten ...............................................
Bereichsauswahl (Paging) .............................................................
Probleme mit First() .................................................................
Datenbindung ...........................................................................
Datenquelle hinzufügen ..............................................................
Anzeige von Detaildaten ..............................................................
Listendarstellung mit anonymen Typen optimieren ....................................
Lazy Loading/Prefetch/Delay Loaded ..................................................
ObjectTracking ausschalten ...........................................................
Bearbeiten und Aktualisieren .............................................................
Editieren ............................................................................
Fehler beim Aktualisieren .............................................................
Konflikte beim Aktualisieren von Datensätzen .........................................
26
Bonuskapitel im E-Book
19
Lokale Datenaktualisierung per DataContext ..........................................
Neue Datensätze erzeugen ............................................................
Löschen .............................................................................
Eingabevalidierung ......................................................................
Prüfung auf Feld-Ebene (Eigenschaft) .................................................
Prüfung auf Datensatz-Ebene (Objekt) ................................................
Überprüfung vor Update, Insert oder Delete ...........................................
Stored Procedures .......................................................................
Allgemeine Verwendung ..............................................................
Skalare Rückgabewerte ...............................................................
Typisierte Rückgabewerte .............................................................
Insert/Update/Delete per Stored Procedure ............................................
Weitere LINQ to SQL-Features ...........................................................
Direkte SQL-Programmierung ........................................................
Verwendung der partiellen Klassen/Methoden .........................................
Schlussbemerkung .......................................................................
1296
1297
1300
1301
1302
1303
1303
1304
1304
1305
1306
1307
1309
1309
1310
1312
Crystal Reports
1313
1314
1314
1315
1321
1322
1323
1324
1324
1325
1326
1326
1327
1328
1328
1329
1330
1330
1332
1332
1335
1339
1342
1346
1348
1352
1356
1356
1356
1358
1358
1359
........................................................................
Übersicht ...............................................................................
Installieren ..........................................................................
Ein Einsteigerbeispiel .................................................................
Der Report-Designer .................................................................
Der Reportaufbau ....................................................................
Die Druckvorschau-Komponente .....................................................
Wichtige Funktionen im Überblick .......................................................
Formelfelder .........................................................................
Parameterfelder ......................................................................
Gruppennamenfelder ................................................................
Spezialfelder .........................................................................
SQL-Ausdrucksfelder ................................................................
Laufende Summe-Felder .............................................................
Unterberichte ........................................................................
Diagramme und Bilder ...............................................................
Weitere Komponenten ...............................................................
Das Ereignis-Modell .................................................................
Reports entwerfen .......................................................................
Verbindung zur Datenbank herstellen .................................................
Sortieren und Gruppieren ............................................................
Verwenden von Parameterfeldern .....................................................
Berechnungen im Report .............................................................
Gestalten mit bedingter Formatierung .................................................
Kreuztabellenberichte ................................................................
Unterberichte ........................................................................
Programmieren der Druckvorschau .......................................................
Der CrystalReportViewer im Überblick ................................................
Wichtige Eigenschaften, Methoden und Ereignisse .....................................
Direkte Ausgabe auf dem Drucker ........................................................
Die Lizenz zum Drucken .............................................................
Druckerauswahl und Konfiguration ...................................................
27
Bonuskapitel im E-Book
20
Drucken mit Druckerdialog ..........................................................
Exportieren von Reports .................................................................
Bestimmen des Exportformats ........................................................
Export als Datei ......................................................................
Export als E-Mail ....................................................................
Praxisbeispiel – Rechnung mit Crystal Report drucken .....................................
Datenbasis anpassen .................................................................
Report erzeugen .....................................................................
Festlegen der Datenquelle ............................................................
Berechnungen im Report durchführen ................................................
Auswahl der gewünschten Datensätze .................................................
Reportentwurf .......................................................................
Druckvorschaufenster entwerfen ......................................................
Zuweisen der Daten und Übergabe der Parameter ......................................
Die fertige Rechnung .................................................................
How-to-Beispiele ........................................................................
19.1 ... ein Deckblatt erzeugen? .......................................................
19.2 ... Seitenzahlen, Druckdatum etc. einblenden? ....................................
19.3 ... Spaltensatz oder Etiketten realisieren? .........................................
19.4 ... die Seitenränder festlegen? ....................................................
19.5 ... mehrspaltige Reports erstellen? ................................................
19.6 ... einen Seitenumbruch erzwingen? ..............................................
19.7 ... die Position und Größe der Druckvorschau vorgeben? ..........................
19.8 ... Reports in die Applikation einbetten? ..........................................
19.9 ... Querdruck auswählen? .......................................................
19.10 ... RTF-/HTML-Text ausgeben? ..................................................
19.11 ... den Report zur Laufzeit auswählen? ...........................................
19.12 ... Summen, Anzahlen, Mittelwerte etc. berechnen? ...............................
19.13 ... farbliche und optische Formatierungen realisieren? .............................
19.14 ... den Datenbankpfad zur Laufzeit anpassen? ....................................
19.15 ... die Login-Informationen zur Laufzeit ändern? .................................
1360
1361
1361
1362
1363
1364
1364
1366
1366
1367
1367
1368
1369
1370
1371
1372
1372
1372
1372
1373
1374
1374
1375
1375
1376
1376
1376
1377
1377
1378
1379
Datenbindung in ASP.NET-Anwendungen
1381
1382
1382
1383
1385
1386
1388
1390
1391
1391
1391
1393
1393
1394
1398
1400
1400
............................................
Übersicht Datenbindung unter ASP.NET ..................................................
Konzept .............................................................................
Übersicht über die DataSource-Steuerelemente ........................................
SqlDataSource im Detail .................................................................
Datenauswahl mit Parametern ........................................................
Parameter für INSERT, UPDATE und DELETE ........................................
FilterExpression .....................................................................
Caching .............................................................................
Weitere Methoden ...................................................................
Ereignisse ...........................................................................
Zugriff auf Geschäftsobjekte mit der ObjectDataSource ....................................
Verbindung zwischen Objekt und DataSource .........................................
Ein Beispiel sorgt für Klarheit .........................................................
Geschäftsobjekte in einer Session verwalten ............................................
Typisierte DataSets und ObjectDataSource ................................................
Verwendung von TableAdaptern in ASP.NET-Seiten ....................................
28
Bonuskapitel im E-Book
Datenauswahl und Anzeige mit TableAdaptern .........................................
Datenmanipulation mit TableAdaptern ................................................
ObjectDataSource und typisierte DataSets .............................................
LinqDataSource .........................................................................
Bindung von einfachen LINQ-Collections .............................................
Binden eines LINQ to SQL-DataContext ..............................................
Berechnete Spalten/Detaildaten .......................................................
Eigene LINQ-Ausdrücke zur Laufzeit übergeben .......................................
Filtern mit der LinqDataSource .......................................................
EntityDataSource ........................................................................
Entity Data Model erstellen ...........................................................
EntityDataSource anbinden ...........................................................
Datenmenge filtern ..................................................................
QueryExtender ..........................................................................
Grundlagen .........................................................................
Suchen ..............................................................................
Sortieren ............................................................................
Weitere Datenquellen ....................................................................
Spezialfall AccessDataSource ..........................................................
Verwalten strukturierter Daten mit der XmlDataSource ................................
Typisierte Datenbindung .............................................................
Model Binding .......................................................................
Das GridView-Steuerelement im Detail ...................................................
Auswahlfunktion (Zeilenauswahl) .....................................................
Auswahl mit mehrspaltigem Index realisieren ..........................................
Hyperlink-Spalte für Detailansicht nutzen .............................................
Spalten erzeugen/konfigurieren .......................................................
Template-Spalten verwenden .........................................................
Paging im GridView realisieren .......................................................
Editieren und Löschen im GridView ...................................................
Einfügen von Datensätzen ............................................................
Keine Daten, was tun? ................................................................
Weitere Steuerelemente für die Datenbindung .............................................
DetailsView ..........................................................................
FormView ...........................................................................
DataList .............................................................................
Repeater .............................................................................
ListView .............................................................................
Label/TextBox .......................................................................
CheckBoxList, BulletList, RadioButtonList, DropDownList, ListBox .....................
Hierarchische Datenanzeige mittels TreeView-Control ..................................
Chart-Steuerelement .................................................................
Eingabeprüfung mit den Validator-Steuerelementen .......................................
Übersicht ............................................................................
Wo findet die Fehlerprüfung statt? ....................................................
Verwendung .........................................................................
RequiredFieldValidator ...............................................................
CompareValidator ...................................................................
RangeValidator ......................................................................
1401
1405
1407
1412
1412
1414
1415
1417
1418
1419
1419
1422
1425
1425
1426
1426
1429
1429
1430
1430
1431
1432
1434
1435
1435
1436
1437
1438
1442
1443
1443
1444
1444
1444
1447
1450
1452
1454
1458
1459
1461
1464
1466
1466
1466
1467
1468
1468
1470
29
Bonuskapitel im E-Book
21
RegularExpressionValidator ...........................................................
CustomValidator .....................................................................
ValidationSummary ..................................................................
Weitere Möglichkeiten der Validation-Steuerelemente ..................................
Reports in ASP.NET-Anwendungen verwenden ............................................
Der Microsoft ReportViewer ..........................................................
Direkter Excel-/PDF-Export ..........................................................
Parameterübergabe an lokale Reports .................................................
Weitere Themen .........................................................................
Dynamic Data .......................................................................
ASP.NET MVC ......................................................................
AJAX ................................................................................
How-to-Beispiele ........................................................................
20.1 ... die Zellen im GridView formatieren? ..........................................
20.2 ... ein GridView mit Scrollbar realisieren? ........................................
20.3 ... ein GridView mit Mouseover-Effekt realisieren? ................................
20.4 ... GridView-Daten im Excel-Format exportieren? ................................
20.5 ... Detaildaten in einem Popup-Fenster anzeigen? .................................
20.6 ... eine Zeilensumme im GridView berechnen? ...................................
20.7 ... reagieren, wenn keine Daten vorhanden sind? ..................................
20.8 ... im GridView eine Spaltensummen berechnen? .................................
20.9 ... korrekte Währungswerte im GridView anzeigen? ...............................
20.10 ... Eingabewerte im GridView validieren? .........................................
20.11 ... einen E-Mail-Versand in ASP.NET realisieren? .................................
1471
1471
1473
1474
1475
1475
1477
1479
1480
1480
1487
1491
1494
1494
1496
1497
1498
1500
1503
1504
1504
1505
1506
1507
WCF – eine Einführung
1511
1512
1512
1513
1514
1516
1516
1516
1518
1518
1519
1520
1523
1524
1524
1525
1526
1527
1527
1528
1528
1529
1529
1530
...............................................................
Die Programmierung verteilter Systeme ...................................................
Intranet oder Internet? ...............................................................
Die Vorgänger .......................................................................
WCF – die neue Technologie ..........................................................
Allgemeiner Aufbau eines WCF-Systems ..................................................
WCF-Assemblies – die verfügbaren Bausteine ..........................................
Service, Host und Client .............................................................
Nachrichtenaustausch ................................................................
Das ABC der WCF-Endpunkte ...........................................................
Verträge .............................................................................
Bindungen ..........................................................................
Adressen ............................................................................
Programmieren eines WCF-Dienstes ......................................................
Quellcode als Klassenbibliothek ......................................................
Das <ServiceContract>-Attribut ......................................................
Das <OperationContract>-Attribut ...................................................
Service Klassen ohne Vertrags-Interfaces ...............................................
Der WCF-Host ..........................................................................
Vorbereitungen ......................................................................
Die App.config ......................................................................
Die ServiceHost-Klasse ...............................................................
Festlegen der Basisadressen ...........................................................
Weitere Details der ServiceHost-Klasse ................................................
30
Bonuskapitel im E-Book
22
Das <system.serviceModel>-Element .................................................
Austausch der Metadaten (MEX) ......................................................
Der WCF-Client .........................................................................
Vorbereitungen ......................................................................
Verwenden von SvcUtil.exe ...........................................................
Einsatz des Proxy-Generators von Visual Studio .......................................
Weitere WCF-Features ...................................................................
Vereinfachte Entwicklung von Host-Anwendungen ....................................
Projektvorlage WCF-Dienstbibliothek .................................................
Wichtige Neuigkeiten in WCF 4.5 .....................................................
How-to-Beispiele ........................................................................
21.1 ... einen WCF-Webdienst mit Datenzugriffsschicht entwickeln? ....................
21.2 ... einen Client für einen WCF-Webdienst entwickeln? ............................
21.3 ... was tun, wenn der IIS nicht funktioniert? ......................................
1531
1532
1535
1535
1535
1538
1539
1539
1541
1546
1547
1547
1554
1557
Einführung WCF Data Services
1559
1560
1560
1563
1564
1565
1569
1569
1571
1572
1573
1574
1575
1577
1580
1581
1582
1582
1583
........................................................
Einführung .............................................................................
Warum WCF Data Services? ..........................................................
Vor- und Nachteile ..................................................................
Und was ist OData? ..................................................................
Übersicht der OData-Abfrageoptionen ................................................
Praktisches Arbeiten mit den WCF Data Services ..........................................
Ein erster Data Consumer ............................................................
Verwendung von CreateQuery(Of T) ..................................................
Verwendung von Execute(Of T) .......................................................
Asynchrone Verarbeitung .............................................................
Anzahl der Entitäten bestimmen ......................................................
Verwendung der DataServiceCollection ...............................................
Eigene Methoden über den Data Service bereitstellen ...................................
Freigabe der Schnittstelle regeln .......................................................
Verwendung von Fiddler .............................................................
How-to-Beispiele ........................................................................
22.1 ... einen einfachen WCF Data Service erstellen? ...................................
22.2 ... einen Silverlight-Client mit WCF Data Services anbinden? ......................
23
Komplexbeispiel Webshop
............................................................
Grundkonzept ..........................................................................
Aufgabenstellung ....................................................................
Unterschiedliche Frontends für Kunden und Verkäufer .................................
Die Datenbankstruktur ..................................................................
Datenbankdiagramm .................................................................
Tabellen .............................................................................
Stored Procedures ....................................................................
Ansichten/Views .....................................................................
Bemerkungen ........................................................................
Entwurf Webshop-Projekt/Datenbank ....................................................
Stammdatenverwaltung mit Webdienst ...................................................
Das Interface ........................................................................
Entwurf Webdienst ..................................................................
1591
1592
1592
1593
1593
1593
1595
1597
1601
1601
1602
1603
1604
1604
31
Bonuskapitel im E-Book
Die Methoden im Einzelnen ..........................................................
Windows-Verwaltungsfrontend ...........................................................
Entwurf .............................................................................
Verbindung zum Webdienst herstellen .................................................
Oberflächengestaltung ...............................................................
Implementierung Stammdatenverwaltung .............................................
Test Stammdatenverwaltung ..........................................................
Typisiertes DataSet für den Report ....................................................
Reportentwurf .......................................................................
Reporteinbindung ...................................................................
Filtern der Artikelgruppen ............................................................
Kunden-Tabelle ......................................................................
ASP.NET-Kundeninterface ...............................................................
Übersicht ............................................................................
Entwurf Default.aspx .................................................................
Vorbereitung Benutzersteuerelemente .................................................
Welcome.ascx ........................................................................
Shop.ascx ...........................................................................
Warenkorb.ascx ......................................................................
Anmeldung.ascx .....................................................................
Bestellung.ascx ......................................................................
Danke.ascx ..........................................................................
Kundenkonto.ascx ...................................................................
NeuerKunde.ascx ....................................................................
Abschlusstest und Bemerkungen ..........................................................
Test .................................................................................
Abschlussbemerkungen ..............................................................
1605
1610
1610
1610
1611
1613
1616
1617
1618
1621
1623
1623
1624
1624
1625
1631
1633
1634
1637
1641
1642
1645
1646
1646
1648
1648
1649
Stichwortverzeichnis
1651
...................................................................
668
Kapitel 10:
SQLite – Ein Mini ganz groß
In diesem Kapitel wollen wir Ihnen eine sinnvolle Alternative sowohl für den meist überdimensionierten
Einsatz des Microsoft SQL Servers, egal ob Express oder LocalDB, als auch für die Verwendung von Microsoft Access-Datenbanken als lokale Datenspeicher vorstellen.
Die Hauptforderungen nach
■ einfacher Installation/Distribution
■ Unterstützung bekannter Technologien (ADO.NET, LINQ to SQL, Entity Framework)
■ Aufhebung der Restriktionen bezüglich der maximalen Datenbankgröße1
■ Unterstützung für Datenbindung
■ gute Performance
■ Plattformunabhängigkeit des Datenformats
■ und, last but not least, die Datensicherheit
werden von dem im Folgenden vorgestellten SQLite in jedem Fall erfüllt. Das hat mittlerweile auch Microsoft erkannt – SQLite fungiert neuerdings als Mini-Datenbank für die Windows Store Apps 2. Grund für diesen Rückgriff auf eine externe Lösung ist der gänzliche Mangel an hauseigener Datenbankunterstützung für
diese Apps, die vorhandene IndexedDB ist für VB-Apps derzeit nicht nutzbar.
H INW EIS
Wir beschränken uns an dieser Stelle ganz bewusst auf lokale Datenspeicher, viele Anwendungen erfordern
nach wie vor keine Server-Infrastruktur und werden mit viel zu viel Ballast (zusätzliche Dienste, Probleme mit UAC, Datensicherung etc.) beim Kunden »abgeworfen«. Administratoren und Anwender sind Ihnen sicher dankbar dafür, wenn Sie eine
einfach installierbare Anwendung anbieten, die nicht gleich das gesamte System »umgräbt«, um ein paar Datensätze zu
speichern. Vielfach reicht auch schon eine XML-Datei, aber das ist eine andere Geschichte.
Was ist eigentlich SQLite?
Bei SQLite handelt es sich um eine Desktop-Datenbankengine, die im Gegensatz zum SQL Server ohne eine
extra Server-Anwendung auskommt. Die komplette Funktionalität wird von einer DLL bereitgestellt, die
Anwendung greift direkt auf den eigentlichen Datenspeicher zu. Der Clou an dieser Lösung: Sie können
trotz allem mit SQL als Abfragesprache arbeiten, müssen sich also nicht erst an eine neue Schnittstelle
gewöhnen3.
Einen grundsätzlichen Überblick zum Datenformat, zur verwendeten SQL-Syntax und zur DLL-Schnittstelle bietet Ihnen die folgende Website
WWW
http://www.sqlite.org/
1
Insbesondere dieser Punkt dürfte für viele Programmierer von Interesse sein, ist doch das Datenlimit von 2 GByte bei Access-Datenbanken nicht mehr zeitgemäß.
2
Zumindest so lange, bis Microsoft endlich eine eigene Lösung auf die Beine gestellt hat.
3
Am besten können Sie SQLite noch mit dem SQL Server Compact vergleichen, beide haben einen konzeptionell ähnlichen Ansatz.
Was ist eigentlich SQLite?
669
Im Folgenden wollen wir Ihnen mit einer unverbindlichen Gegenüberstellung der Vor- und Nachteile die
Entscheidung für oder gegen SQLite erleichtern.
Vorteile
Davon bietet SQLite jede Menge:
■ Die Datenbankengine ist winzig im Vergleich zu den etablierten Produkten (die DLL hat lediglich eine
Größe von ungefähr 1 MB).
■ Es ist keinerlei administrativer Aufwand notwendig, wenn Sie mal vom Speichern der eigentlichen
Datendatei absehen.
■ Das Format ist ideal für die Verwendung im Zusammenhang mit dem Compact Framework, da geringer
Ressourcenbedarf.
■ Alle Daten sind in einer Datei zusammengefasst, endlose Dateilisten, wie bei dBase oder Paradox, sind
nicht zu befürchten.
■ Die komplette Engine befindet sich in einer bzw. zwei Dateien (Compact Framework).
■ SQLite implementiert eine Großteil der SQL92-Spezifikation, Sie können also Ihre SQL-Know-How
weiter nutzen und müssen nicht umlernen.
■ SQLite-Datenbanken sind plattformkompatibel, d.h., Sie können die Datei problemlos mit anderen Sys-
temen auslesen und bearbeiten. Für fast jede Plattform und Programmiersprache werden entsprechende
Schnittstellen angeboten. Dies ist im Zusammenhang mit dem Datenaustausch zu Android- und iOSAnwendungen interessant.
■ SQLite ist in einigen Punkten schneller1 als eine entsprechende SQL Server Compact-Datenbank und die
Dateien sind kleiner. Im Gegensatz zum SQL Server Compact kann man bei einer maximalen Daten bankgröße von 2 Terabyte kaum noch von einer Größenbegrenzung sprechen.
■ Datenbanken können verschlüsselt werden.
■ Unterstützung für Trigger, Views und Constraints.
■ SQLite unterstützt verschiedene Formen der Volltextsuche, ein Feature, auf das wir z.B. bei Access-
Datenbanken schon lange warten.
■ Es sind ADO.NET 2.0 Provider verfügbar, auch die Verwendung des Entity Frameworks ist möglich.
■ Optional ist auch ein Zugriff per ODBC-Treiber möglich.
■ SQLite ist komplett kostenlos, der Quellcode ist ebenfalls verfügbar.
■ SQLite ist eine der wenigen Datenbankengines, die Sie derzeit in einer WinRT-App überhaupt zum
Laufen bekommen.
H INW EIS
Insbesondere der letzte Punkt ist ein echtes »Killerfeature«, wir gehen ab Seite 695 auf die spezifische Lösung
im Rahmen von WinRT ein.
1
Hier kommt es jedoch auf eine sinnvolle Indizierung der Tabellen an, andernfalls bricht die Performance recht schnell ein.
670
Kapitel 10:
SQLite – Ein Mini ganz groß
Nachteile
Jede Medaille hat zwei Seiten und so müssen Sie auch bei SQLite mit einigen Einschränkungen und Nachteilen leben.
■ Grundsätzlich sollten Sie immer das Konzept als Desktop-Datenbank im Auge behalten. Sie können
zwar mit mehreren Anwendungen auf die Datendatei zugreifen, allerdings ist der Schreibmechanismus
der Engine etwas eigenwillig, nur ein Prozess kann exklusiv auf die Datenbank zugreifen, Lesezugriffe
werden in dieser Zeit geblockt.
■ Keine Unterstützung für Stored Procedures und UDFs, Sie können jedoch eigene Scalar- und Aggre-
gat-Funktionen schreiben, die als Callback in Ihrer Anwendung abgelegt sind.
■ Es sind keine geschachtelten Transaktionen möglich.
■ Keine direkte Replikationsunterstützung, Sie können jedoch eine zweite Datenbank mit ATTACH ein-
binden und nachfolgend die Daten mit einer Abfrage über die betreffenden Tabellen synchronisieren.
■ Keine Unterstützung für Nutzer- und Rechteverwaltung, es handelt sich um eine Desktop-Datenbank,
die Sie jedoch verschlüsseln können.
Vorbereitungen
Haben Sie sich für SQLite als Datenformat entschieden, ist der nächste Schritt die Auswahl eines geeigneten
Datenproviders, der uns auch unter .NET wie gewohnt zur Verfügung steht.
Download/Installation
Die Autoren haben sich in diesem Fall für System.Data.SQLite, einen kostenlosen Wrapper und ADO.NET 2.0/3.5-Provider, entschieden, da dieser sehr gut dokumentiert und auch aktuell ist. Ganz nebenbei ist
auch eine entsprechende Integration in Visual Studio vorhanden. Sie können also die Datenbanken, wie
vom Microsoft SQL Server gewohnt, in der Visual Studio-IDE bearbeiten und abfragen (Server-Explorer).
Herunterladen können Sie die Installation unter der Adresse:
WWW
http://system.data.sqlite.org/
Laden Sie das Setup for 32-bit Windows (.NET Framework 4.5) herunter, wenn Sie über Visual Studio 2012
verfügen, für Visual Studio 2010 nutzen Sie das Setup for 32-bit Windows (.NET Framework 4.0).
H INW EIS
Achten Sie darauf, für welche Framework-Version Sie die Installation herunterladen!
Nach dem Download führen Sie das Setup-Programm aus, um die Designtime-Unterstützung in Visual Studio zu integrieren.
Die Besonderheit dieses Projekts ist eine Unterstützung sowohl für das komplette, als auch für das Compact-Framework. Arbeiten Sie mit dem normalen Framework, wird für Ihr Projekt bzw. das Zielsystem
lediglich die Datei System.Data.SQLite.DLL benötigt, in dieser befindet sich die SQLite-Engine und der für
Vorbereitungen
671
uns wichtige .NET-Wrapper. Für den Einsatz mit dem Compact Framework müssen Sie die Dateien System.Data.-SQLite.DLL (Unterordner \\CompactFramework) und SQLite.Interop.066.DLL auf dem Zielsystem bereitstellen.
H INW EIS
System.Data.SQLite ist »lediglich« ein .NET-Wrapper für die originale SQLite-Engine (aktuell 3.7.15.2), Sie
profitieren also auch automatisch von Verbesserungen und Neuerungen an der SQLite-Engine.
Mehr über die SQLite-Engine erfahren Sie unter folgender Adresse:
WWW
http://www.sqlite.org/docs.html
Integration in Ihr VB-Projekt
Möchten Sie den Provider in Ihr Projekt integrieren, fügen Sie zunächst einen Verweis auf die Assembly
System.Data.SQLite hinzu und legen die Eigenschaft Lokale Kopie auf True fest. Benötigen Sie zusätzlich
auch Unterstützung für LINQ, fügen Sie noch die Assembly System.Data.SQLite.Linq hinzu.
Der einfachste Weg zur Integration in Ihr VB-Projekt führt jedoch über den NuGet-Manager. Wählen Sie
eines der vier möglichen Pakete und klicken Sie auf Installieren:
Abbildung 10.1 Installation per NuGet-Paket
Sollten Sie das Paket System.Data.SQLite (x86/x64) gewählt haben, werden Ihrem Projekt zwei Unterverzeichnisse x86 und x64 hinzugefügt, in denen jeweils die plattformspezifische SQLite.Interop.dll abgelegt ist.
Im Hauptverzeichnis finden Sie die Assembly System.Data.SQLite.dll.
672
Kapitel 10:
SQLite – Ein Mini ganz groß
Datenbank-Tools
Eine Datenbank-Engine ist ja gut und schön, aber wer hat schon Lust, Datenbanken ausschließlich per Code
zu erstellen bzw. zu administrieren? Aus diesem Grund möchten wir zunächst einen Blick auf einige der
verfügbaren Werkzeuge werfen, bevor wir auf die Details der Programmierung mit VB eingehen.
Verwalten von SQLite-Datenbanken mit Visual Studio
Dank vollständiger Integration in die Visual Studio-IDE stellt es kein Problem dar, über den Server-Explorer
eine neue Datenbank zu erzeugen. Wählen Sie einfach im Server-Explorer die Schaltfläche Mit Datenbank
verbinden und ändern Sie die Datenquelle in SQLite Database File. Der dazugehörige Datenanbieter .NET
Framework DataProvider for SQLite ist bereits automatisch ausgewählt (siehe folgende Abbildung).
Abbildung 10.2 Neue SQLite-Datenbank erzeugen
Im eigentlichen Verbindungsdialog können Sie jetzt die neue Datenbank erzeugen. Legen Sie hier auch
Page-Size und Cache-Size fest. Das Date-/Time-Format belassen Sie am besten bei ISO-8601 (formatierte
Zeichenkette). Mit Synchronisation ist das Verhalten beim Speichern von Änderungen gemeint:
■ die Einstellung Normal führt dazu, dass Änderungen immer dann geschrieben werden, wenn kritische
Codeabschnitte durchlaufen werden
■ Full führt zu Schreibzugriffen bei jeder Änderung und
■ Off bedeutet, dass die Schreibpuffer nicht explizit geschrieben werden
Herunterladen

Datenbank-Programmierung mit Visual Basic 2012