|
Inhaltsüberblick |
6 |
|
|
Inhaltsverzeichnis |
8 |
|
|
Einleitung |
30 |
|
|
Für wen ist dieses Buch? |
31 |
|
|
Was lesen Sie in diesem Buch? |
31 |
|
|
Auf zu neuen Ufern |
35 |
|
|
Ein Loblied auf .NET |
36 |
|
|
Im Web geht es weiter |
37 |
|
|
Danksagung |
38 |
|
|
Was ist neu bei Visual Basic.NET 1.1 und Visual Studio .NET 2003? |
38 |
|
|
Was ist neu in der 2. Auflage? |
39 |
|
|
Teil 1 Überblick und die ersten Schritte mit .NET |
40 |
|
|
1 System.Start |
42 |
|
|
1.1 Eine kleine Konsolenanwendung |
43 |
|
|
1.2 Eine kleine Windows-Anwendung |
46 |
|
|
Ein Programm wieder beenden |
51 |
|
|
Eine verbesserte Version des Devisenumrechners |
51 |
|
|
Der Devisenrechner arbeitet mit mehreren Währungen |
52 |
|
|
Die Devisendaten im XML-Format |
56 |
|
|
Die Devisendaten aus dem Internet |
58 |
|
|
1.3 Eine kleine Webanwendung mit ASP.NET |
60 |
|
|
1.4 Der Devisenrechner als Webservice |
67 |
|
|
Einen Webservice von einer Anwendung aus aufrufen |
72 |
|
|
1.5 Rückblick und Ausblick |
75 |
|
|
1.6 Ein paar Dinge, die Sie am Anfang garantiert »falsch« machen werden |
77 |
|
|
2 Das .NET Framework erklärt |
80 |
|
|
2.1 Visual Basic .NET = Visual Basic + .NET |
81 |
|
|
2.2 Das .NET Framework in zehn Minuten |
82 |
|
|
Ein erstes Beispiel |
85 |
|
|
2.3 Die Bestandteile des .NET Frameworks |
87 |
|
|
2.4 Die Rolle der Common Language Runtime (CLR) |
87 |
|
|
Die Aufgabe der CLR |
87 |
|
|
Die Laufzeitdienste der CLR |
88 |
|
|
2.5 Das Common Type System (CTS) für universelle Zusammenarbeit |
89 |
|
|
2.6 Vom Quelltext zum IL-Code |
90 |
|
|
Sind IL-Programme geschützt? |
92 |
|
|
2.7 Die .NET-Klassenbibliothek |
93 |
|
|
Der Class Viewer aus dem .NET Framework SDK |
94 |
|
|
2.8 Die Rolle der Assemblies |
95 |
|
|
Alles steht im Manifest |
96 |
|
|
Die .NET-Klassenbibliothek besteht aus Assemblies |
97 |
|
|
Starke Namen, schwache Namen |
97 |
|
|
Hier stecken sie also alle: der Global Assembly Cache (GAC) |
99 |
|
|
Starke Namen anlegen |
101 |
|
|
2.9 Die Vorteile für Visual Basic-Programmierer |
104 |
|
|
Vereinheitlichung |
105 |
|
|
Vereinfachung durch Laufzeitdienste |
105 |
|
|
Leistungsfähigere Programmiersprachen |
105 |
|
|
Objektorientierung |
106 |
|
|
Programmieren von Webanwendungen |
106 |
|
|
Sicherheit |
107 |
|
|
Versionierung |
107 |
|
|
Gemischtsprachige Programmierung |
108 |
|
|
Realisierung verteilter Anwendungen |
109 |
|
|
2.10 Auf zu anderen Plattformen mit dem CLI |
110 |
|
|
3 Visual Studio .NET im Überblick |
112 |
|
|
3.1 Was kann Visual Studio .NET? |
113 |
|
|
Möglichkeiten, die nur angedeutet werden können |
114 |
|
|
Die wichtigsten Unterschiede zur IDE von Visual Basic 6.0 |
115 |
|
|
3.2 Kurze Tour durch die Entwicklungsumgebung |
116 |
|
|
Das Einstellen eines Benutzerprofils |
116 |
|
|
Die individuelle Startseite |
116 |
|
|
Die Auswahl eines Projekttyps |
117 |
|
|
Der Aufbau eines Projekts |
119 |
|
|
3.3 Der Programmeditor |
119 |
|
|
3.4 Ein Überblick über die wichtigsten Fenster |
121 |
|
|
Der Projektmappen-Explorer |
121 |
|
|
Die Klassenansicht |
122 |
|
|
Der Server-Explorer |
123 |
|
|
Die Ressourcenansicht |
125 |
|
|
Das Eigenschaftenfenster |
125 |
|
|
Die Toolbox |
126 |
|
|
Der Objektbrowser |
127 |
|
|
Die Aufgabenliste |
130 |
|
|
Das Befehlsfenster (Direktfenster) |
131 |
|
|
Das Ausgabenfenster |
132 |
|
|
3.5 Die wichtigsten Arbeitsschritte |
132 |
|
|
Das Neuanlegen eines Projekts |
132 |
|
|
Öffnen von Projekten |
132 |
|
|
Öffnen über den Verlauf-Ordner |
133 |
|
|
Hinzufügen von Verweisen |
134 |
|
|
Speichern einzelner Dateien |
134 |
|
|
Das Starten, Beenden und Unterbrechen von Projekten |
134 |
|
|
Suchen und Ersetzen im Programm |
139 |
|
|
3.6 Tipps für die tägliche Praxis |
140 |
|
|
Umschalten auf den ganzen Bildschirm |
140 |
|
|
Drucken |
140 |
|
|
Fenster verschieben ohne anzudocken |
140 |
|
|
Umschalten zwischen Fenstern |
140 |
|
|
Hinzufügen externer Tools |
141 |
|
|
Bearbeiten von Bitmaps |
141 |
|
|
Bearbeiten der Symbolleiste |
142 |
|
|
3.7 Arbeiten mit der Hilfe |
142 |
|
|
Hilfeseiten werden als Register angezeigt |
143 |
|
|
Setzen von Favoriten |
143 |
|
|
Suchen in der Hilfe |
144 |
|
|
Suchergebnisse erneut sichtbar machen |
144 |
|
|
Indexsuche |
145 |
|
|
Die dynamische Hilfe |
145 |
|
|
Bearbeiten und Erstellen von Filtern |
145 |
|
|
3.8 Einstellen von Optionen |
146 |
|
|
3.9 Tastatur-Shortcuts |
147 |
|
|
Teil 2 Visual Basic .NET-Programmiergrundlagen |
150 |
|
|
4 Die Kernsprachelemente von Visual Basic .NET |
152 |
|
|
4.1 Der allgemeine Programmaufbau |
153 |
|
|
Kommentare |
154 |
|
|
Ein allgemeiner Rahmen für (fast) alle Situationen |
154 |
|
|
Module und warum sie nicht wirklich wichtig sind |
155 |
|
|
4.2 Das »Objektprinzip« bei Visual Basic .NET – fünf einfache Regeln |
156 |
|
|
4.3 Variablen, Konstanten, Zuweisungen und Operatoren |
157 |
|
|
Variablen |
158 |
|
|
Konstanten |
162 |
|
|
Zuweisungen |
163 |
|
|
Operatoren |
164 |
|
|
Datentypen |
166 |
|
|
Die Frage der Genauigkeit |
169 |
|
|
4.4 Arrays |
172 |
|
|
4.5 Entscheidungen |
175 |
|
|
4.6 Programmschleifen |
180 |
|
|
4.7 Funktionen und Prozeduren |
184 |
|
|
Benennung von Funktionsparametern |
186 |
|
|
Parameterübergabe als Wert |
186 |
|
|
Optionale Parameter |
187 |
|
|
Funktion mit einer variablen Anzahl an Parametern |
187 |
|
|
Funktionen mit Arrays als Rückgabewert |
188 |
|
|
4.8 Umgang mit Strings |
189 |
|
|
String-Operationen in der Praxis |
190 |
|
|
Elemente aus einem String entfernen |
194 |
|
|
Die String-Klasse im Überblick |
196 |
|
|
Die String-Funktionen aus dem Microsoft.VisualBasic-Namespace |
198 |
|
|
Die StringBuilder-Klasse für den effektiven Umgang mit Strings |
200 |
|
|
4.9 Mathematische Funktionen |
202 |
|
|
4.10 Formalitäten bei Visual Basic .NET |
205 |
|
|
Der Option-Befehl |
205 |
|
|
Der Imports-Befehl |
206 |
|
|
Der With-Befehl |
207 |
|
|
Sprünge im Programm – der GoTo-Befehl |
207 |
|
|
Eingaben über die Tastatur entgegennehmen |
208 |
|
|
Ausgaben in einer Konsolenanwendung |
209 |
|
|
4.11 Alle Visual Basic .NET-Befehle im Überblick |
214 |
|
|
Befehle älterer Versionen, die nicht mehr verwendet werden |
217 |
|
|
5 Objektorientierte Programmierung mit Visual Basic .NET |
220 |
|
|
5.1 Was ist eine Klasse und was ist ein Objekt? |
221 |
|
|
Klassen besitzen Mitglieder |
221 |
|
|
5.2 Klassen über den Class-Befehl definieren |
222 |
|
|
Die Klasse erhält ein Mitglied |
223 |
|
|
5.3 Klassen instanziieren – der Konstruktor ist immer dabei |
224 |
|
|
Der Spezialwert Nothing |
226 |
|
|
Vorsicht vor später Bindung |
226 |
|
|
Die Rolle des Konstruktors |
227 |
|
|
Konstruktoren können überladen werden |
229 |
|
|
5.4 Die Rolle von Shared |
232 |
|
|
5.5 Felder hinzufügen |
232 |
|
|
5.6 Eigenschaften hinzufügen |
235 |
|
|
5.7 Methoden hinzufügen |
238 |
|
|
5.8 Klassen ableiten – Vererbung |
239 |
|
|
Der Gültigkeitsbereich Protected |
243 |
|
|
5.9 Eigenschaften und Methoden, die für Klassen stehen |
244 |
|
|
5.10 Ein abschließendes Beispiel |
246 |
|
|
5.11 Sich selbst speichernde Objekte |
252 |
|
|
5.12 Zusammenfassung zum Thema Klassen |
253 |
|
|
6 Überblick über die .NET- Basisklassen |
254 |
|
|
6.1 Ein Blick aus der Vogelperspektive |
255 |
|
|
6.2 Das Prinzip der Namespaces |
257 |
|
|
6.3 Ein Überblick über die Namespaces der .NET- Klassenbibliothek |
259 |
|
|
6.4 Die Environment-Klasse als Beispiel zum Kennenlernen |
263 |
|
|
Die Klasse aufrufen |
266 |
|
|
6.5 Der Ursprung aller Klassen: System.Object |
267 |
|
|
6.6 Die »12 wichtigsten« Klassen |
271 |
|
|
6.7 Ein kurzer Ausflug nach Microsoft.VisualBasic |
273 |
|
|
6.8 Die Bestandteile der .NET-Basisklassen im Überblick |
274 |
|
|
6.9 .NET-Klassen erweitern |
276 |
|
|
6.10 Alles über .NET-Klassen |
278 |
|
|
Aufruf einer Übersicht über die .NET-Klassenbibliothek |
278 |
|
|
6.11 Noch einmal der Objektbrowser |
281 |
|
|
7 Klassen für Fortgeschrittenere |
284 |
|
|
7.1 Klassen als Typen |
285 |
|
|
Typen abfragen |
285 |
|
|
Typen und Objekte vergleichen |
286 |
|
|
Kurzer Überblick über die Type-Klasse |
286 |
|
|
7.2 Überschreiben von Mitgliedern |
288 |
|
|
Das Shadows-Schlüsselwort |
290 |
|
|
7.3 Delegates |
293 |
|
|
Delegates in der Theorie |
294 |
|
|
Delegates in der Praxis |
295 |
|
|
Multicast-Delegates |
297 |
|
|
7.4 Ereignisse |
300 |
|
|
Ein Ereignis definieren |
300 |
|
|
Ereignisse über WithEvents mit Ereignisprozeduren verbinden |
302 |
|
|
7.5 Abstrakte Basisklassen |
303 |
|
|
7.6 Schnittstellen – wozu sie wirklich gut sind |
305 |
|
|
Schnittstellen definieren |
305 |
|
|
Auch Schnittstellen sind Typen |
306 |
|
|
Schnittstellen implementieren |
306 |
|
|
Feststellen, ob eine Klasse eine Schnittstelle unterstützt |
307 |
|
|
Klassen, die mehrere Schnittstellen implementieren |
307 |
|
|
Schnittstellen vererben |
308 |
|
|
Schnittstellen als Parameter |
308 |
|
|
Ein abschließendes Beispiel |
309 |
|
|
Schnittstellen oder abstrakte Basisklassen? |
313 |
|
|
7.7 Schnittstellen in den .NET-Basisklassen |
314 |
|
|
Das Dispose-Entwurfsmuster |
315 |
|
|
Sortieren von Arrays mit Objekten nach eigenen Kriterien |
319 |
|
|
Eigene Formatbezeichner mithilfe von IFormattable |
322 |
|
|
7.8 Ein Wort zur Polymorphie |
323 |
|
|
7.9 Me, MyBase und MyClass |
327 |
|
|
Das Me-Schlüsselwort |
327 |
|
|
Das MyBase-Schlüsselwort |
328 |
|
|
Das MyClass-Schlüsselwort |
329 |
|
|
7.10 Enumerationen |
330 |
|
|
7.11 Alle Schlüsselwörter der objektorientierten Programmierung im Überblick |
330 |
|
|
8 Windows-Formulare und Steuerelemente kennen lernen |
334 |
|
|
8.1 Ein kurzer Überblick zur Einstimmung |
335 |
|
|
Hinter jedem Windows-Formular steht die Klasse Form |
335 |
|
|
Windows-Formulare hinzufügen |
337 |
|
|
Die (neue) Toolbox |
337 |
|
|
Kompatibilität zu Visual Basic 6.0 |
337 |
|
|
8.2 Eine MDI-Anwendung Schritt für Schritt |
338 |
|
|
8.3 Ein Windows-Formular im Überblick |
347 |
|
|
Allgemeines zu Größenangaben |
352 |
|
|
Das Einstellen von Größenangaben |
352 |
|
|
Das Festlegen von Positionsangaben |
353 |
|
|
Der Umgang mit Fonts |
353 |
|
|
Der Umgang mit Bitmaps |
355 |
|
|
Der Umgang mit Icons |
355 |
|
|
Steuerelemente passen automatisch ihre Größe an |
356 |
|
|
Steuerelemente an einem Rand verankern |
356 |
|
|
8.4 Das Prinzip der Ereignisverarbeitung |
356 |
|
|
Die Auswahl der richtigen Ereignisprozedur |
357 |
|
|
Die Rolle der »Überschreibungen« |
359 |
|
|
Der allgemeine Aufbau einer Ereignisprozedur |
359 |
|
|
Tastaturereignisse |
360 |
|
|
Mausereignisse |
361 |
|
|
Ziehen- und Ablegen-Ereignisse |
362 |
|
|
Validierungsereignisse |
362 |
|
|
Ereignisse, die sich auf die optische Darstellung beziehen |
363 |
|
|
8.5 Die Steuerelemente im Überblick |
364 |
|
|
Die Toolbox |
366 |
|
|
Allgemeine Mitglieder bei den Steuerelementen |
367 |
|
|
Grafikoperationen |
367 |
|
|
Die Label-Klasse |
368 |
|
|
Die LinkLabel-Klasse |
369 |
|
|
Die Button-Klasse |
370 |
|
|
Die TextBox-Klasse |
371 |
|
|
Die MainMenu-Klasse |
374 |
|
|
Die CheckBox-Klasse |
377 |
|
|
Die RadioButton-Klasse |
377 |
|
|
Die GroupBox-Klasse |
378 |
|
|
Die Panel-Klasse |
379 |
|
|
Die PictureBox-Klasse |
379 |
|
|
Die ListBox-Klasse |
381 |
|
|
Die CheckedListBox-Klasse |
387 |
|
|
Die ComboBox-Klasse |
388 |
|
|
Die HScrollBar- und VScrollBar-Klasse |
388 |
|
|
Die Timer-Klasse |
389 |
|
|
Wo gibt es mehr? |
390 |
|
|
8.6 Die Klassen im Namespace System.Windows.Forms |
391 |
|
|
Eine Windows-Anwendung mit Notepad |
391 |
|
|
Ableiten von Steuerelementen |
394 |
|
|
8.7 Spezialitäten bei Windows-Formularen und Steuerelementen |
396 |
|
|
Formulare besitzen zwei Namen |
396 |
|
|
Umschalten auf den Programmeditor |
397 |
|
|
Festlegen des MDI-Hauptfensters |
397 |
|
|
Noch einmal: Die Basisklassenereignisse und die Instanzereignisse |
399 |
|
|
Zugriff auf die Nachrichtenschleife |
399 |
|
|
8.8 Die wichtigsten »Neuerungen« bei Windows- Formularen |
401 |
|
|
8.9 Die wichtigsten Fakten im Überblick |
402 |
|
|
Teil 3 Die Programmierpraxis |
404 |
|
|
9 Fortgeschrittenere Sprachelemente von Visual Basic .NET |
406 |
|
|
9.1 Der Gültigkeitsbereich von Variablen |
407 |
|
|
Der Gültigkeitsbereich »Blockebene« |
407 |
|
|
Der Gültigkeitsbereich »Prozedurebene« |
407 |
|
|
Der Gültigkeitsbereich »Klassenebene« |
407 |
|
|
Der Gültigkeitsbereich »Assembly-Ebene« |
408 |
|
|
»Globale« Variablen |
408 |
|
|
9.2 Die formatierte Ausgaben |
409 |
|
|
Formatierung von Strings |
412 |
|
|
Alles eine Frage der Kultur – länderspezifische Einstellungen berücksichtigen |
412 |
|
|
9.3 Werttypen versus Referenztypen |
416 |
|
|
Heap oder Stack? |
416 |
|
|
Die Rolle von System.ValueType |
417 |
|
|
ByVal oder ByRef – Parameterübergabe an Funktionen |
418 |
|
|
Boxing und Unboxing |
421 |
|
|
9.4 Strukturen |
423 |
|
|
Strukturen auf Wunsch mit Konstruktor |
425 |
|
|
Strukturen und Zeichenketten fester Länge |
426 |
|
|
9.5 Namespaces definieren |
427 |
|
|
9.6 Aufruf von API-Funktionen |
428 |
|
|
Unterschiede beim Aufruf im Vergleich zu früheren Visual Basic-Versionen |
429 |
|
|
Ein einfaches Beispiel |
429 |
|
|
Ein Aufruf mit dem -Attribut |
430 |
|
|
API-Aufruf mit Zeichenketten fester Länge |
432 |
|
|
Aufruf einer Callback-Funktion mit Delegate-Objekt |
433 |
|
|
Nicht gerne gesehen, aber machbar – direkte Zugriffe auf den Arbeitsspeicher |
435 |
|
|
9.7 Der Zugriff auf die Kommandozeile |
437 |
|
|
Die Main-Funktion und ihre Parameter |
437 |
|
|
Zugriff auf die Kommandozeile über die Environment-Klasse |
437 |
|
|
10 Dateizugriffe mit Visual Basic .NET |
440 |
|
|
10.1 Allgemeine Dateizugriffe |
441 |
|
|
Ein kurzer Überblick |
441 |
|
|
Die StreamReader-Klasse |
442 |
|
|
Die StreamWriter-Klasse |
444 |
|
|
Die FileStream-Klasse |
446 |
|
|
Der Unterschied zwischen FileStream und StreamReader |
446 |
|
|
Das Prinzip der Arbeitsteilung |
447 |
|
|
10.2 Die Rolle der Streams |
449 |
|
|
Die Stream-Klasse |
450 |
|
|
Die FileStream-Klasse |
451 |
|
|
10.3 Binäre Daten schreiben und lesen |
455 |
|
|
10.4 Überblick über den System.IO-Namespace |
457 |
|
|
10.5 Zugriffe auf das Dateisystem |
458 |
|
|
Die File-Klasse |
460 |
|
|
Die FileInfo-Klasse |
461 |
|
|
Die Directory-Klasse |
462 |
|
|
Die DirectoryInfo-Klasse |
462 |
|
|
Die Path-Klasse |
463 |
|
|
10.6 Arrays in einer Datei speichern und wieder auslesen |
464 |
|
|
10.7 Die Kompatibilitätsfunktionen (zur Entspannung) |
466 |
|
|
10.8 Verzeichnisse überwachen |
469 |
|
|
Kurze Aufmunterung für zwischendurch |
471 |
|
|
10.9 Umgang mit unterschiedlichen Zeichensätzen – die Encoding-Klassen |
472 |
|
|
10.10 Asynchrones Lesen einer Textdatei |
474 |
|
|
11 Strukturierte Ausnahmebehandlung und Debuggen |
476 |
|
|
11.1 Wie treten Ausnahmen auf? |
477 |
|
|
11.2 Strukturierte Ausnahmebehandlung über den Try Befehl |
479 |
|
|
Der Try Catch-Befehl |
481 |
|
|
Der On Error GoTo-Befehl |
481 |
|
|
Informationen über eine Ausnahme erhalten |
482 |
|
|
11.3 Die Exception-Klasse im Überblick |
484 |
|
|
Ein allgemeiner Rahmen für eine Ausnahmebehandlung |
487 |
|
|
Erweiterung mit dem When-Schlüsselwort |
487 |
|
|
Gemeinsamer Ausgang für die Ausnahmebehandlung – der Finally-Befehl |
488 |
|
|
Wie viele Ausnahmen kann ein »Befehl« auslösen? |
488 |
|
|
Ausnahmebehandlung bei verschachtelten Prozeduren |
489 |
|
|
Ausnahmen im Debugger |
490 |
|
|
11.4 Ausnahmen auslösen für den Throw-Befehl |
491 |
|
|
11.5 Eigene Ausnahmen definieren |
493 |
|
|
11.6 Ereignisse protokollieren |
496 |
|
|
11.7 Der integrierte Debugger |
499 |
|
|
Die wichtigsten Arbeitsschritte mit dem integrierten Debugger |
500 |
|
|
11.8 Die wichtigsten Fenster des integrierten Debuggers |
502 |
|
|
11.9 Tipps für die Praxis |
505 |
|
|
11.10 Der Microsoft CLR-Debugger |
506 |
|
|
12 Benutzeroberflächen für Windows-Anwendungen |
510 |
|
|
12.1 Allgemeines zu Dialogfeldern |
511 |
|
|
Dialogfelder mit ShowDialog anzeigen |
512 |
|
|
Feststellen eines Standardbuttons für Bestätigung und Abbruch |
513 |
|
|
Optische Einstellungen bei Dialogfeldern |
513 |
|
|
Festlegen, was beim Formularstart geschieht |
514 |
|
|
Formulare nur auf Bestätigung schließen |
514 |
|
|
Windows-Anwendungen über Main starten |
515 |
|
|
Fenster immer an der Spitze anzeigen |
515 |
|
|
Transparente Fenster |
515 |
|
|
Die Startposition eines Fensters festlegen |
516 |
|
|
Einstellen der Tabreihenfolge |
516 |
|
|
12.2 Der Umgang mit mehreren Formularen |
517 |
|
|
12.3 Standarddialogfelder |
520 |
|
|
Das Standarddialogfeld für die Auswahl einer Datei zum Öffnen |
520 |
|
|
Das Standarddialogfeld für die Auswahl einer Datei zum Speichern |
522 |
|
|
Das Standarddialogfeld zur Auswahl von Schrifteigenschaften |
523 |
|
|
Das Standarddialogfeld zur Auswahl einer Farbe |
525 |
|
|
Das Standarddialogfeld zur Auswahl eines Druckers |
525 |
|
|
12.4 Menüs |
527 |
|
|
Sich selbst zeichnende Menüs |
529 |
|
|
12.5 Symbolleisten |
532 |
|
|
12.6 Spezielle Steuerelemente der Toolbox |
535 |
|
|
Die StatusBar-Klasse |
535 |
|
|
Die ListView-Klasse |
536 |
|
|
Die TreeView-Klasse |
540 |
|
|
Die TabControl-Klasse |
544 |
|
|
Die DateTimePicker-Klasse für die Datumsauswahl |
545 |
|
|
Die MonthCalendar-Klasse (für die Datumsauswahl) |
546 |
|
|
Die Splitter-Klasse |
548 |
|
|
Die RichTextBox-Klasse |
550 |
|
|
Fortschritte anzeigen mit der ProgressBar-Klasse |
554 |
|
|
Einstellen von Werten über die TrackBar-Klasse |
555 |
|
|
Die NotifyIcon-Klasse |
556 |
|
|
Die ErrorProvider-Klasse |
558 |
|
|
Die HelpProvider-Klasse |
559 |
|
|
Einbauen einer ToolTipp-Hilfe über die ToolTip-Klasse |
561 |
|
|
12.7 Steuerelemente zusammenfassen (Steuerelementefelder) |
562 |
|
|
12.8 Windows-Formulare vererben |
563 |
|
|
12.9 Ziehen und Ablegen |
564 |
|
|
Ziehen und Ablegen starten |
565 |
|
|
Auf eine Ablegen-Operation reagieren |
565 |
|
|
12.10 Drucken |
569 |
|
|
Der allgemeine Ablauf beim Drucken |
571 |
|
|
Auflisten der vorhandenen Drucker |
573 |
|
|
Einstellen der Seiteneigenschaften |
574 |
|
|
Eine Druckvorschau |
576 |
|
|
Ein abschließendes Beispiel |
577 |
|
|
13 .NET-Bibliotheken und Steuerelemente erstellen |
582 |
|
|
13.1 Klassenbibliotheken à la .NET |
583 |
|
|
Die Rolle der Module |
588 |
|
|
13.2 Die Rolle der Konfigurationsdatei AssemblyInfo.vb |
589 |
|
|
Die Rolle der Versionsnummer |
591 |
|
|
13.3 Einfache Windows-Steuerelemente selbst gemacht |
592 |
|
|
Steuerelemente direkt im Projekt »ableiten« |
595 |
|
|
Steuerelemente direkt von der Control-Klasse ableiten |
597 |
|
|
13.4 Windows-Steuerelement-Bibliothek-Projekte |
599 |
|
|
Die ISBNTextbox wird umgesetzt |
601 |
|
|
Die ISBNTextbox wird getestet |
604 |
|
|
Spezialitäten bei benutzerdefinierten Steuerelementen |
607 |
|
|
13.5 Sich selbst zeichnende Steuerelemente |
609 |
|
|
Runde Buttons? – Kein Problem |
609 |
|
|
13.6 Versionsnummern für Assemblies festlegen |
612 |
|
|
Anfertigen eines starken Namens |
613 |
|
|
Ein Assembly im GAC registrieren |
614 |
|
|
Config-Dateien anlegen |
616 |
|
|
Die .NET Framework Configuration-Konsole |
617 |
|
|
Ein Beispiel zum Schluss |
620 |
|
|
Teil 4 Fortgeschrittene Themen |
632 |
|
|
14 XML |
634 |
|
|
14.1 XML ganz einfach |
635 |
|
|
Ein Wort zu XML 1.0 |
636 |
|
|
Von Mythen und Märchen |
636 |
|
|
Ein kleines Beispiel |
638 |
|
|
Regeln für XML |
643 |
|
|
14.2 Der allgemeine Aufbau eines XML-Dokuments |
644 |
|
|
Die Rolle der Namespaces |
645 |
|
|
Die verschiedenen Bestandteile eines XML-Dokuments |
646 |
|
|
14.3 Ein erstes Beispiel mit Visual Basic .NET |
649 |
|
|
14.4 Überblick über den System.Xml-Namespace |
651 |
|
|
Die XmlDocument-Klasse |
653 |
|
|
Die XmlNode-Klasse |
656 |
|
|
Die XmlTextReader-Klasse für das schnelle Einlesen von XML Dokumenten |
658 |
|
|
Die XmlTextWriter-Klasse für das Schreiben von XML-Dokumenten |
663 |
|
|
Binäre Daten lesen und schreiben |
665 |
|
|
14.5 Spezialitäten mit XPath |
668 |
|
|
Der XPath-Namespace |
671 |
|
|
14.6 XML-Dokumente mit XSL transformieren |
674 |
|
|
Die Rolle von XSL |
674 |
|
|
Wie funktioniert XSL? |
676 |
|
|
Ein kleines Beispiel zum Abschluss |
679 |
|
|
14.7 Visual Studio .NET und XML |
681 |
|
|
14.8 Eine kleine XML-Anwendung zum Schluss |
683 |
|
|
14.9 .NET und die Rolle von XML |
684 |
|
|
15 Spezialitäten der .NET Basisklassen |
686 |
|
|
15.1 Collection-, Dictionary-, Stack- und HashTable- Klassen und vieles mehr |
687 |
|
|
Die Rolle der Schnittstellen |
689 |
|
|
Die ArrayList-Klasse |
690 |
|
|
Die HashTable-Klasse |
692 |
|
|
Die Queue-Klasse |
695 |
|
|
Die SortedList-Klasse |
696 |
|
|
Die Stack-Klasse |
698 |
|
|
Die BitArray-Klasse |
700 |
|
|
Auflistungen durchlaufen mit IEnumerator |
702 |
|
|
15.2 Der Umgang mit Attributen |
703 |
|
|
Ein wenig Theorie |
704 |
|
|
Benutzerdefinierte Attribute |
706 |
|
|
Benutzerdefinierte Attribute lesen |
709 |
|
|
15.3 Kurzer Exkurs zum Thema Multithreading |
711 |
|
|
Was ist ein Thread? |
712 |
|
|
Prozesse und Anwendungsdomänen (AppDomains) |
712 |
|
|
Überblick über die Thread-Klasse |
713 |
|
|
Die CurrentThread-Eigenschaft für den aktuellen Thread |
717 |
|
|
Die verschiedenen Zustände eines Threads |
717 |
|
|
Unterschiedliche Thread-Prioritäten |
718 |
|
|
Threads über die Join-Methode abstimmen |
719 |
|
|
Dateisuche mit Threads |
720 |
|
|
Synchronisationsprobleme mit dem SyncLock-Befehl lösen |
723 |
|
|
15.4 Typinformationen zur Laufzeit abfragen (Reflection) |
727 |
|
|
Die Rolle der Type-Klasse |
727 |
|
|
15.5 Zugriff auf die Registry |
728 |
|
|
15.6 Weitere Spezialitäten |
731 |
|
|
Umgang mit Raum und Zeit (die TimeSpan-Struktur) |
732 |
|
|
Umwandlung von Zeichenketten |
733 |
|
|
Objekte serialisieren |
735 |
|
|
Zugriffe auf die Zwischenablage |
738 |
|
|
Reguläre Ausdrücke |
739 |
|
|
Verschlüsselung |
742 |
|
|
Der Zugriff auf die serielle Schnittstelle |
745 |
|
|
16 Datenbankprogrammierung mit ADO.NET |
748 |
|
|
16.1 ADO.NET in fünf Minuten |
749 |
|
|
16.2 Die Rolle von ADO.NET in der Microsoft-Welt |
750 |
|
|
16.3 Überblick über die Klassen im Namespace System.Data |
752 |
|
|
16.4 Zugriff auf Jet-Datenbanken – Überblick über die Klassen im Namespace System.Data.Oledb |
757 |
|
|
Die Rolle des Eingabepromptes |
760 |
|
|
16.5 Zugriff auf SQL Server-Datenbanken – Überblick über die Klassen im Namespace System.Data.Sql... |
761 |
|
|
16.6 Einfache Beispiele zum Kennenlernen von ADO.NET |
763 |
|
|
Herstellen einer Verbindung und Abrufen von Datensätzen |
767 |
|
|
Die Rolle des Connection-Objekts |
768 |
|
|
Die Rolle des DataReaders |
769 |
|
|
Datensätze abrufen und in einem DataGrid darstellen |
771 |
|
|
Abrufen von Datensätzen über eine SQL-Abfrage mit Parametern |
773 |
|
|
Ausführen einer Jet-Abfrage |
775 |
|
|
Ausführen einer SQL-Aktionsabfrage |
777 |
|
|
Ausführen einer SQL-Abfrage, die genau einen Wert zurückgibt |
779 |
|
|
16.7 Der Aufruf von gespeicherten Prozeduren |
781 |
|
|
Aufruf einer gespeicherten Prozedur mit Out-Parameter |
784 |
|
|
Kurzer Ausflug zu den Visual Database Tools |
786 |
|
|
Neuanlegen gespeicherter Prozeduren |
787 |
|
|
Aufruf einer gespeicherten Prozedur |
787 |
|
|
Debuggen einer gespeicherten Prozedur |
788 |
|
|
16.8 Das universelle DataTable-Objekt |
790 |
|
|
Zeilen hinzufügen |
795 |
|
|
Auf Spalten zugreifen |
795 |
|
|
Daten editieren |
797 |
|
|
Künstliche Einschränkungen über Contraints |
798 |
|
|
16.9 Das universelle DataSet |
799 |
|
|
Ein DataSet anlegen |
800 |
|
|
Ein DataSet mit Daten füllen |
800 |
|
|
Ein DataSet als XML speichern |
801 |
|
|
Ein DataSet direkt mit XML laden |
802 |
|
|
Beziehungen zwischen DataTables anlegen |
802 |
|
|
16.10 Das DataGrid stellt sich (endlich) vor |
805 |
|
|
Das Prinzip der Bindung |
806 |
|
|
Das Prinzip der Formatierung |
808 |
|
|
Einzelne Spalten formatieren – die DataGridTableStyle-Klasse |
809 |
|
|
Der »Trick« mit dem CurrencyManager |
811 |
|
|
16.11 Aktualisieren von Datenbanken |
814 |
|
|
Die Rolle des Datenadapters |
815 |
|
|
16.12 Drei Wege führen zum UPDATE-Kommando |
815 |
|
|
Der Command-Builder |
816 |
|
|
Der Datenadapter-Konfigurationsassistent |
817 |
|
|
16.13 Datenbindung bei Steuerelementen (und anderen »Tierchen«) |
821 |
|
|
Bindung an andere »Tierchen« |
823 |
|
|
16.14 Datenbankunterstützung bei Visual Studio .NET – die Visual Database Tools |
825 |
|
|
Der Server Explorer |
825 |
|
|
Datenadapter-Konfigurationsassistent |
827 |
|
|
Ein XML-Editor |
827 |
|
|
Ein XSD-Schemaeditor |
828 |
|
|
Die Datenkomponenten in der Toolbox |
829 |
|
|
16.15 ADO.NET und XML |
830 |
|
|
16.16 Spezialitäten bei ADO.NET |
839 |
|
|
Typisierte DataSets |
839 |
|
|
Umgang mit Bitmaps (BLOBs) |
843 |
|
|
Transaktionen |
846 |
|
|
Zugriff auf Excel-Tabellen und dBase-Dateien |
849 |
|
|
16.17 Zugriff auf die Datenbankstruktur mit ADOX und SQL DMO |
852 |
|
|
Schemainformationen mit ADO.NET abfragen |
852 |
|
|
ADOX |
854 |
|
|
SQL DMO |
854 |
|
|
16.18 Ein kurzer Abstecher zum Crystal Report Writer |
856 |
|
|
16.19 Zugriff auf Oracle SQL-Server-Datenbanken |
859 |
|
|
Allgemeines zum Zugriff auf eine Oracle-Datenbank |
860 |
|
|
Die ersten Schritte mit dem Microsoft .NET-Datenprovider |
861 |
|
|
16.20 Die Brücke zu ADO und ein direkter Vergleich |
864 |
|
|
Ein direkter Vergleich ADO zu ADO.NET |
866 |
|
|
Ein Wörtchen zu DAO und RDO |
867 |
|
|
Teil 5 Web und Netzwerke |
870 |
|
|
17 Webanwendungen mit Visual Basic .NET und ASP.NET |
872 |
|
|
17.1 Ein paar allgemeine Anmerkungen |
873 |
|
|
Was ist eine Webanwendung? |
875 |
|
|
Ein Blick zurück: ASP |
876 |
|
|
Was ist aus den IIS-Anwendungen geworden? |
880 |
|
|
Gibt es die ASP-Objekte noch? |
880 |
|
|
Und nun: ASP.NET |
881 |
|
|
17.2 Ein erstes Beispiel mit ASP.NET |
882 |
|
|
Hallo Welt mit ASP.NET |
883 |
|
|
Weitere Beispiele zu ASP.NET |
885 |
|
|
17.3 Die Webformulare |
904 |
|
|
Anlegen einer ASP.NET-Anwendung |
905 |
|
|
Die Umsetzung einer Webanwendung mit Webformular |
907 |
|
|
17.4 Die Idee von »Code behind Page« |
909 |
|
|
17.5 Das Klassenmodell hinter ASP.NET |
912 |
|
|
17.6 Allgemeine Arbeitsschritte |
913 |
|
|
IIS installieren |
913 |
|
|
IIS-Dienst starten |
913 |
|
|
Zugriffsrechte einstellen |
914 |
|
|
Anlegen eines Webverzeichnisses |
916 |
|
|
Wo werden ASP.NET-Anwendungen gehostet? |
918 |
|
|
17.7 WebMatrix 0.6 als Alternative zu Visual Studio .NET |
918 |
|
|
18 Ein ASP.NET-Praxisprojekt |
920 |
|
|
18.1 Spiel und Regeln |
921 |
|
|
18.2 Vorbereitungen auf dem Server |
922 |
|
|
Virtuelles Verzeichnis |
922 |
|
|
E-Mail-Versand |
924 |
|
|
18.3 Datenbankstruktur |
925 |
|
|
Spiele-Tabelle |
926 |
|
|
Spieler-Tabelle |
927 |
|
|
Tipps-Tabelle |
927 |
|
|
Rangliste-Tabelle |
927 |
|
|
18.4 Ein- und Ausloggen |
929 |
|
|
Anmeldung |
929 |
|
|
Das Login im Detail |
938 |
|
|
Die Benutzer sollen sich auch wieder abmelden – das Logout |
942 |
|
|
Passwort vergessen? |
943 |
|
|
18.5 Jetzt darf getippt werden |
946 |
|
|
18.6 Administrationsfunktionen |
957 |
|
|
18.7 Das große Finale – die Auswertung |
961 |
|
|
18.8 Der komplette Code im Gesamtüberblick |
968 |
|
|
18.9 Erweiterungsmöglichkeiten |
978 |
|
|
Cookies oder keine Cookies? |
978 |
|
|
Weitere Ideen für angehende ASP.NET-Programmierer |
980 |
|
|
18.10 Ein paar Tipps zum Spielen |
981 |
|
|
19 Netzwerkprogrammierung mit .NET – ein Überblick |
984 |
|
|
19.1 Überblick über System.Net |
985 |
|
|
Die Socket-Klasse |
985 |
|
|
Die EndPoint- und IPEndPoint-Klasse |
985 |
|
|
Die IPAddress-Klasse |
985 |
|
|
Die Dns-Klasse |
985 |
|
|
Die Socket-Klasse |
986 |
|
|
Die TCPClient-Klasse |
986 |
|
|
Die UDPClient-Klasse |
987 |
|
|
19.2 Das Prinzip von Winsock |
988 |
|
|
Die Socket-Klasse im Überblick |
990 |
|
|
Ein erstes Beispiel für eine Socket-Verbindung |
990 |
|
|
19.3 Weitere Socket-Beispiele |
998 |
|
|
Der Wetterserver sendet (endlich) Messwerte |
998 |
|
|
Der Wetterserver benutzt einen weiteren Thread und ein Networkstream- Objekt |
1002 |
|
|
Einer für alle – der Wetterserver bedient eine beliebige Anzahl an Clients |
1008 |
|
|
19.4 Download von Dateien über HTTP |
1016 |
|
|
19.5 Versenden von E-Mail-Nachrichten über SMTP |
1018 |
|
|
Abholen von E-Mail-Nachrichten über POP3 |
1020 |
|
|
Herstellen einer DFÜ-Netzwerkverbindung |
1021 |
|
|
20 Visual Basic-Projekte auf .NET umstellen |
1024 |
|
|
20.1 Das Wichtigste vorweg |
1025 |
|
|
20.2 Allgemeine Vorüberlegungen |
1027 |
|
|
20.3 Unterschiede beim Projektaufbau |
1028 |
|
|
20.4 Unterschiede bei Formularen und Steuerelementen |
1029 |
|
|
20.5 Unterschied bei der Datenbindung |
1031 |
|
|
20.6 Unterschiede bei der Programmiersprache |
1036 |
|
|
20.7 Der Aktualisierungsassistent in Aktion |
1038 |
|
|
Was ist aus dem Tagebuch geworden? |
1041 |
|
|
TODO or not TO? – Oder wie sich der Assistent dem Programmierer mitteilt |
1042 |
|
|
20.8 Spezialitäten |
1043 |
|
|
Strings mit fester Länge |
1043 |
|
|
Ausrichtung von Variablen in einem benutzerdefinierten Datentyp |
1045 |
|
|
Lokale Variablen innerhalb von Blöcken |
1045 |
|
|
Der »schlechte« Einfluss von Variant-Variablen |
1047 |
|
|
Verwendung von Default-Eigenschaften |
1048 |
|
|
Null-Datentyp und Null-Weitergabe |
1049 |
|
|
Add-Methode der ListBox fügt Objekte und keine Strings hinzu |
1050 |
|
|
Kein Terminate-Ereignis bei Klassen mehr |
1050 |
|
|
Visual Basic .NET unterstützt keine »weiche« Bindung |
1051 |
|
|
Keine implizite Instanziierung |
1051 |
|
|
Laufzeitfehler in COM-Ereignisprozeduren werden nicht gemeldet |
1052 |
|
|
Dynamischer Datenaustausch (DDE) |
1052 |
|
|
20.9 Empfehlungen für einen »sanften« Umstieg |
1052 |
|
|
20.10 C# als Alternative? |
1054 |
|
|
21 Ausliefern einer Visual Basic .NET-Anwendung |
1058 |
|
|
21.1 Was bedeutet die Installation einer Anwendung bei .NET? |
1059 |
|
|
Drei Gründe für ein Setup |
1060 |
|
|
21.2 Ein paar allgemeine Begriffe |
1061 |
|
|
Die Rolle der Abhängigkeiten |
1061 |
|
|
Die Rolle des Mergemoduls |
1061 |
|
|
Microsoft-Installer |
1062 |
|
|
Satelliten-Assemblies |
1062 |
|
|
Dotnetfx.exe |
1063 |
|
|
Setup- und Weitergabe-Projekttypen |
1063 |
|
|
21.3 Die Weitergabe einer Anwendung über ein Setup Projekt |
1065 |
|
|
21.4 Spezialitäten beim Anlegen eines Setup-Projekts |
1069 |
|
|
Lizenzbestimmungen anzeigen |
1069 |
|
|
Individuelle Dialogfelder anzeigen |
1071 |
|
|
Einträge in der Registry vornehmen |
1072 |
|
|
Dateitypen registrieren |
1073 |
|
|
Festlegen individueller Aktionen |
1073 |
|
|
Die Installer-Version aktualisieren |
1073 |
|
|
Ein Wort zu den Installationskomponenten |
1074 |
|
|
Die Weitergabe eines Projekts mit der .NET-Laufzeitumgebung |
1074 |
|
|
Feststellen, ob ».NET« bereits installiert ist |
1076 |
|
|
Abschließende Tipps |
1078 |
|
|
21.5 Zugriff auf Konfigurationseinstellungen der Anwendung |
1080 |
|
|
21.6 Lokalisieren einer Anwendung |
1081 |
|
|
22 Ein wenig Spaß mit GDI+ |
1084 |
|
|
22.1 Die wichtigsten Unterschiede zu früheren Visual Basic-Versionen |
1085 |
|
|
GDI+ für Webanwendungen |
1087 |
|
|
22.2 Ein erster Überblick über den Namespace System.Drawing |
1087 |
|
|
22.3 Die Rolle des Graphics-Objekts |
1089 |
|
|
22.4 Positions- und Größenangaben |
1091 |
|
|
22.5 Zeichnen von Linien und anderen geometrischen Figuren |
1093 |
|
|
22.6 Ausgabe von Text |
1094 |
|
|
Aufräumen muss man (meistens) selber – die Rolle von Dispose |
1096 |
|
|
22.7 Umgang mit Bitmaps |
1097 |
|
|
22.8 Eine kleines »Finale« |
1100 |
|
|
22.9 Ein kurzer Blick in die Zukunft |
1103 |
|
|
Transparente Bitmaps |
1104 |
|
|
Anhang |
1106 |
|
|
A .NET-Lexikon |
1108 |
|
|
B Visual Basic .NET im Vergleich zu früheren Visual Basic Versionen |
1114 |
|
|
B.1 Die Visual Basic-Befehle |
1114 |
|
|
Die Visual Basic .NET-Funktionen |
1117 |
|
|
Die Visual Basic-Objekte |
1129 |
|
|
Visual Basic-Sprachelemente, die es bei Visual Basic .NET nicht mehr gibt |
1135 |
|
|
Diverses |
1142 |
|
|
Noch einmal Microsoft.VisualBasic |
1143 |
|
|
C Hinweise zur Installation von Visual Studio .NET |
1148 |
|
|
C.1 Allgemeine Empfehlungen (und andere gut gemeinte Ratschläge) |
1148 |
|
|
C.2 Spezialfälle |
1150 |
|
|
C.3 Der allgemeine Ablauf der Installation im Überblick |
1151 |
|
|
C.4 Einstellen einer Visual Basic-konformen Umgebung |
1153 |
|
|
D Das .NET Framework SDK |
1154 |
|
|
D.1 Allgemeines zum .NET Framework SDK |
1154 |
|
|
Die Tools |
1155 |
|
|
D.2 Systemvoraussetzungen |
1157 |
|
|
D.3 Die Installation |
1157 |
|
|
D.4 Die Hilfe |
1158 |
|
|
D.5 Die Laufzeitumgebung |
1159 |
|
|
D.6 Ein Wort zum (fehlenden) Editor |
1160 |
|
|
E Ressourcen im Internet |
1162 |
|
|
E.1 Webadressen |
1162 |
|
|
E.2 Newsgroups |
1164 |
|
|
E.3 Mailinglisten |
1166 |
|
|
F Die CD-ROM zum Buch |
1168 |
|
|
F.1 Das .NET Framework SDK |
1168 |
|
|
F.2 SharpDevelop als kostenlose Alternative zu Visual Studio .NET |
1169 |
|
|
F.3 Die Beispielprogramme des Buches |
1171 |
|
|
Gibt es kein Ablaufmodell? |
1172 |
|
|
Wenn es Probleme mit der Buch-CD geben sollte ... |
1172 |
|
|
Stichwortverzeichnis |
1174 |
|