C sharp Shortcut
Programmieren im NET-Framework mit der C sharp Beta 2
Seiten
2001
Hanser, Carl (Hersteller)
978-3-446-21959-5 (ISBN)
Hanser, Carl (Hersteller)
978-3-446-21959-5 (ISBN)
- Keine Verlagsinformationen verfügbar
- Artikel merken
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
Patrick A. Lorenz ist Medienproduzent in Freiburg tätig. Er beschäftigt sich seit rund vier Jahren als Entwickler im Webumfeld intensiv mit der ASP-Technologie. Buchveröffentlichungen 'rund um .NET' und Referent auf Fachkonferenzen.
- Spracheinführung
- Datentypen
- Schleifen
- Operatoren
- Bedingungen
- Klassen
- Konvertierungen
- Zeichenketten
- Reguläre Ausdrücke
- Multithreading
- Reflections
- Spracheinführung - Datentypen - Schleifen - Operatoren - Bedingungen - Klassen - Konvertierungen - Zeichenketten - Reguläre Ausdrücke - Multithreading - Reflections
| Reihe/Serie | .NET Shortcuts |
|---|---|
| Zusatzinfo | Webseite |
| Sprache | deutsch |
| Maße | 168 x 240 mm |
| Gewicht | 558 g |
| Einbandart | kartoniert |
| Themenwelt | Informatik ► Betriebssysteme / Server ► Windows Server |
| Schlagworte | C sharp (Programmiersprache) |
| ISBN-10 | 3-446-21959-5 / 3446219595 |
| ISBN-13 | 978-3-446-21959-5 / 9783446219595 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
