C sharp Shortcut

C# gilt als die kommende Sprache, wenn es um die Programmierung im Microsoft-Umfeld geht, vereint sie doch das Beste beider Welten in sich - die einfache Handhabung von Visual Basic und die Mächtigkeit von Visual C++.



Dieses Buch wendet sich an alle, die C# vor Erscheinen der Final kennenlernen wollen und eine zuverlässige Einführung in Konzept und Aufbau suchen. Der Autor beschreibt dazu alle wesentlichen Sprachkomponenten und erläutert diese anhand prägnanter Beispiele. Neben den Grundlagen objektorientierter Programmierung zählen die Sprachnotation, Schleifen, Variablen, Operatoren, Konvertierungen und die Fehlerbehandlung zu wichtigen Themenschwerpunkten. Zudem werden auch weitergehende Programmiertechniken wie z.B. Multithreading und Reflections behandelt.



"C# Shortcut" liefert erstmals Informationen auf Basis der aktuellen Beta 2, die gegenüber der Beta 1 umfangreiche Änderungen erfuhr und bereits jetzt recht zuverlässige Aussagen über den endgültigen Aufbau von C# und dessen Einsatzmöglichkeiten zulässt.




Aus dem Inhalt:

- Spracheinführung

- Datentypen

- Schleifen

- Operatoren

- Bedingungen

- Klassen

- Konvertierungen

- Zeichenketten

- Reguläre Ausdrücke

- Multithreading

- Reflections

Inhalt

1 Einführung............................................................................................................... 13

1.1 Wer sollte dieses Buch lesen? ................................................................................... 13

1.2 Was Sie brauchen...................................................................................................... 14

1.3 Warum eine neue Sprache? ....................................................................................... 14

1.4 Das .NET Framework................................................................................................ 15

1.5 Die Beispiele aus dem Buch...................................................................................... 18

1.6 Kontakt zum Autor.................................................................................................... 22

2 Erste Schritte in C# ................................................................................................. 25

2.1 Notation..................................................................................................................... 25

2.2 GROSS oder klein? ................................................................................................... 26

2.3 Variablen................................................................................................................... 27

2.4 Konstanten ................................................................................................................ 28

2.5 Einfache Datentypen ................................................................................................. 28

2.6 Einfache Datentyp-Konvertierung............................................................................. 29

2.7 Kommentare.............................................................................................................. 30

2.8 Namespaces............................................................................................................... 30

2.9 Konsolen-Applikationen ........................................................................................... 33

2.10 Die Methode Main .................................................................................................... 34

2.11 Hallo Welt ................................................................................................................. 35

3 Klassen & objektorientierte Programmierung ± Teil I ........................................ 39

3.1 Was ist ein Objekt? ................................................................................................... 39

3.2 Was ist eine Klasse?.................................................................................................. 40

3.3 Instanziierung einer Klasse........................................................................................ 41

3.4 Terminierung eines Objekts ...................................................................................... 42

3.5 Deklaration einer neuen Klasse ................................................................................. 43

4 Bedingungen ............................................................................................................ 79

4.1 Das if-Konstrukt........................................................................................................ 79

4.2 Das switch-Konstrukt ................................................................................................ 82

4.3 Bedingungsoperator .................................................................................................. 86

5 Schleifen................................................................................................................... 89

5.1 Die for-Schleife......................................................................................................... 89

5.2 Die while-Schleife..................................................................................................... 91

5.3 Die do-Schleife ......................................................................................................... 92

5.4 Die foreach..in-Schleife............................................................................................. 92

5.5 Die Anweisungen break und continue....................................................................... 94

6 Sprunganweisungen ................................................................................................ 99

6.1 break.......................................................................................................................... 99

6.2 continue..................................................................................................................... 99

6.3 goto ......................................................................................................................... 100

6.4 return....................................................................................................................... 101

6.5 throw....................................................................................................................... 102

7 Operatoren............................................................................................................. 105

7.1 Mathematische Standard-Operatoren ...................................................................... 105

7.2 Mathematische Kurz-Operatoren ............................................................................ 108

7.3 Zuweisungsoperatoren ............................................................................................ 110

7.4 Noch mehr Mathematik mit der Klasse System.Math............................................. 112

7.5 Logische Operatoren ............................................................................................... 115

7.6 Typenoperatoren ..................................................................................................... 123

8 Arbeiten mit Zeichenketten.................................................................................. 131

8.1 Der Datentyp string ................................................................................................. 131

8.2 Die Klasse StringBuilder......................................................................................... 148

8.3 Reguläre Ausdröcke ................................................................................................ 152

9 Erweiterte Datentypen.......................................................................................... 171

9.1 Arrays...................................................................................................................... 171

9.2 Collections .............................................................................................................. 181

9.3 Strukturen................................................................................................................ 189

9.4 Aufzählungen .......................................................................................................... 192

10 Konvertierungen.................................................................................................... 199

10.1 Konvertierung von numerischen Werten................................................................. 199

10.2 Konvertierung zu string........................................................................................... 201

10.3 Konvertierung von Verweistypen............................................................................ 204

10.4 Die Klasse Convert ................................................................................................. 209

11 Fehlerbehandlung ................................................................................................. 217

11.1 Was ist eine Ausnahme? ......................................................................................... 217

11.2 Das try..catch..finally-Konstrukt ............................................................................. 219

11.3 Die Klasse Exception .............................................................................................. 223

11.4 Ausnahmen auslösen............................................................................................... 225

11.5 Ausnahmen (kontrolliert) weiterreichen.................................................................. 228

11.6 Eigene Ausnahmen definieren................................................................................. 230

11.7 Zusammenfassung................................................................................................... 234

12 Klassen & objektorientierte Programmierung ± Teil II..................................... 237

12.1 Überladungen.......................................................................................................... 237

12.2 Vererbung ............................................................................................................... 241

12.3 Schnittstellen........................................................................................................... 256

12.4 Benutzerdefinierte Operatoren erstellen.................................................................. 262

13 Weitergehende Programmierung......................................................................... 277

13.1 Arbeiten mit Threads............................................................................................... 277

13.2 Reflections .............................................................................................................. 281

13.3 Arbeiten mit dem CodeDOM.................................................................................. 286