visual c# 2010 - amazon s3...8 inhalt 3.10.3 klassenspezifische methoden ..... 205 3.10.4 statische...

Andreas Kühnel

Visual C# 2010Das umfassende Handbuch

1552.book Seite 1 Dienstag, 10. August 2010 11:16 11

3

Auf einen Blick

1 Allgemeine Einführung in .NET ............................................................ 29

2 Grundlagen der Sprache C# ................................................................. 55

3 Klassendesign ..................................................................................... 149

4 Vererbung, Polymorphie und Interfaces ............................................... 211

5 Delegates und Ereignisse ..................................................................... 273

6 Weitere .NET-Datentypen ................................................................... 301

7 Weitere Möglichkeiten von C# ............................................................ 311

8 Auflistungsklassen (Collections) .......................................................... 383

9 Fehlerbehandlung und Debugging ....................................................... 419

10 LINQ to Objects ................................................................................. 465

11 Multithreading und die Task Parallel Library (TPL) ............................... 497

12 Arbeiten mit Dateien und Streams ....................................................... 549

13 Binäre Serialisierung ............................................................................ 593

14 Einige wichtige .NET-Klassen .............................................................. 603

15 Projektmanagement und Visual Studio 2010 ....................................... 641

16 XML .................................................................................................... 703

17 WPF – Die Grundlagen ........................................................................ 797

18 WPF-Containerelemente ..................................................................... 829

19 WPF-Steuerelemente .......................................................................... 867

20 Konzepte der WPF .............................................................................. 941

21 Datenbindung ..................................................................................... 985

22 2D-Grafik ............................................................................................ 1021

23 ADO.NET – verbindungsorientierte Objekte ......................................... 1041

24 ADO.NET – Das Command-Objekt ....................................................... 1065

25 ADO.NET – Der SqlDataAdapter .......................................................... 1093

26 ADO.NET – Daten im lokalen Speicher ................................................ 1107

27 ADO.NET – Aktualisieren der Datenbank ............................................. 1149

28 Stark typisierte DataSets ..................................................................... 1171

29 LINQ to SQL ........................................................................................ 1199

30 Weitergabe von Anwendungen ............................................................ 1231


5

Inhalt

Vorwort zur 5. Auflage .............................................................................................. 27

29

1 Allgemeine Einführung in .NET .......................................................... 29

1.1 Warum .NET? .......................................................................................... 291.1.1 Ein paar Worte zu diesem Buch ................................................ 321.1.2 Die Beispielprogramme ............................................................. 34

1.2 .NET unter die Lupe genommen .............................................................. 341.2.1 Das Entwicklerdilemma ............................................................ 341.2.2 .NET – ein paar allgemeine Eigenschaften ................................. 361.2.3 Das Sprachenkonzept ............................................................... 371.2.4 Die Common Language Specification (CLS) ............................... 381.2.5 Das Common Type System (CTS) ............................................... 401.2.6 Das .NET Framework ................................................................ 411.2.7 Die Common Language Runtime (CLR) ..................................... 421.2.8 Die .NET-Klassenbibliothek ...................................................... 431.2.9 Das Konzept der Namespaces ................................................... 44

1.3 Assemblys ............................................................................................... 451.3.1 Die Metadaten ........................................................................ 461.3.2 Das Manifest ............................................................................ 47

1.4 Die Entwicklungsumgebung .................................................................... 471.4.1 Editionen von Visual Studio 2010 ............................................. 481.4.2 Hard- und Softwareanforderungen ........................................... 481.4.3 Installation ............................................................................... 491.4.4 Entwicklungsumgebung von Visual Studio 2010 ........................ 49

55

2 Grundlagen der Sprache C# ................................................................ 55

2.1 Konsolenanwendungen ........................................................................... 552.1.1 Allgemeine Anmerkungen ......................................................... 552.1.2 Ein erstes Konsolenprogramm ................................................... 56

2.2 Grundlagen der C#-Syntax ....................................................................... 592.2.1 Kennzeichnen, dass eine Anweisung abgeschlossen ist............... 592.2.2 Anweisungs- und Gliederungsblöcke ......................................... 602.2.3 Kommentare ............................................................................. 612.2.4 Groß- und Kleinschreibung ....................................................... 622.2.5 Struktur einer Konsolenanwendung .......................................... 63

2.3 Variablen und Datentypen ....................................................................... 652.3.1 Variablendeklaration ................................................................. 65


6

Inhalt

2.3.2 Variablenbezeichner ................................................................. 672.3.3 Zugriff auf eine Variable ............................................................ 682.3.4 Ein- und Ausgabemethoden der Klasse »Console«...................... 682.3.5 Einfache Datentypen ................................................................. 742.3.6 Typkonvertierung ...................................................................... 85

2.4 Operatoren .............................................................................................. 942.4.1 Arithmetische Operatoren ........................................................ 942.4.2 Vergleichsoperatoren ............................................................... 972.4.3 Logische Operatoren ................................................................. 982.4.4 Bitweise Operatoren ................................................................. 1012.4.5 Zuweisungsoperatoren .............................................................. 1042.4.6 Stringverkettung ....................................................................... 1052.4.7 Sonstige Operatoren ................................................................. 1052.4.8 Operator-Vorrangregeln ........................................................... 106

2.5 Datenfelder (Arrays) ................................................................................ 1072.5.1 Deklaration und Initialisierung eines Arrays ............................... 1072.5.2 Zugriff auf Array-Elemente ........................................................ 1082.5.3 Speicherabbild eines Arrays ...................................................... 1102.5.4 Mehrdimensionale Arrays ......................................................... 1122.5.5 Array-Größe zur Laufzeit festlegen ............................................ 1142.5.6 Bestimmung der Array-Obergrenze ........................................... 1152.5.7 Gesamtanzahl der Array-Elemente ........................................... 1162.5.8 Verzweigte Arrays ..................................................................... 116

2.6 Kontrollstrukturen ................................................................................... 1182.6.1 if-Anweisung ............................................................................ 1182.6.2 switch-Statement ...................................................................... 124

2.7 Programmschleifen .................................................................................. 1292.7.1 for-Schleife ............................................................................... 1302.7.2 foreach-Schleife ........................................................................ 1412.7.3 do- und while-Schleife .............................................................. 142

149

3 Klassendesign ..................................................................................... 149

3.1 Einführung in die Objektorientierung ....................................................... 1493.1.1 Vorteile der objektorientierten Programmierung........................ 151

3.2 Klassendefinition ..................................................................................... 1523.2.1 Klassen in Visual Studio anlegen ............................................... 1523.2.2 Das Projekt »GeometricObjectsSolution« .................................. 1533.2.3 Deklaration von Objektvariablen ............................................... 1543.2.4 Zugriffsmodifizierer einer Klasse ................................................ 1553.2.5 Splitten einer Klassendefinition mit »partial«.............................. 156


7

Inhalt

3.3 Arbeiten mit Objektreferenzen ................................................................ 1563.3.1 Prüfen auf Initialisierung ........................................................... 1563.3.2 Ein Objekt freigeben ................................................................. 1583.3.3 Mehrere Referenzen auf ein Objekt .......................................... 158

3.4 Referenz- und Wertetypen ...................................................................... 1593.5 Eigenschaften eines Objekts .................................................................... 160

3.5.1 Öffentliche Felder ..................................................................... 1603.5.2 Datenkapselung mit Eigenschaftsmethoden sicherstellen ........... 1623.5.3 Ergänzung der Klasse »Circle« ................................................... 1643.5.4 Lese- und schreibgeschützte Eigenschaften ............................... 1653.5.5 Sichtbarkeit der Accessoren »get« und »set« .............................. 1663.5.6 Unterstützung von Visual Studio 2010 ...................................... 1673.5.7 Automatisch implementierte Eigenschaften .............................. 1673.5.8 Vereinfachte Objektinstanziierung mit Objektinitialisierern........ 168

3.6 Methoden eines Objekts ......................................................................... 1693.6.1 Methoden mit Rückgabewert ................................................... 1693.6.2 Methoden ohne Rückgabewert ................................................. 1723.6.3 Methoden mit Parameterliste ................................................... 1733.6.4 Methodenüberladung ............................................................... 1753.6.5 Variablen innerhalb einer Methode (Lokale Variablen)............... 1773.6.6 Referenz- und Wertparameter .................................................. 1783.6.7 Zugriff auf private Daten ........................................................... 1903.6.8 Namenskonflikte mit »this« lösen .............................................. 1913.6.9 Trennung von Daten und Code im Speicher .............................. 1923.6.10 Methode oder Eigenschaft? ...................................................... 1933.6.11 Methoden und Eigenschaften umbenennen .............................. 194

3.7 Konstruktoren ......................................................................................... 1953.7.1 Konstruktoren bereitstellen ...................................................... 1963.7.2 Parametrisierte Konstruktoren und die Objektinitialisierung....... 1973.7.3 Konstruktoraufrufe ................................................................... 1973.7.4 Definition von Konstruktoren ................................................... 1983.7.5 »internal«-Konstruktoren .......................................................... 1993.7.6 »private«-Konstruktoren ........................................................... 1993.7.7 Konstruktorenaufrufe umleiten ................................................. 199

3.8 Der Destruktor ....................................................................................... 2003.9 Konstanten in einer Klasse ....................................................................... 201

3.9.1 Konstanten mit dem Schlüsselwort »const« ............................... 2013.9.2 Schreibgeschützte Felder mit »readonly« ................................... 202

3.10 Statische Klassenkomponenten ................................................................ 2033.10.1 Begrifflichkeiten ........................................................................ 2033.10.2 Statische Klassenvariable in der Klasse »Circle« .......................... 204


8

Inhalt

3.10.3 Klassenspezifische Methoden .................................................... 2053.10.4 Statische Konstruktoren (Klasseninitialisierer) ............................ 2063.10.5 Statische Klassen ...................................................................... 2073.10.6 Stand der Klasse »Circle« ........................................................... 208

211

4 Vererbung, Polymorphie und Interfaces ............................................ 211

4.1 Die Vererbung ......................................................................................... 2114.1.1 Basisklassen und abgeleitete Klassen ......................................... 2114.1.2 Ableitung einer Klasse .............................................................. 2124.1.3 Klassen, die nicht abgeleitet werden können ............................. 2144.1.4 Konstruktoren in abgeleiteten Klassen ...................................... 2144.1.5 Der Zugriffsmodifizierer »protected« ......................................... 2154.1.6 Konstruktorverkettung in der Vererbung ................................... 216

4.2 Der Problemfall geerbter Methoden ........................................................ 2204.2.1 Geerbte Methoden mit »new« verdecken .................................. 2224.2.2 Abstrakte Methoden ................................................................. 2244.2.3 Virtuelle Methoden .................................................................. 226

4.3 Typumwandlung und Typuntersuchung von Objektvariablen ................... 2284.3.1 Implizite Typumwandlung von Objektreferenzen ....................... 2284.3.2 Explizite Typumwandlung von Objektreferenzen........................ 2304.3.3 Typuntersuchung mit dem is-Operator ..................................... 2304.3.4 Typumwandlung mit dem as-Operator ...................................... 231

4.4 Polymorphie ............................................................................................ 2324.4.1 »Klassische« Methodenimplementierung ................................... 2324.4.2 Abstrakte Methoden ................................................................. 2334.4.3 Virtuelle Methoden .................................................................. 2344.4.4 Versiegelte Methoden .............................................................. 2384.4.5 Überladen einer Basisklassenmethode ....................................... 2384.4.6 Statische Member und Vererbung ............................................. 239

4.5 Das Projekt »GeometricObjectsSolution« ergänzen .................................. 2404.6 Hat-ein(e)-Beziehungen ........................................................................... 243

4.6.1 Innere Klassen (Nested Classes) ................................................ 2494.7 Interfaces (Schnittstellen) ....................................................................... 253

4.7.1 Schnittstellendefinition ............................................................. 2544.7.2 Schnittstellenimplementierung .................................................. 2544.7.3 Interpretation der Schnittstellen ............................................... 259

4.8 Das Zerstören von Objekten – der Garbage Collector ............................... 2654.8.1 Arbeitsweise des Garbage Collectors ......................................... 2654.8.2 Expliziter Aufruf des Garbage Collectors .................................... 2674.8.3 Der Destruktor ........................................................................ 267


9

Inhalt

4.8.4 Die »IDisposable«-Schnittstelle ................................................. 2684.8.5 Ergänzungen in den Klassen »Circle« und »Rectangle«................ 270

273

5 Delegates und Ereignisse ................................................................... 273

5.1 Delegates ................................................................................................ 2735.1.1 Einführung in das Prinzip der Delegates .................................... 2735.1.2 Vereinfachter Aufruf eines Delegates ........................................ 2775.1.3 Multicast-Delegate ................................................................... 2785.1.4 Anonyme Methoden ................................................................. 282

5.2 Ereignisse eines Objekts .......................................................................... 2835.2.1 Ereignis in einer Ereignisquelle ergänzen ................................... 2845.2.2 Behandlung eines Ereignisses im Ereignisempfänger................... 2865.2.3 Allgemeine Betrachtungen der Ereignishandlerregistrierung ....... 2885.2.4 Wenn der Ereignisempfänger ein Ereignis nicht behandelt ......... 2895.2.5 Ereignisse mit Übergabeparameter ............................................ 2905.2.6 Ereignisse in der Vererbung ...................................................... 2945.2.7 Hinter die Kulissen geblickt ...................................................... 2945.2.8 Änderungen im Projekt »GeometricObjects« .............................. 296

301

6 Weitere .NET-Datentypen .................................................................. 301

6.1 Strukturen ............................................................................................... 3016.1.1 Definition einer Struktur ........................................................... 3016.1.2 Initialisieren einer Struktur ........................................................ 3026.1.3 Weitere Merkmale einer Struktur .............................................. 3036.1.4 Verschachtelte Strukturen ......................................................... 3046.1.5 Änderung im Projekt »GeometricObjects« ................................. 305

6.2 Enumerationen (Aufzählungen) ................................................................ 3076.2.1 Wertzuweisung an »enum«-Mitglieder ...................................... 3086.2.2 Alle Mitglieder einer Aufzählung durchlaufen ............................ 309

311

7 Weitere Möglichkeiten von C# .......................................................... 311

7.1 Namensräume (Namespaces) ................................................................... 3117.1.1 Zugriff auf Namespaces ............................................................. 3127.1.2 Die »using«-Direktive ................................................................ 3147.1.3 Globaler Namespace ................................................................. 3147.1.4 Vermeiden von Mehrdeutigkeiten ............................................ 3157.1.5 Namespaces festlegen ............................................................... 3167.1.6 Der ::-Operator ......................................................................... 317


10

Inhalt

7.2 Generics – generische Datentypen ........................................................... 3197.2.1 Lösung mit einer generischen Klasse ......................................... 3217.2.2 Typparameter mit Constraints einschränken .............................. 3237.2.3 Generische Methoden .............................................................. 3267.2.4 Generics und Vererbung ........................................................... 3277.2.5 Konvertierung von Generics ...................................................... 3297.2.6 Generische Delegates ................................................................ 3307.2.7 Generische Klassen in der .NET-Klassenbibliothek ..................... 330

7.3 Operatorüberladung ................................................................................ 3317.3.1 Syntax der Operatorüberladung ................................................ 3327.3.2 Operatorüberladungen in »GeometricObjectsSolution«.............. 3337.3.3 »true«- und »false«-Operatoren ................................................ 3377.3.4 Benutzerdefinierte Konvertierungen .......................................... 339

7.4 Indexer .................................................................................................... 3437.4.1 Überladen von Indexern ........................................................... 3467.4.2 Parameterbehaftete Eigenschaften ............................................ 348

7.5 Erweiterungsmethoden ............................................................................ 3517.6 Implizit typisierte Variablen (Typinferenz) ................................................ 3557.7 Lambda-Ausdrücke .................................................................................. 3567.8 Anonyme Typen ...................................................................................... 3597.9 Nullable-Typen ....................................................................................... 3597.10 Attribute ................................................................................................. 361

7.10.1 Das »Flags«-Attribut .................................................................. 3617.10.2 Anmerkungen zu den Attributen ............................................... 3637.10.3 Benutzerdefinierte Attribute ..................................................... 3647.10.4 Attribute auswerten .................................................................. 3687.10.5 Festlegen der Assembly-Eigenschaften ...................................... 371

7.11 Partielle Methoden .................................................................................. 3727.12 Dynamisches Binden ............................................................................... 374

7.12.1 Eine kurze Analyse .................................................................... 3757.12.2 Dynamische Objekte ................................................................. 376

7.13 Unsicherer (unsafe) Programmcode – Zeigertechnik in C# ........................ 3777.13.1 Einführung ................................................................................ 3777.13.2 Das Schlüsselwort »unsafe« ....................................................... 3787.13.3 Deklaration von Zeigern ............................................................ 3787.13.4 Die »fixed«-Anweisung ............................................................. 3797.13.5 Zeigerarithmetik ....................................................................... 3817.13.6 Der Operator »->« .................................................................... 381


11

Inhalt

383

8 Auflistungsklassen (Collections) ........................................................ 383

8.1 Die Listen des Namespace »System.Collections« ...................................... 3848.1.1 Die elementaren Schnittstellen der Auflistungsklassen ............... 384

8.2 Die Klasse »ArrayList« .............................................................................. 3868.2.1 Einträge hinzufügen .................................................................. 3878.2.2 Datenaustausch zwischen einem Array und einer ArrayList ........ 3908.2.3 Die Elemente einer ArrayList sortieren ...................................... 3908.2.4 Sortieren von Arrays mit »ArrayList.Adapter« ............................. 397

8.3 Die Klasse »Hashtable« ............................................................................ 3988.3.1 Methoden und Eigenschaften der Schnittstelle »IDictionary« ..... 3988.3.2 Beispielprogramm zur Klasse »Hashtable« ................................. 399

8.4 Die Klassen »Queue« und »Stack« ............................................................ 4048.4.1 Die »Stack«-Klasse .................................................................... 404

8.5 Objektauflistungen im Überblick ............................................................ 4078.6 Generische Auflistungsklassen ................................................................. 407

8.6.1 Die Interfaces der generischen Auflistungsklassen ...................... 4088.6.2 Die generische Auflistungsklasse »List<T>« ................................ 408

8.7 Eigene Auflistungen mit »yield« durchlaufen ........................................... 415

419

9 Fehlerbehandlung und Debugging ..................................................... 419

9.1 Die Behandlung von Laufzeitfehlern ........................................................ 4199.1.1 Laufzeitfehler erkennen ............................................................ 4209.1.2 Die Behandlung von Exceptions ................................................ 4229.1.3 Die »try...catch«-Anweisung ..................................................... 4239.1.4 Behandlung mehrerer Exceptions .............................................. 4259.1.5 Die »finally«-Anweisung ............................................................ 4279.1.6 Das Weiterleiten von Ausnahmen ............................................. 4289.1.7 Die Hierarchie der Exceptions ................................................... 4349.1.8 Die Reihenfolge der »catch«-Klauseln ....................................... 4359.1.9 Die Basisklasse »Exception« ...................................................... 4379.1.10 Benutzerdefinierte Ausnahmen ................................................. 437

9.2 Debuggen mit Programmcode ................................................................. 4419.2.1 Einführung ................................................................................ 4419.2.2 Die Klasse »Debug« .................................................................. 4419.2.3 Die Klasse »Trace« .................................................................... 4459.2.4 Ablaufverfolgung mit »TraceListener«-Objekten ......................... 4469.2.5 Steuerung der Protokollierung mit Schaltern.............................. 4519.2.6 Bedingte Kompilierung ............................................................. 455


12

Inhalt

9.3 Debuggen mit Visual Studio 2010 ........................................................... 4579.3.1 Debuggen im Haltemodus ........................................................ 4579.3.2 Das Direktfenster ...................................................................... 4609.3.3 Weitere Alternativen, um Variableninhalte zu prüfen................. 462

465

10 LINQ to Objects ................................................................................ 465

10.1 Einführung in LINQ ................................................................................. 46510.1.1 Grundlagen der LINQ-Erweiterungsmethoden ........................... 46610.1.2 Verzögerte Ausführung ............................................................. 468

10.2 LINQ to Objects ...................................................................................... 46910.2.1 Musterdaten ............................................................................. 46910.2.2 Allgemeine Syntax .................................................................... 47110.2.3 Übersicht über die Abfrageoperatoren ...................................... 47210.2.4 Die »from«-Klausel .................................................................... 47310.2.5 Der Restriktionsoperator »where« ............................................. 47510.2.6 Projektionsoperatoren .............................................................. 47710.2.7 Sortieroperatoren ..................................................................... 47810.2.8 Gruppieren mit »GroupBy« ........................................................ 47910.2.9 Verknüpfungen mit »Join« ......................................................... 48110.2.10 Die Set-Operatoren-Familie ...................................................... 48410.2.11 Die Familie der Aggregatoperatoren ......................................... 48510.2.12 Generierungsoperatoren ........................................................... 48910.2.13 Quantifizierungsoperatoren ...................................................... 49010.2.14 Aufteilungsoperatoren .............................................................. 49110.2.15 Elementoperatoren ................................................................... 493

497

11 Multithreading und die Task Parallel Library (TPL) ........................... 497

11.1 Überblick ................................................................................................. 49711.2 Multithreading mit der Klasse »Thread« ................................................... 498

11.2.1 Einführung in das Multithreading .............................................. 49811.2.2 Threadzustände und Prioritäten ................................................ 49811.2.3 Zusammenspiel mehrerer Threads ............................................. 50011.2.4 Die Entwicklung einer einfachen Multithreading-Anwendung.... 50011.2.5 Die Klasse »Thread« .................................................................. 50311.2.6 Threadpools nutzen .................................................................. 51111.2.7 Synchronisation von Threads ..................................................... 51311.2.8 Der Monitor zur Synchronisation .............................................. 51511.2.9 Das Synchronisationsobjekt »Mutex« ....................................... 52211.2.10 Das Attribut »MethodImpl« ...................................................... 52411.2.11 Grundlagen asynchroner Methodenaufrufe ............................... 52411.2.12 Asynchroner Methodenaufruf ................................................... 525


13

Inhalt

11.2.13 Asynchroner Aufruf mit Rückgabewerten .................................. 52911.2.14 Eine Klasse mit asynchronen Methodenaufrufen ........................ 532

11.3 Die TPL (Task Parallel Library) .................................................................. 53611.3.1 Allgemeines zur Parallelisierung mit der TPL .............................. 53611.3.2 Die Klasse »Parallel« ................................................................. 53711.3.3 Die Klasse »Task« ...................................................................... 542

549

12 Arbeiten mit Dateien und Streams .................................................... 549

12.1 Namespaces der Ein- bzw. Ausgabe ......................................................... 55012.1.1 Das Behandeln von Ausnahmen bei E/A-Operationen................ 551

12.2 Laufwerke, Verzeichnisse und Dateien ..................................................... 55112.2.1 Die Klasse »File« ....................................................................... 55212.2.2 Die Klasse »FileInfo« ................................................................. 55712.2.3 Die Klassen »Directory« und »DirectoryInfo«.............................. 55912.2.4 Die Klasse »Path« ...................................................................... 56312.2.5 Die Klasse »DriveInfo« .............................................................. 56512.2.6 Die Klasse »SpecialDirectories« ................................................. 566

12.3 Die »Stream«-Klassen .............................................................................. 56712.3.1 Die abstrakte Klasse »Stream« ................................................... 56712.3.2 Die von »Stream« abgeleiteten Klassen im Überblick.................. 57012.3.3 Die Klasse »FileStream« ............................................................ 571

12.4 Die Klassen »TextReader« und »TextWriter« ............................................ 57712.4.1 Die Klasse »StreamWriter« ........................................................ 57812.4.2 Die Klasse »StreamReader« ....................................................... 582

12.5 Die Klassen »BinaryReader« und »BinaryWriter« ...................................... 58412.5.1 Komplexe binäre Dateien ......................................................... 586

593

13 Binäre Serialisierung ........................................................................... 593

13.1 Serialisierungsverfahren ........................................................................... 59413.2 Serialisierung mit »BinaryFormatter« ........................................................ 595

603

14 Einige wichtige .NET-Klassen ............................................................ 603

14.1 Die Klasse »Object« ................................................................................. 60314.1.1 Referenzvergleiche mit »Equals« und »ReferenceEquals« ............ 60414.1.2 »ToString« und »GetType« ......................................................... 60414.1.3 Die Methode »MemberwiseClone« ........................................... 605

14.2 Die Klasse »String« .................................................................................. 60814.2.1 Erzeugen eines Strings .............................................................. 60814.2.2 Eigenschaften von »String« ........................................................ 609


14

Inhalt

14.2.3 Methoden der Klasse »String« ................................................... 60914.2.4 Zusammenfassung der Klasse »String« ....................................... 619

14.3 Die Klasse »StringBuilder« ....................................................................... 62114.3.1 Allgemeines .............................................................................. 62114.3.2 Kapazität eines »StringBuilder«-Objekts .................................... 62114.3.3 Konstruktoren der Klasse »StringBuilder« .................................. 62214.3.4 Eigenschaften der Klasse »StringBuilder« ................................... 62214.3.5 Die Methoden der Klasse »StringBuilder« .................................. 62314.3.6 Allgemeine Anmerkungen ......................................................... 625

14.4 Der Typ »DateTime« ................................................................................ 62614.4.1 Zeitspanne »Tick« ..................................................................... 62614.4.2 Konstruktoren von »DateTime« ................................................. 62714.4.3 Eigenschaften von »DateTime« .................................................. 62814.4.4 Methoden der Klasse »DateTime« ............................................. 629

14.5 Die Klasse »TimeSpan« ............................................................................ 63114.6 Ausgabeformatierung .............................................................................. 633

14.6.1 Formatierung mit der Methode »String.Format«......................... 63414.6.2 Formatierung mit der Methode »ToString« ................................ 63714.6.3 Benutzerdefinierte Formatierung ............................................... 638

641

15 Projektmanagement und Visual Studio 2010 .................................... 641

15.1 Der Projekttyp »Klassenbibliothek« .......................................................... 64115.1.1 Mehrere Projekte in einer Projektmappe verwalten ................... 64215.1.2 Die Zugriffsmodifizierer »public« und »internal« ......................... 64315.1.3 Friend-Assemblys ...................................................................... 64315.1.4 Einbinden einer Klassenbibliothek ............................................ 644

15.2 Assemblys ............................................................................................... 64615.2.1 Konzept der Assemblys ............................................................. 64615.2.2 Allgemeine Beschreibung privater und globaler Assemblys......... 64815.2.3 Struktur einer Assembly ............................................................ 64815.2.4 Globale Assemblys .................................................................... 653

15.3 Konfigurationsdateien ............................................................................ 66415.3.1 Einführung ................................................................................ 66415.3.2 Die verschiedenen Konfigurationsdateien ................................. 66515.3.3 Struktur einer Anwendungskonfigurationsdatei.......................... 66715.3.4 Anwendungskonfigurationsdatei mit Visual Studio 2010

bereitstellen .............................................................................. 67015.3.5 Einträge der Anwendungskonfigurationsdatei auswerten ........... 67115.3.6 Editierbare, anwendungsbezogene Einträge mit <appSettings> 676

15.4 Versionsumleitung in einer Konfigurationsdatei ....................................... 67815.4.1 Herausgeberrichtliniendatei ...................................................... 683


15

Inhalt

15.5 XML-Dokumentation .............................................................................. 68415.5.1 Prinzip der XML-Dokumentation .............................................. 68515.5.2 XML-Kommentar-Tags .............................................................. 68715.5.3 Generieren der XML-Dokumentationsdatei ............................... 688

15.6 Der Klassendesigner (Class Designer) ....................................................... 69015.6.1 Ein typisches Klassendiagramm ................................................. 69015.6.2 Hinzufügen und Ansicht von Klassendiagrammen ...................... 69215.6.3 Die Toolbox des Klassendesigners ............................................. 69315.6.4 Das Fenster »Klassendetails« ..................................................... 69315.6.5 Klassendiagramme als Bilder exportieren .................................. 695

15.7 Refactoring .............................................................................................. 69515.7.1 Methode extrahieren ................................................................ 69615.7.2 Bezeichner umbenennen ........................................................... 69815.7.3 Felder einkapseln ...................................................................... 699

15.8 Code Snippets (Codeausschnitte) ............................................................. 69915.8.1 Codeausschnitte einfügen ......................................................... 70015.8.2 Anatomie eines Codeausschnitts ............................................... 700

703

16 XML .................................................................................................... 703

16.1 XML-Dokumente .................................................................................... 70316.1.1 Wohlgeformte und gültige XML-Dokumente ............................. 70416.1.2 Regeln für wohlgeformten XML-Code ....................................... 70616.1.3 Kommentare ............................................................................. 70916.1.4 Verarbeitungsanweisungen ....................................................... 71016.1.5 Reservierte Zeichen in XML ...................................................... 71016.1.6 CDATA-Abschnitte ................................................................... 71116.1.7 Namensräume (Namespaces) .................................................... 711

16.2 Gültigkeit eines XML-Dokuments ............................................................ 71816.2.1 XML Schema (XSD) ................................................................... 71916.2.2 XML-Dokument mit einem XML Schema verknüpfen................. 72016.2.3 Struktur eines XML Schemas ..................................................... 723

16.3 Die Klasse »XmlReader« .......................................................................... 72916.3.1 XML-Dokumente mit einem »XmlReader«-Objekt lesen............. 72916.3.2 Validieren eines XML-Dokuments ............................................. 736

16.4 Eigenschaften und Methoden der Klasse »XmlReader« ............................ 73916.4.1 Navigation mit dem »XmlReader« ............................................. 73916.4.2 Eigenschaften und Methoden im Zusammenhang

mit Attributen .......................................................................... 74016.4.3 Eigenschaften und Methoden im Zusammenhang

mit Namespaces ....................................................................... 74016.4.4 Daten lesen .............................................................................. 741


16

Inhalt

16.5 Die Klasse »XmlWriter« ........................................................................... 74116.5.1 Die Methoden der Klasse »XmlWriter« ..................................... 746

16.6 Navigation durch XML (XPath) ................................................................ 74616.6.1 Die Klasse »XPathNavigator« ..................................................... 74616.6.2 XPath-Ausdrücke ...................................................................... 75116.6.3 Kontextknoten .......................................................................... 75216.6.4 Beispiele mit XPath-Ausdrücken ............................................... 75316.6.5 Knotenmengen mit der »Select«-Methode ................................ 75616.6.6 Auswerten von XPath-Ausdrücken ............................................ 760

16.7 Document Object Model (DOM) ............................................................. 76416.7.1 Allgemeines .............................................................................. 76416.7.2 Arbeiten mit XmlDocument ...................................................... 76516.7.3 XmlDocument und XPathNavigator .......................................... 76616.7.4 Die Klasse »XmlNode« (Operationen mit Knoten) ...................... 76716.7.5 XML-Struktur manipulieren ...................................................... 77516.7.6 Knoten ändern .......................................................................... 77616.7.7 Löschen in einem XML-Dokument ............................................ 778

16.8 Serialisierung mit »XmlSerializer« ............................................................. 78016.8.1 XML-Serialisierung mit Attributen steuern ................................ 782

16.9 LINQ to XML .......................................................................................... 78516.9.1 Klassenhierarchie von LINQ to XML ......................................... 78516.9.2 Die Klasse »XElement« .............................................................. 78616.9.3 Die Klasse »XDocument« .......................................................... 78916.9.4 Navigation im XML-Dokument ................................................. 79016.9.5 Änderungen am XML-Dokument vornehmen............................. 795

797

17 WPF – Die Grundlagen ....................................................................... 797

17.1 Merkmale einer WPF-Anwendung ........................................................... 79717.2 Anwendungstypen ................................................................................... 79917.3 Eine WPF-Anwendung und ihre Dateien ................................................. 800

17.3.1 Die Datei »App.xaml« ............................................................... 80217.3.2 Die Datei »App.xaml.cs« ........................................................... 80217.3.3 Die Dateien ».baml« und ».g.cs« ................................................ 803

17.4 Einführung in XAML ................................................................................ 80317.4.1 Struktur einer XAML-Datei ....................................................... 80417.4.2 XAML-Elemente ....................................................................... 80517.4.3 Eigenschaften eines XAML-Elements festlegen........................... 80517.4.4 Typkonvertierung ...................................................................... 80917.4.5 Markup-Erweiterungen (Markup Extensions) ............................. 81017.4.6 Namespaces .............................................................................. 812


17

Inhalt

17.4.7 XAML-Spracherweiterungen ..................................................... 81517.4.8 Markup-Erweiterungen ............................................................. 816

17.5 Abhängige und angehängte Eigenschaften ............................................... 81617.5.1 Abhängige Eigenschaften .......................................................... 81617.5.2 Angehängte Eigenschaften ........................................................ 818

17.6 Logischer und visueller Elementbaum ...................................................... 81817.6.1 Warum wird zwischen den Elementbäumen unterschieden? ...... 82017.6.2 Elementbäume mit Code ermitteln ........................................... 820

17.7 Ereignisse in der WPF .............................................................................. 82217.7.1 Allgemeine Grundlagen ............................................................ 82217.7.2 Routed Events .......................................................................... 823

829

18 WPF-Containerelemente .................................................................... 829

18.1 WPF-Fenster ........................................................................................... 82918.1.1 Nachrichtenfenster mit »MessageBox« ...................................... 83018.1.2 Die Methode »MessageBox.Show« ........................................... 83118.1.3 Fenster vom Typ »Window« ...................................................... 83318.1.4 Fenster vom Typ »NavigationWindow« ..................................... 83718.1.5 Das »Page«-Element ................................................................. 83818.1.6 Das »Frame«-Steuerelement ...................................................... 845

18.2 Layoutcontainer ...................................................................................... 84618.2.1 Gemeinsame Eigenschaften der Layoutcontainer........................ 847

18.3 Canvas ..................................................................................................... 84818.4 StackPanel ............................................................................................... 84918.5 WrapPanel .............................................................................................. 85218.6 DockPanel ............................................................................................... 85318.7 UniformGrid ............................................................................................ 85618.8 Grid ......................................................................................................... 857

18.8.1 Struktur eines »Grid« festlegen .................................................. 85718.8.2 »ColumnSpan« und »RowSpan« ................................................ 86118.8.3 Spalten- und Zeilenbreite mit »GridSplitter« ändern................... 862

18.9 Verschachtelte Layoutcontainer ............................................................... 863

867

19 WPF-Steuerelemente ......................................................................... 867

19.1 Hierarchie der WPF-Komponenten .......................................................... 86719.2 Steuerelemente positionieren ................................................................. 869

19.2.1 Die Eigenschaften »Top«, »Bottom«, »Right« und »Left« ............. 86919.2.2 Außenrand mit der Eigenschaft »Margin« festlegen .................... 86919.2.3 Innenrand mit der Eigenschaft »Padding« festlegen.................... 870


18

Inhalt

19.3 Allgemeine Eigenschaften der WPF-Komponenten .................................. 87019.3.1 Die Eigenschaft »Content« ........................................................ 87019.3.2 Größe einer Komponente ......................................................... 87219.3.3 Ausrichtung einer Komponente ................................................ 87319.3.4 Die Eigenschaften »Padding« und »Margin« .............................. 87419.3.5 Sichtbarkeit eines Steuerelements ............................................. 87619.3.6 Farbeinstellungen ..................................................................... 87719.3.7 Schriften ................................................................................... 877

19.4 Buttons ................................................................................................... 87819.4.1 Die Basisklasse »ButtonBase« .................................................... 87819.4.2 Das Steuerelement »Button« ..................................................... 87919.4.3 Das Steuerelement »ToggleButton« ........................................... 88019.4.4 Das Steuerelement »RepeatButton« .......................................... 88119.4.5 Das Steuerelement »Checkbox« ................................................ 88219.4.6 Das Steuerelement »RadioButton« ............................................ 882

19.5 Einfache Eingabesteuerelemente ............................................................. 88419.5.1 Das Steuerelement »Label« ....................................................... 88419.5.2 Das Steuerelement »TextBox« ................................................... 88519.5.3 Das Steuerelement »PasswordBox« ........................................... 88819.5.4 Das Steuerelement »TextBlock« ................................................ 88919.5.5 Das Steuerelement »Tooltip« .................................................... 892

19.6 FlowDocuments ..................................................................................... 89319.6.1 Allgemeine Beschreibung .......................................................... 89319.6.2 Eigenschaften eines FlowDocuments ......................................... 89519.6.3 Blöcke eines FlowDocuments .................................................... 89519.6.4 Inline-Elemente ........................................................................ 89919.6.5 FlowDocuments mit Code erzeugen .......................................... 90219.6.6 Speichern und Laden von FlowDocuments ................................ 905

19.7 Das Element »FlowDocumentViewer« ..................................................... 90519.7.1 Das Anzeigeelement »FlowDocumentScrollViewer« ................... 90519.7.2 Das Anzeigeelement »FlowDocumentPageViewer« .................... 90619.7.3 Das Anzeigeelement »FlowDocumentReader«............................ 907

19.8 XPS-Dokumente mit »DocumentViewer« ................................................. 90719.8.1 Allgemeines zum XPS-Format ................................................... 90719.8.2 Beispielprogramm ..................................................................... 90819.8.3 Das Steuerelement »RichTextBox« ............................................ 909

19.9 WPF-Listenelemente – ItemControls ........................................................ 91419.9.1 Das Steuerelement »ListBox« .................................................... 91419.9.2 ComboBox ................................................................................ 91719.9.3 Das Steuerelement »ListView« .................................................. 91819.9.4 Das Steuerelement »TreeView« ................................................. 921


19

Inhalt

19.9.5 Das Steuerelement »TabControl« .............................................. 92219.9.6 Menüleisten ............................................................................. 92319.9.7 Kontextmenüs .......................................................................... 92619.9.8 Symbolleisten ........................................................................... 92819.9.9 Die Statusleiste ......................................................................... 931

19.10 Weitere Steuerelemente .......................................................................... 93219.10.1 Die »ProgressBar« ..................................................................... 93219.10.2 Das Steuerelement »Slider« ....................................................... 93319.10.3 Das »GroupBox«-Steuerelement ................................................ 93319.10.4 Das Steuerelement »ScrollViewer« ............................................ 93519.10.5 Das Steuerelement »Expander« ................................................. 93619.10.6 Das Steuerelement »Border« ..................................................... 93819.10.7 Die »Image«-Komponente ........................................................ 93919.10.8 Grafik zur Laufzeit laden ........................................................... 940

941

20 Konzepte der WPF ............................................................................. 941

20.1 Ressourcen .............................................................................................. 94120.1.1 Wo logische Ressourcen definiert werden können ..................... 94120.1.2 Definition logischer Ressourcen ................................................ 94320.1.3 Statische und dynamische Ressourcen ....................................... 94620.1.4 Ressourcen in Ressourcendateien ............................................. 94820.1.5 Suche nach einer Ressource ...................................................... 95020.1.6 Ressourcen mit C#-Code ........................................................... 95120.1.7 Abrufen von Systemressourcen ................................................. 952

20.2 Styles ...................................................................................................... 95420.2.1 Einfache Stile ............................................................................ 95420.2.2 Typisierte Stile .......................................................................... 95720.2.3 EventSetter ............................................................................... 960

20.3 Trigger ..................................................................................................... 96220.3.1 Eigenschaftstrigger .................................................................... 96320.3.2 Ereignistrigger ........................................................................... 96520.3.3 Datentrigger ............................................................................. 967

20.4 Templates ............................................................................................... 96820.4.1 Grundlagen der Templates ........................................................ 96820.4.2 Verfeinerung des Entwurfs ........................................................ 97020.4.3 Definition innerhalb eines Styles ............................................... 97320.4.4 Den Visual Tree ermitteln ......................................................... 974

20.5 Commands .............................................................................................. 97920.5.1 Vordefinierte Commands .......................................................... 97920.5.2 Beispielanwendung ................................................................... 98020.5.3 Commando-Ziel festlegen ......................................................... 981


20

Inhalt

20.5.4 Commands an Ereignisse binden ............................................... 98220.5.5 Commands programmieren ....................................................... 983

985

21 Datenbindung ..................................................................................... 985

21.1 Wichtige Klassen ..................................................................................... 98521.1.1 Die Klasse »Binding« ................................................................. 98521.1.2 Die Klasse »DataContext« ......................................................... 986

21.2 Einfache Datenbindung ........................................................................... 98721.2.1 Bindung mit Code erzeugen ...................................................... 98821.2.2 Bindungsrichtung ...................................................................... 98921.2.3 Änderung der Datenquelle ........................................................ 99121.2.4 Weitere Möglichkeiten im Zusammenhang mit der

Datenbindung ........................................................................... 99421.2.5 Die Ereignisse »SourceUpdated« und »TargetUpdated« .............. 995

21.3 Verschiedene Datenbindungsquellen ....................................................... 99621.3.1 Bindung an einfache Objekte .................................................... 99621.3.2 Auflistungen binden .................................................................. 997

21.4 DataTemplates festlegen ......................................................................... 99921.4.1 Trigger ...................................................................................... 1001

21.5 Daten konvertieren .................................................................................. 100321.5.1 Beispielprogramm ..................................................................... 100521.5.2 Mehrfachbindungen und »Converter«-Klassen ........................... 1006

21.6 Die Klasse »ObjectDataProvider« ............................................................. 100821.7 WPF und ADO.NET ................................................................................. 1010

21.7.1 Ausgabe in einer ListBox ........................................................... 101021.7.2 Eine Tabelle im DataGrid-Steuerelement ................................... 101321.7.3 WPF und LINQ to SQL .............................................................. 1019

1021

22 2D-Grafik ............................................................................................ 1021

22.1 Shapes ..................................................................................................... 102122.1.1 Allgemeine Beschreibung .......................................................... 102122.1.2 Line-Elemente .......................................................................... 102222.1.3 Ellipse- und Rectangle-Elemente ............................................... 102222.1.4 Polygon- und Polyline-Elemente ............................................... 102322.1.5 Darstellung der Linien ............................................................... 1023

22.2 Path-Elemente ......................................................................................... 102522.2.1 GeometryGroup ........................................................................ 102622.2.2 CombinedGeometry .................................................................. 102722.2.3 PathGeometry .......................................................................... 1028


21

Inhalt

22.3 Brush-Objekte ......................................................................................... 102922.3.1 SolidColorBrush ........................................................................ 103022.3.2 LinearGradientBrush ................................................................. 103122.3.3 RadialGradientBrush ................................................................. 103322.3.4 TileBrush .................................................................................. 103422.3.5 ImageBrush .............................................................................. 103622.3.6 VisualBrush ............................................................................... 103722.3.7 DrawingBrush ........................................................................... 1039

1041

23 ADO.NET – verbindungsorientierte Objekte ......................................1041

23.1 Datenprovider ......................................................................................... 104223.2 Verbindung zu einer Datenbank herstellen .............................................. 1043

23.2.1 Das »Connection«-Objekt ......................................................... 104323.2.2 Verbindungszeichenfolge .......................................................... 104423.2.3 Verbindung mit einer SQL Server-Instanz aufbauen ................... 104523.2.4 Öffnen und Schließen einer Verbindung .................................... 104923.2.5 Verbindungspooling ................................................................. 105223.2.6 Ereignisse eines »Connection«-Objekts ..................................... 105723.2.7 Verbindungszeichenfolgen aus einer Konfigurationsdatei

abrufen ..................................................................................... 105823.2.8 Verbindungen mit dem »OleDb«-Datenprovider ........................ 1061

1065

24 ADO.NET – Das Command-Objekt .....................................................1065

24.1 Das »SqlCommand«-Objekt ..................................................................... 106524.1.1 Erzeugen eines »SqlCommand«-Objekts .................................... 106624.1.2 Die Methode »CreateCommand« des »Connection«-Objekts ...... 106724.1.3 Ausführen des »SqlCommand«-Objekts ..................................... 106724.1.4 Die Eigenschaft »CommandTimeout« des

»SqlCommand«-Objekts ............................................................ 106824.2 Aktionsabfragen absetzen ........................................................................ 1068

24.2.1 Datensätze hinzufügen .............................................................. 106824.2.2 Datensätze löschen ................................................................... 106924.2.3 Datensätze ändern .................................................................... 107024.2.4 Abfragen, die genau ein Ergebnis liefern ................................... 1070

24.3 Das »SqlDataReader«-Objekt ................................................................... 107024.3.1 Datensätze einlesen .................................................................. 107124.3.2 Schließen des »SqlDataReader«-Objekts .................................... 107424.3.3 MARS (Multiple Active Resultsets) ............................................ 107424.3.4 Batch-Abfragen mit »NextResult« durchlaufen ........................... 107524.3.5 Schema eines »SqlDataReader«-Objekts untersuchen................. 1076


22

Inhalt

24.4 Parametrisierte Abfragen ......................................................................... 107924.4.1 Parametrisierte Abfragen mit dem SqlClient-Datenprovider ....... 107924.4.2 Die Klasse »SqlParameter« ........................................................ 108124.4.3 Asynchrone Abfragen ................................................................ 108224.4.4 Gespeicherte Prozeduren (Stored Procedures)............................ 1086

1093

25 ADO.NET – Der SqlDataAdapter ........................................................ 1093

25.1 Was ist ein »DataAdapter«? ..................................................................... 109325.2 Konstruktoren der Klasse »DataAdapter« ................................................. 109525.3 Mit dem »SqlDataAdapter« arbeiten ........................................................ 1096

25.3.1 Die Eigenschaft »SelectCommand« ............................................ 109625.3.2 Lokalen Datenspeicher mit »Fill« füllen ..................................... 109625.3.3 Öffnen und Schließen von Verbindungen .................................. 109725.3.4 Doppelter Aufruf der »Fill«-Methode ........................................ 109825.3.5 Mehrere »DataAdapter«-Objekte aufrufen ................................ 109925.3.6 Spalten- und der Tabellenbezeichner einer »DataTable«............. 109925.3.7 Paging mit der »Fill«-Methode .................................................. 1100

25.4 Tabellenzuordnung mit der Klasse »TableMappings« ................................ 110025.4.1 Spaltenzuordnungen in einem »DataSet« .................................. 110225.4.2 Spaltenzuordnungen einer »DataTable« .................................... 110425.4.3 Die Eigenschaft »MissingMappingAction« des »DataAdapter« .... 1104

25.5 Das Ereignis »FillError« des »SqlDataAdapter« .......................................... 1105

1107

26 ADO.NET – Daten im lokalen Speicher ............................................. 1107

26.1 »DataSet«-Objekte verwenden ................................................................ 110826.1.1 »DataSet«-Objekte erzeugen ..................................................... 110826.1.2 Anatomie einer »DataTable« ..................................................... 110826.1.3 Zugriff auf eine Tabelle im »DataSet« ........................................ 110926.1.4 Zugriff auf die Ergebnisliste ....................................................... 111026.1.5 Dateninformationen in eine XML-Datei schreiben ..................... 1111

26.2 Gültigkeitsprüfung im »DataSet« .............................................................. 111226.2.1 Dem »DataSet« Schema-Informationen übergeben .................... 111226.2.2 Eigenschaften einer »DataColumn«, die zur Gültigkeitsprüfung

dienen ...................................................................................... 111426.2.3 Die »Constraints«-Klassen einer »DataTable«.............................. 111526.2.4 Schema mit Programmcode erzeugen ....................................... 111626.2.5 Schema-Informationen mit »SqlDataAdapter« abrufen ............... 1118

26.3 Änderungen in einer DataTable vornehmen ............................................. 112126.3.1 Editieren einer DataRow ........................................................... 112126.3.2 Datenzeile löschen .................................................................... 1123


23

Inhalt

26.3.3 Neue Datenzeile hinzufügen ..................................................... 112326.3.4 Der Sonderfall: Autoinkrementspalten ...................................... 112426.3.5 Was passiert bei der Änderung einer Datenzeile?....................... 112626.3.6 Manuelles Steuern der Eigenschaft »DataRowState« .................. 1130

26.4 Mit mehreren Tabellen arbeiten .............................................................. 113126.4.1 Der Weg über JOIN-Abfragen ................................................... 113126.4.2 Mehrere Tabellen in einem »DataSet« ....................................... 113326.4.3 Eine »DataRelation« erzeugen ................................................... 113326.4.4 »DataRelation« und Einschränkungen ....................................... 113426.4.5 In Beziehung stehende Daten suchen ....................................... 113626.4.6 Ergänzung zum Speichern von Schema-Informationen

in einer XML-Schema-Datei ...................................................... 113926.5 Filtern und Suchen in einer DataTable ..................................................... 1139

26.5.1 Die Methode »Find« ................................................................. 113926.5.2 Die Methode »Select« ............................................................... 1140

26.6 Objekte vom Typ »DataView« .................................................................. 114126.6.1 »DataView« erzeugen ............................................................... 114226.6.2 Auf die Datenzeilen in einer »DataView« zugreifen .................... 114326.6.3 Die Eigenschaft »Sort« und die Methode »Find«......................... 114326.6.4 Die Methode »FindRows« ......................................................... 114326.6.5 Die Eigenschaft »RowFilter« ...................................................... 114426.6.6 Die Eigenschaft »RowStateFilter« .............................................. 114426.6.7 Änderungen an einem »DataView«-Objekt ............................... 114526.6.8 Aus einer »DataView« eine »DataTable« erzeugen...................... 1146

1149

27 ADO.NET – Aktualisieren der Datenbank ..........................................1149

27.1 Aktualisieren mit dem »CommandBuilder« .............................................. 114927.1.1 Von »SqlCommandBuilder« generierte

Aktualisierungsstatements ........................................................ 115127.1.2 Konfliktsteuerung in einer Mehrbenutzerumgebung .................. 115227.1.3 Die Eigenschaft »ConflictOption« des »SqlCommandBuilder« ..... 115527.1.4 Die Eigenschaft »SetAllValues« .................................................. 1156

27.2 Manuell gesteuerte Aktualisierung ........................................................... 115627.2.1 Eigene Aktualisierungslogik ....................................................... 115727.2.2 Beispielprogramm ..................................................................... 1159

27.3 Konfliktanalyse ........................................................................................ 116127.3.1 Benutzer über fehlgeschlagene Aktualisierungen

informieren ............................................................................... 116127.3.2 Konfliktverursachende Datenzeilen bei der Datenbank

abfragen ................................................................................... 116327.4 Neue Autoinkrementwerte abrufen ......................................................... 1168


24

Inhalt

1171

28 Stark typisierte DataSets ................................................................... 1171

28.1 Stark typisierte DataSets erzeugen ........................................................... 117128.1.1 Typisierte DataSets mit dem Visual Studio Designer

erstellen .................................................................................... 117128.1.2 Das Kommandozeilentool »XSD.exe« ........................................ 1174

28.2 Anatomie eines typisierten DataSet ......................................................... 117528.2.1 Datenzeilen einer Tabelle ausgeben .......................................... 117628.2.2 Datenzeilen hinzufügen ............................................................ 117928.2.3 Datenzeilen bearbeiten ............................................................. 118028.2.4 Datenzeilen suchen ................................................................... 118028.2.5 NULL-Werte im typisierten DataSet .......................................... 118028.2.6 Daten in einem hierarchischen DataSet ..................................... 1181

28.3 Typisierte DataSets manuell im Designer erzeugen .................................. 118228.3.1 DataTable manuell erzeugen ..................................................... 118228.3.2 Der DataTable Spalten hinzufügen ............................................ 118228.3.3 Beziehungen zwischen den Tabellen erstellen ............................ 118328.3.4 Weitergehende Betrachtungen ................................................. 1185

28.4 Der TableAdapter .................................................................................... 118528.4.1 TableAdapter mit Visual Studio erzeugen .................................. 118528.4.2 Die Methode »Fill« des TableAdapters ...................................... 119128.4.3 Die Methode »GetData« ........................................................... 119228.4.4 Die Methode »Update« ............................................................. 119228.4.5 Aktualisieren mit den »DBDirect«-Methoden ............................. 119228.4.6 TableAdapter mit mehreren Abfragen ....................................... 119328.4.7 Änderungen an einem TableAdapter vornehmen ....................... 1196

28.5 Fazit: Typisierte oder nicht typisierte DataSets? ....................................... 1197

1199

29 LINQ to SQL ....................................................................................... 1199

29.1 Allgemeine Grundlagen ........................................................................... 119929.2 Objektzuordnung mit Entitätsklassen ....................................................... 120029.3 Mapping von Objekten ............................................................................ 1202

29.3.1 Das »Table«-Attribut ................................................................. 120229.3.2 Das »Column«-Attribut ............................................................. 1202

29.4 Verknüpfungen zwischen Entitäten .......................................................... 120329.4.1 Der Typ »EntityRef<T>« ............................................................ 120529.4.2 Verzögertes Laden .................................................................... 120629.4.3 Der Typ »EntitySet<T>« ............................................................. 120629.4.4 Ein weiteres Beispiel ................................................................. 120829.4.5 Sofortiges Laden der Daten ....................................................... 1208


25

Inhalt

29.5 Tools zur Erzeugung von Entitätsklassen .................................................. 121029.6 Die Klasse »DataContext« ........................................................................ 1211

29.6.1 Verbindungsaufbau ................................................................... 121129.6.2 Daten abfragen ......................................................................... 121129.6.3 Von einer LINQ-Abfrage erzeugtes SQL-Statement

ausgeben .................................................................................. 121229.6.4 Aktualisieren der Daten ............................................................ 121329.6.5 Konflikte behandeln ................................................................. 1216

29.7 Der LINQ to SQL-Designer (O/R-Designer) .............................................. 122229.7.1 Handhabung des O/R-Designers ............................................... 122229.7.2 Die abgeleitete »DataContext«-Klasse ....................................... 122629.7.3 Entitätsklassen .......................................................................... 1229

1231

30 Weitergabe von Anwendungen ..........................................................1231

30.1 Weitergabe mit MS-Installer .................................................................... 123130.1.1 Weitergabeprojekte .................................................................. 123230.1.2 Der Windows Installer .............................................................. 123330.1.3 Weitergabeprojekte mit dem Setup-Assistenten ........................ 123330.1.4 Editoren eines Weitergabeprojekts ........................................... 123630.1.5 Der Dateisystem-Editor ............................................................. 123830.1.6 Der Registrierungs-Editor .......................................................... 124530.1.7 Der Dateityp-Editor .................................................................. 124730.1.8 Der Benutzeroberflächen-Editor ................................................ 125030.1.9 Editor für benutzerdefinierte Aktionen ...................................... 126130.1.10 Editor für Startbedingungen ...................................................... 1262

30.2 ClickOnce-Verteilung .............................................................................. 126730.2.1 Allgemeine Beschreibung .......................................................... 126730.2.2 Erstellen einer ClickOnce-Anwendung ...................................... 126930.2.3 Installation einer ClickOnce-Anwendung .................................. 1273

Index ......................................................................................................................... 1275


27

Vorwort zur 5. Auflage

Mit dem Erscheinen des .NET Framework im Jahr 2002 wagte Microsoft einen revolutionä-ren Schritt und stellte eine Plattform bereit, die es möglich macht, nahezu alle erdenklichenAnwendungen mit einer Entwicklungssprache nach Wahl zu codieren. Innerhalb dieserSprachenvielfalt war C# die einzige wirklich von Grund auf neu gestaltete Sprache, spezia-lisiert auf und angepasst an das neue Framework. C# war damit auch frei von allen Altlas-ten, die teilweise die anderen Sprachen beeinflusst haben, und hat sich als die primäre.NET-Sprache etabliert.

Die Resonanz auf das .NET Framework war anfangs geteilt. Neben der vielfach geäußertenEuphorie gab es auch Skeptiker, die der neu geschaffenen Plattform kritisch gegenüberstan-den und an den angepriesenen Vorteilen zweifelten. Im Laufe der Zeit mussten aber auchdie Skeptiker erkennen, dass .NET viele Vorteile hat, die die Entwicklung von Programmenvereinfachen, und damit Raum und Zeit schafft, um bessere und effizientere Software zuschreiben.

Inzwischen sind acht Jahre vergangen. Viele kleine und große Softwareschmieden setzenderweil auf .NET. Deutlich erkennbar ist, dass insbesondere Unternehmensanwendungenund Portale mit dem .NET Framework realisiert wurden; ASP.NET und ADO.NET auf derBasis der Version 2.0 und 3.5 haben eine breite Akzeptanz gefunden, und LINQ und dieWindows Communication Foundation (WCF) sind in vielen jüngeren Anwendungen zu finden.

In der jüngsten Version 4.0 des .NET Framework sind natürlich ebenfalls wieder viele Neu-erungen enthalten. Diese sind aber nicht mehr so umfangreich wie bei den vergangenenVersionswechseln. Vielmehr wurde sehr viel Arbeit in die Verbesserung und Ergänzungbestehender Technologien investiert. Erwähnenswert, was den Inhalt dieses Buchesangeht, ist die TPL (Task Parallel Library), die uns die recht einfache Programmierung fürMehrkernprozessoren ermöglicht. Auch die Sprache C# hat ein paar Neuerungen erfahren.Gerechterweise muss man aber wohl sagen, dass die Neuerungen denen beispielsweise derVersion 2.0 im Jahr 2005 nicht das Wasser reichen können.

Visual Studio 2010 ist nun komplett mit der Windows Presentation Foundation (WPF) ent-wickelt worden. Es enthält ein paar Neuerungen und Verbesserungen und wirkt deshalbausgereifter als seine Vorgänger. Abgesehen von den neu angebotenen Editionen sind aberauch hier insgesamt die Neuerungen im Vergleich zu den bisherigen Versionen gering.

Natürlich kann ich Ihnen in dem vorliegenden Buch nicht alle Neuerungen und schon garnicht alle Tools vorstellen. Dafür ist die Kombination aus Visual Studio 2010 und .NET


28

Vorwort zur 5. Auflage

Framework viel zu umfangreich und vielseitig. Mit der neuen, vollständig überarbeiteten5. Auflage meines Buches zu C# versuche ich daher erst gar nicht, alle denkbaren Tiefen zuergründen. Stattdessen werde ich – wie auch schon in den ersten Auflagen dieses Buches –versuchen, ein gutes Fundament zu legen. In meinen Augen ganz wesentlich ist dabei dasVerständnis der objektorientierten Programmierung, die daher tiefgehend behandelt wird.Im weiteren Verlauf werde ich Sie mit einigen wichtigen Klassen vertraut machen, die inden meisten Anwendungen eine wichtige Rolle spielen. Im Vergleich zu den vorangegan-genen Auflagen habe ich weitere Themen aufgenommen, beispielsweise die ThematikXML. Da die WPF in der Praxis immer mehr an Bedeutung gewinnt, habe ich in diesemBuch den WPF-Teil deutlich ergänzt. Damit musste allerdings die Entwicklung von Win-Form-Anwendungen den Platz räumen. Auch wenn das der eine oder andere Leser bedau-ern und kritisieren mag, der WPF gehört die Zukunft, und auch ohne WinForm-Anwen-dungen ist das Buch am Rande des technisch umsetzbaren Umfangs angekommen.

Aachen-Oberforstbach,Andreas Kühnel

[email protected]


29

1 Allgemeine Einführung in .NET

Einem Leser, der über fundierte Grundlagenkenntnisse verfügt, eine Thematik nahezubrin-gen, die seine Aufmerksamkeit erregt und ihm neue Kenntnisse vermittelt, ist ein nichtganz einfaches Unterfangen. Dabei gleichzeitig auch einen Programmieranfänger behutsamin die abstrakte Denkweise der Programmlogik einzuführen, ohne gleichzeitig Frust undEnttäuschung zu verbreiten, dürfte nahezu unmöglich sein. Ich versuche mit diesem Buchdennoch diesen Weg zu beschreiten, auch wenn es manchmal einer Gratwanderung zwi-schen zwei verschiedenen Welten gleicht. Dabei baue ich schlicht und ergreifend auf denjahrelangen Erfahrungen auf, die ich als Trainer bei den unterschiedlichsten Seminaren mitteilweise ausgesprochen heterogenen Gruppen erworben habe.

1.1 Warum .NET?

Vielleicht wissen Sie überhaupt noch nicht, was sich hinter .NET verbirgt? Vielleicht habenSie sich für dieses Buch entschieden, ohne die Tragweite Ihres Entschlusses für .NET zukennen. Ich möchte Ihnen das zunächst einmal erläutern.

Blicken wir ein paar Jahre zurück, sagen wir mal in die 90er-Jahre, und stellen wir uns dieFrage, wie damals Anwendungen entwickelt worden sind und wie sich die IT-Welt wäh-rend dieser Zeit entwickelt hat. Am Anfang des von uns betrachteten Jahrzehnts war derHauptschauplatz der Desktop-PC; Netzwerke steckten noch mehr oder weniger in den Kin-derschuhen. Grafische Benutzeroberflächen hielten langsam Einzug auf den Rechnern, dasInternet war einem nur mehr oder weniger elitären Benutzerkreis bekannt und zugänglich.Desktop-PCs wurden mit immer besserer Hardware ausgestattet, ein Super-PC von 1990galt zwei Jahre später als total veraltet und musste wegen der gestiegenen Anforderungender Software an die Hardware oft zumindest drastisch aufgerüstet, wenn nicht sogar ersetztwerden.

Sie merken vielleicht an diesen wenigen Worten, wie dramatisch sich die IT-Welt seitdemverändert hat. Die Evolution betraf aber nicht nur Software und Hardware. Software muss,ehe sie den Benutzer bei seiner täglichen Arbeit unterstützen kann, entwickelt werden.Hier kochten viele Unternehmen ein eigenes Süppchen und warben bei den Entwicklernund Entscheidungsträgern mit Entwicklungsumgebungen, die zum einem auf den unter-schiedlichsten Programmiersprachen aufsetzten und zudem auch noch mit eigenen Funkti-


30

Allgemeine Einführung in .NET1

onsbibliotheken aufwarteten: Borlands Delphi, Microsofts Visual Basic, für die Puristen Cund C++ – um nur die bekanntesten Vertreter zu nennen.

Die Vielfalt betraf jedoch nicht nur die Entwicklung der Software. Immer neue Plattformen,angepasst an den jeweils aktuellen Trend der Zeit, eroberten den Markt und verschwandennicht selten auch schnell wieder. Die Unternehmensnetzwerke mussten mit der stürmi-schen Entwicklung Schritt halten, wurden komplexer und komplizierter und öffneten sichzunehmend auch der Welt nach außen.

In dieser Periode begann auch der Siegeszug des Internets. Obgleich es anfangs nur alsweltweiter Verteiler statischer Dateninformationen positioniert war, wurden immer mehrTechnologien ausgedacht, die die statischen Webseiten durch dynamische ersetzten, diedem Anwender nicht immer dieselben Informationen bereitstellten, sondern genau die, fürdie er sich interessierte. Datenbanken wurden hinter die Webserver geschaltet und fütter-ten die Webseiten mit dem aktuellsten Informationsstand.

Kluge Köpfe erkannten auch sehr schnell, dass die Spezifikationen des Internets sich auchdazu eignen, mehrere verschiedene Unternehmen zu koppeln. Damit wurde die Grundlagedafür geschaffen, dass Sie heute im Reisebüro oder im Internet-Browser eine Reise buchenkönnen, die nicht nur den Flug, sondern gleichzeitig auch eine gültige Hotelzimmer-buchung, vielleicht sogar samt Mietwagen, beinhaltet – obwohl hierzu schon drei Informa-tionsquellen mit unterschiedlicher Software abgezapft werden müssen: ein nicht ganz ein-faches Unterfangen, wenn Sie bedenken, dass möglicherweise die Schnittstellen, über diedie verschiedenen Komponenten sich zwangsläufig austauschen müssen, nicht einheitlichdefiniert sind.

Bei dieser rasanten Entwicklung der Möglichkeiten, Daten auszutauschen oder auch nureinfach weiterzuleiten, sollten Sie nicht vergessen, dass auch die Hardware eine ähnlicheEntwicklung genommen hat. Ein Handy besitzen heutzutage schon die meisten schulpflich-tigen Kinder, und Pocket-PCs, PDAs und andere Kleincomputer haben schon lange ihrenSiegeszug angetreten, dessen Ende nicht im Entferntesten erkennbar ist.

An der Schnittstelle all dieser Vielfältigkeit steht der Entwickler. Denn was nützen die besteHardware und die ausgeklügelsten Spezifikationen, wenn die Bits sich nicht den Weg voneinem zum anderen Endpunkt bahnen? Für diesen Bitfluss wollen Sie als Entwickler sor-gen. Damit fangen aber wegen der oben erwähnten Vielgestaltigkeit der IT-Welt die Pro-bleme an: verschiedene Plattformen, unterschiedliche Programmiersprachen, mehrereKlassenbibliotheken, eine Vielzahl zu beachtender Spezifikationen usw.

Einen ersten Schritt in Richtung Vereinheitlichung beschritt die Firma Sun mit Java. DerErfolg, den diese plattformunabhängige Sprache hatte und auch immer noch hat, war auchein Zeichen für Microsoft, um das Entwicklerterrain zu kämpfen. Nach einer eingehendenAnalyse der Anforderungen, die gegen Ende der 90er-Jahre an die damalige Software


31

Warum .NET? 1.1

gestellt wurden, sowie einer Trendanalyse der Folgejahre wurde das .NET Framework ent-wickelt. Dabei konnte Microsoft die Gunst der späten Stunde nutzen und die Nachteile undSchwachpunkte, die jedes Produkt – also auch Java – hat, durch neue Ideen ausmerzen.

Nein, .NET ist natürlich auch kein Heilsbringer und wird sicherlich nicht die Menschheitüberdauern. Aber nach heutigen Maßstäben ist .NET das wahrscheinlich effizienteste Frame-work, in dessen Mittelpunkt die .NET Klassenbibliothek steht. Diese bietet Ihnen alles, wasSie zum Entwickeln brauchen – egal, ob es sich um eine einfache Anwendung handelt, dienur ein paar Daten anzeigt, oder um eine Unternehmensanwendung großen Stils. Sie kön-nen Desktop-Anwendungen genauso erstellen wie eine hochkomplexe Internet-Anwen-dung. Sie können die Office-Produkte damit programmieren, fremde Datenquellen anzap-fen, Programme für Ihren Pocket-PC schreiben und vieles mehr. Dazu müssen Sie sich nichtimmer wieder in neue Programmiersprachen und neue Entwicklungsumgebungen einar-beiten, denn alles ist wie aus einem Guss.

Ich möchte jetzt nicht den Eindruck vermitteln, dass alles ganz einfach ist und Sie dem-nächst ganz tolle Anwendungen mit den unglaublichsten Features präsentieren können.Dafür ist die .NET-Klassenbibliothek einfach zu umfangreich. Aber Sie können sich daraufverlassen, dass Sie sich nun auf das Wesentliche Ihrer Arbeit konzentrieren können: Siearbeiten unabhängig vom Typ der zu entwickelnden Anwendung immer in derselbenUmgebung, zum Beispiel mit Visual Studio 2010. Sie brauchen sich nicht immer wiederaufs Neue in andere Programmiersprachen einzuarbeiten, sondern können auf gewonneneKenntnisse aufsetzen. Und Ihnen werden alle Mittel an die Hand gegeben, um auf wirklicheinfachste Weise mit fremden Anwendungen zu kommunizieren, wenn sich diese anbestimmten, allgemein anerkannten Spezifikationen orientieren. XML ist hierbei das Zau-berwort, das das alles ermöglicht.

Eine Funktionsbibliothek (eigentlich müsste ich an dieser Stelle richtigerweise von einerKlassenbibliothek sprechen) ist nur so gut, wie sie auch zukünftige Anforderungen befrie-digen kann. Dass .NET hier architektonisch den richtigen Weg beschritten hat, beweist diederzeit aktuelle Version 4.0.

Genau an dieser Stelle darf ich Ihnen natürlich auch den großen Haken nicht verschweigen,den die ansonsten so hervorragende Umgebung hat: Sie werden mit Sicherheit niemals alleTiefen von .NET ergründen. Als jemand, der von der ersten Beta-Version an mit dabei war,muss ich sagen, dass ich mich immer wieder aufs Neue davon überraschen lassen muss,welche Fähigkeiten in der .NET-Klassenbibliothek schlummern. Verabschieden Sie sich vonder Idee, jemals alle Klassen mit ihren Fähigkeiten erfassen zu können. Die Klassenbiblio-thek ist einfach zu mächtig.


32


1.1.1 Ein paar Worte zu diesem Buch

Mit der Einführung von .NET in den Jahren 2001/2002 änderte sich die Philosophie der An-wendungsentwicklung – zumindest im Hause Microsoft. Die Karten wurden neu gemischt,denn das architektonische Konzept war – zumindest Microsoft – neu. Da .NET grundsätzlichplattformunabhängig ist, ähnlich wie Java auch, zeigte Microsoft gleichzeitig zum erstenMal ernsthaft die Akzeptanz anderer Plattformen.

.NET ist zu 100 % objektorientiert. Das ist Fakt. Obwohl das objektorientierte Programmie-ren schon seit vielen Jahren in vielen Sprachen eingeführt worden ist, sind nicht alle pro-fessionellen Entwickler in der Lage, auf dieser Basis Programme zu entwickeln. Teilweisesträuben sie sich sogar mit Händen und Füßen gegen die Denkweise in Klassen und Objek-ten, denn ihre Denkweise ist zu sehr in der prozeduralen Programmierung verwurzelt.

Es spielt keine Rolle, ob man einfachste Programme zur Konsolenausgabe entwickelt, lokaleWindows-Anwendungen oder Applikationen für das Internet – immer spielen Klassen undObjekte die tragende Rolle. Daher ist es unumgänglich, zunächst die Grundlagen einer.NET-Entwicklungssprache einschließlich des objektorientierten Ansatzes zu beherrschen,bevor man sich in das Abenteuer visualisierter Oberflächen stürzt.

Mit diesem Buch möchte ich Ihnen diese notwendigen Grundlagen fundiert und gründlichvermitteln und danach zeigen, wie mit der Windows Presentation Foundation (WPF) Win-dows-Anwendungen entwickelt werden und wie Sie mit ADO.NET auf Datenbankenzugreifen. Das Buch ist in Kapitel aufgeteilt, die logisch aufeinander aufbauen. Jedes Kapitelenthält wiederum einzelne Abschnitte, die ein untergeordnetes Thema abgrenzen. DieGliederung könnte man wie folgt beschreiben:

� Einführung in die Entwicklungsumgebung

� die Sprachsyntax von Visual C# einschließlich des objektorientierten Ansatzes

� die wichtigsten .NET-Klassenbibliotheken

� die Entwicklung einer grafischen Benutzerschnittstelle mit der Windows PresentationFoundation (WPF)

� Datenzugriffe mit ADO.NET und LINQ to SQL

In diesem Kapitel werden zuerst die elementaren Grundlagen von .NET erörtert. Zwangs-läufig werden Sie daher auf Begriffe stoßen, die Ihnen möglicherweise zu diesem Zeitpunktnicht sehr viel sagen. Ich gebe gern zu, auch ich hasse Bücher, die sich zunächst ausgiebigüber eine Technologie auslassen, mit Fachbegriffen jonglieren und sich erst nach einigenfrustrierenden Seiten dem eigentlichen Thema widmen. Dennoch ist es unumgänglich,zuerst den Kern von .NET mit seinen Vorteilen für den Programmierer zu erläutern, bevorman sich mit der Sprache auseinandersetzt. Allerdings werde ich mir Mühe geben, Siedabei nicht allzu sehr zu strapazieren, und mich auf das beschränken, was für den Einstieg


33

Warum .NET? 1.1

als erste Information unumgänglich ist. Lassen Sie sich also nicht entmutigen, wenn einBegriff fällt, den Sie nicht zuordnen können, und lesen Sie ganz locker weiter – in diesemBuch werde ich nichts als bekannt voraussetzen: Sie werden alles noch intensiv lernen.

Bevor wir uns ab Kapitel 2 der Sprache widmen, wird die überarbeitete Entwicklungsum-gebung Visual Studio 2010 vorgestellt (die übrigens jetzt auch mit der WPF designt wurde).Wenn Sie mit einer alten Version von Visual Studio gearbeitet haben, werden Sie sicherlichschnell mit der neuen vertraut. Sollten Sie keine Erfahrungen mitbringen, dürften amAnfang einige Probleme mit dem Handling auftreten. Dazu kann ich Ihnen nur einen Ratgeben: Lassen Sie sich nicht aus der Fassung bringen, wenn sich wie von Geisterhandklammheimlich plötzlich ein Fenster in die Entwicklungsumgebung scrollt oder Sie dieÜbersicht verlieren – vor den Erfolg haben die Götter den Schweiß gesetzt.

In Kapitel 2 beginnen wir mit dem eigentlichen Thema dieses Buches. Ich stelle Ihnen dieSyntax der Sprache Visual C# 2010 vor, lasse dabei aber noch sämtliche Grundsätze desobjektorientierten Ansatzes weitestgehend außer Acht. Sie sollen zunächst lernen, Variab-len zu deklarieren, mit Daten zu operieren, Schleifen zu programmieren usw. In den Kapi-teln 3 bis 15 wenden wir uns ausführlich dem objektorientierten Ansatz zu und werdenauch ein paar besondere Technologien beleuchten.

XML ist in der modernen Software allgegenwärtig. Daher wird in Kapitel 16 XML näherbeleuchtet, und Sie werden die wohl wichtigsten Klassen im Zusammenhang mit der XML-Verarbeitung kennenlernen.

Diese Kapitel gehören sicherlich zu den wichtigsten in diesem Buch, denn Sie werden nie-mals eine .NET-basierte Anwendung entwickeln können, wenn Sie nicht in der Lage sind,klassenorientierten Code zu lesen und zu schreiben.

Anschließend stelle ich Ihnen die Windows Presentation Foundation (WPF) vor. Mit dieserProgrammierschnittstelle können Sie Windows-Anwendungen entwickeln, die auf derBeschreibungssprache XAML basieren.

Datenbanken spielen in nahezu jeder Anwendung eine wichtige Rolle. In den letzten Kapi-teln werden wir uns daher mit ADO.NET beschäftigen. ADO.NET beschreibt Klassen, umauf Daten aus einer beliebigen Datenquelle, hier insbesondere einer Datenbank, zuzugrei-fen. Ganz zum Schluss darf natürlich auch eine Beschreibung der Verteilungstechnikeneiner .NET-Anwendung nicht fehlen.

Vielleicht werden Sie sich fragen, wo denn ASP.NET-Webanwendungen, ASP.NET-Web-dienste, .NET-Remoting, die Windows Communication Foundation (WCF) usw. ihre Erwäh-nung finden. Meine Antwort dazu lautet: nirgendwo in diesem Buch. Denn schauen Siesich nur den Gesamtumfang des Buches an, das Sie gerade in den Händen halten. Die The-men, die hier beschrieben sind, werden nicht nur oberflächlich behandelt, sondern gehenoft auch ins Detail. So bleibt leider einfach kein Platz mehr für die anderen Technologien.


34


1.1.2 Die Beispielprogramme

Begleitend zu der jeweiligen Thematik werden in jedem Kapitel Beispiele entwickelt, dieSie auf der DVD-ROM finden, die diesem Buch beiliegt. Im Buch sind diese Beispiele amAnfang des Quellcodes wie folgt gekennzeichnet:

Dieses Beispiel gehört demnach zu Kapitel 6, und der Name der Anwendung lautet EinBei-spielprogramm.

Eine allgemeine Bemerkung noch zu den Beispielen und Codefragmenten. Als Autor einesProgrammierbuches steht man vor der Frage, welchen Schwierigkeitsgrad die einzelnenBeispiele haben sollen. Werden komplexe Beispiele gewählt, liefert man häufig eine Scha-blone, die in der täglichen Praxis mit mehr oder weniger vielen Änderungen oder Ergän-zungen übernommen werden kann. Andererseits riskiert man damit aber auch, dass mitder Komplexität der Blick des Lesers für das Wesentliche verloren geht und schlimmsten-falls die Beispiele nicht mit der Intensität studiert werden, die zum Verständnis der Thema-tik erforderlich wäre.

Ich habe mich für einfachere Beispielprogramme entschieden. Einen erfahrenen Entwicklersollte das weniger stören, weil er sich normalerweise mehr für die Möglichkeiten der Spra-che interessiert, während für einen Einsteiger kleine, überschaubare Codesequenzen ver-ständlicher und letztendlich auch motivierender sind.

1.2 .NET unter die Lupe genommen

In den folgenden Abschnitten schauen wir uns jetzt ein wenig genauer an, was es mit .NETauf sich hat.

1.2.1 Das Entwicklerdilemma

Mit .NET hat Microsoft im Jahr 2002 eine Entwicklungsplattform veröffentlicht, die inzwi-schen von vielen Entwicklungsteams akzeptiert und auch eingesetzt wird. KommerzielleGründe spielten für Microsoft sicherlich auch eine Rolle, damals einen Neuanfang in derPhilosophie seiner Softwareentwicklung herbeizuführen.

In den Jahren zuvor hatte sich bereits abgezeichnet, dass sich die Ansprüche an moderneSoftware grundlegend ändern würden. Das Internet spielte dabei wohl die wesentlichsteRolle, aber auch die Anforderung, dem erhöhten Aufkommen clientseitiger Anfragen aneinen Zentralserver durch skalierbare Anwendungen zu begegnen. Der Erfolg von Java, das

// ---------------------------------------------------------// Beispiel: ...\Kapitel 6\EinBeispielprogramm // ---------------------------------------------------------


35

.NET unter die Lupe genommen 1.2

sich in den Jahren zuvor als eine der bedeutendsten Programmiersprachen etablierte, magder Beweis dafür sein, denn Java spielt seine Stärken in erster Linie bei der Entwicklungwebbasierter und verteilter Anwendungen aus.

Die damaligen Probleme waren nicht neu, und entsprechende Technologien gab es schonlänger – auch bei Microsoft. Mit COM/COM+ ließen sich zwar auch vielschichtige und ska-lierbare Anwendungen entwickeln, aber unzweifelhaft war die Programmierung vonCOM+ wegen der damit verbundenen Komplexität als nicht einfach zu bezeichnen. Es gibtnicht sehr viele Entwickler, die von sich behaupten können, diese Technologie im Griffgehabt zu haben. Damit trat auch ein Folgeproblem auf, denn grundsätzlich gilt: Je kompli-zierter eine Technologie ist, desto fehleranfälliger wird die Software. Man muss nicht unbe-dingt ein Microsoft-Gegner sein, um zu sagen, dass selbst der Urheber dieser Technologiendiese oft nur unzureichend in den hauseigenen Produkten umsetzt.

Die Aussage, dass die Vorteile der .NET-Systemplattform nur der Entwicklung verteilterSysteme wie dem Internet zugutekommen, beschreibt ihre Möglichkeiten nur völlig unzu-reichend. Selbstverständlich lassen sich auch einfache Windows- und Konsolenanwendun-gen auf Basis von .NET entwickeln. Die Vorteile beziehen sich aber nicht nur auf Anwen-dungen selbst, sondern lösten auch ein Dilemma der Entwickler. Die Entscheidung für einebestimmte Programmiersprache war in der Vergangenheit fast schon eine Glaubensfrage –nicht nur, was die Programmiersprache anging, denn die Festlegung auf eine bestimmteSprache war auch die Entscheidung für eine bestimmte Funktions- bzw. Klassenbibliothek.

Windows-Programme basieren alle auf der Systemschnittstelle einer Funktionssammlung,die als WinAPI-32 bezeichnet wird. Da diese Funktionssammlung einige Tausend Funktio-nen enthält, wurden verwandte Funktionalitäten in Klassen zusammengeführt und konntenüber Methodenaufrufe angesprochen werden. Dieses Prinzip vereinfachte die Programmie-rung deutlich, aber bedauerlicherweise gab es nicht eine einzige, sondern gleich mehrere,herstellerspezifische Klassenbibliotheken, die zwar ein ähnliches Leistungsspektrum aufwie-sen, aber grundlegend anders definiert waren. Die Microsoft Foundation Classes (MFC) fürVisual C++ ist die Klassenbibliothek von Microsoft, und Borland-Inprise kochte mit derObject Windows Library (OWL) ein eigenes Süppchen. Der Wechsel von einer Programmier-sprache zu einer anderen bedeutete in der Regel auch, sich in eine andere Bibliothek einzu-arbeiten. Beides kostet nicht nur sehr viel Zeit, sondern bedeutet auch finanziellen Aufwand.

Es mag fast erstaunen (oder auch nicht), dass es neben Windows tatsächlich auch nochandere Betriebssysteme gibt, denen man durchaus auch eine Existenzberechtigungzuschreiben muss. Die Entwickler von Java haben das schon vor Jahren erkannt und mitder Virtual Machine (VM) eine Komponente bereitgestellt, die auf verschiedene Betriebs-systemplattformen portiert werden kann. Dies ist einer der größten Vorteile von Java undhat sicherlich viele Entscheidungsträger in den Unternehmen beeinflusst. Code lässt sichauf Windows-Plattformen entwickeln und auf einer Unix-Maschine installieren – ein reiz-


36


voller Gedanke, Investitionen von einem bestimmten System zu lösen und sie nicht daranzu binden.

1.2.2 .NET – ein paar allgemeine Eigenschaften

Es ist kein Zufall, dass ich im vorigen Abschnitt öfter Java erwähnt habe. Wenn Sie das Kon-zept von Java kennen oder vielleicht in der Vergangenheit sogar mit Java programmierthaben, werden Sie sehr viele Parallelen zu .NET wiedererkennen. Microsoft ist in der Ver-gangenheit sicher nicht entgangen, worauf der Erfolg von Java zurückzuführen ist. InKenntnis der Fakten hat man die Idee, die hinter Java steckt, übernommen und dabei ver-sucht, die bekannten Schwachstellen des Ansatzes bzw. der Sprache auszumerzen. Es darfsich bei Ihnen jetzt allerdings nicht die Meinung festigen, .NET sei nur eine Kopie von Java– .NET hat die Messlatte spürbar höher gelegt.

Wir wollen uns nun ansehen, welche wesentlichen programmiertechnischen Neuerungen.NET mit sich bringt:

� Objektorientierung .NET ist zu 100 % objektbasiert und bildet eine konsistente Schicht zur Anwendungsent-wicklung. Es gibt keine Elemente, die sich nicht auf Objekte zurückführen lassen. Sogarso einfache Datentypen wie der Integer werden als Objekte behandelt. Auch Zugriffe aufdas darunterliegende Betriebssystem werden durch Klassen gekapselt.

� WinAPI-32-Ersatz Langfristig beabsichtigt Microsoft, die Win32-API durch die Klassen des .NET Frame-works zu ersetzen. Damit verwischen auch die charakteristischen Merkmale der ver-schiedenen Sprachen. Ob eine Anwendung mit Visual Basic .NET programmiert wirdoder mit C# oder C++ – es spielt keine Rolle mehr. Alle Sprachen greifen auf die gleicheBibliothek zurück, sprachspezifische, operative Bibliotheken gibt es nicht mehr. DieKonsequenz ist, dass die Wahl einer bestimmten Sprache nicht mehr mit der Entschei-dung gleichzusetzen ist, wie effizient eine Anwendung geschrieben werden kann oderwas sie zu leisten imstande ist.

� Plattformunabhängigkeit Anwendungen, die auf .NET basieren, laufen in einer Umgebung, die mit der virtuellenMaschine von Java verglichen werden kann, in der erst zur Laufzeit einer Anwendungder Maschinencode erzeugt wird. Die Spezifikation der Laufzeitumgebung (CommonLanguage Runtime – CLR) ist keine geheime Verschlusssache von Microsoft, sondernoffen festgelegt. In letzter Konsequenz bedeutet das aber auch, dass sich die CommonLanguage Runtime auch auf Plattformen portieren lässt, die nicht Windows heißen, z. B.auf Unix oder Linux. Als Beweis sei hier das Mono-Projekt genannt, mit dem .NETerfolgreich auf die Linux-Plattform portiert worden ist.


37


� Sprachunabhängigkeit Es spielt keine Rolle, in welcher Programmiersprache eine Komponente entwickeltwird. Eine in C# 2010 geschriebene Klasse kann aus VB.NET, F# oder jeder anderen.NET-konformen Sprache heraus aufgerufen werden, ohne den Umweg über eine spezi-fizierte Schnittstellentechnologie wie COM/COM+ gehen zu müssen. Darüber hinauslässt sich beispielsweise eine in Visual C# implementierte Klasse auch aus einer VB.NET-Klasse ableiten – oder umgekehrt.

� Speicherverwaltung Die Freigabe von nicht mehr benötigtem Speicher war schon immer ein Problem. Unter.NET braucht sich ein Entwickler darum nicht mehr zu kümmern, da der im Hintergrundarbeitende Prozess des Garbage Collectors diese Aufgaben übernimmt und nicht mehrbenötigte Objekte erkennt und automatisch aus dem Speicher entfernt.

� Weitergabe Ein .NET-Programm weiterzugeben ist viel einfacher geworden – insbesondere im Ver-gleich zu einem auf COM basierenden Programm, das Einträge in die Registrierungsda-tenbank vornehmen muss. Im einfachsten Fall reicht es vollkommen aus, ein .NET-Pro-gramm (d. h. eine EXE- oder DLL-Datei) in das dafür vorgesehene Verzeichnis zukopieren. Darüber hinaus ist aber auch die Verteilung mit einem Installationsassistentenund – ganz neu unter .NET 2.0 – mit ClickOnce möglich.

1.2.3 Das Sprachenkonzept

Die drei Entwicklungssprachen, die in der Vergangenheit hauptsächlich das Bild in derAnwendungsentwicklung prägten, waren C++, Java und Visual Basic 6.0. Seit dem Jahr2002 und dem Erscheinen des .NET Frameworks 1.0 gesellten sich noch die .NET-Sprachendazu, allen voran C#.

Betrachten wir jetzt nur die drei zuerst genannten Sprachen. Nehmen wir an, wir würdenmit jeder ein einfaches ausführbares Programm schreiben. Wie sehen die Kompilate dieserdrei Sprachen aus, und wie werden die drei Kompilate ausgeführt, wenn wir sie auf einenRechner kopieren, auf dem nur das Betriebssystem installiert ist?

� Nach der Kompilierung des C/C++-Quellcodes erhalten wir eine .exe-Datei, die beispiels-weise durch einen einfachen Doppelklick im Explorer des frisch installierten Rechnersgestartet werden kann. Das Kompilat wird jedoch auf einer anderen Plattform nicht lauf-fähig sein, denn dazu wäre zuerst eine Neukompilierung erforderlich.

� Eine mit dem VB6-Compiler erzeugte ausführbare Datei kann auf unserer jungfräulichenBetriebssysteminstallation nicht sofort gestartet werden, obwohl die Dateiendung .exelautet. Wir benötigen zur Ausführung einen Interpreter, d. h. das Laufzeitmodul vonVisual Basic, der uns den kompilierten Zwischencode in den ausführbaren nativen CPU-Maschinencode übersetzt. Die Portierung eines VB-Programms auf eine andere Platt-form ist nicht möglich.


38


� Java arbeitet prinzipiell ähnlich wie Visual Basic 6.0. Es wird ein Zwischencode gene-riert, der sogenannte Bytecode. Die kompilierten Dateien haben die Dateiendung .class.Zur Laufzeit wird dieser Code zuerst durch einen Interpreter geschickt, der als virtuelleMaschine (VM) bezeichnet wird. Vorausgesetzt, die VM wurde bei der Installation desBetriebssystems installiert, kann man die Java-Anwendung starten. Das Kompilat istsogar plattformunabhängig und kann auch auf andere Systeme verteilt werden.

Insbesondere die Plattformunabhängigkeit des Kompilats ist bisher ein deutliches Argu-ment für viele Unternehmen gewesen, nicht nur in heterogenen Umgebungen verstärkt aufJava zu setzen.

Entwickeln wir eine .NET-basierte Anwendung, ähnelt der Ablauf der Kompilierung biszum Start der Laufzeitumgebung dem Ablauf unter Java. Zuerst wird ein Zwischencodeerzeugt, der CPU-unabhängig ist. Die Dateiendung lautet .exe, wenn wir eine eigenstart-fähige Anwendung entwickelt haben. Allerdings ist diese Datei nicht ohne Weiteres lauf-fähig: Sie benötigt zur Laufzeit einen »Endcompiler«, der den Zwischencode in nativen,plattformspezifischen Code übersetzt. Der Zwischencode einer .NET-Anwendung wird alsMSIL-Code (Microsoft Intermediate Language) oder nur kurz als IL bezeichnet, und derEndcompiler wird JIT-Compiler (Just-In-Time) oder kurz JITter genannt.

Abbildung 1.1 Der Ablauf der Entwicklung eines .NET-Programms bis zur Laufzeit

1.2.4 Die Common Language Specification (CLS)

Wenn Sie sich in Abbildung 1.1 den Prozessablauf vom Quellcode bis zur Ausführung einer.NET-Anwendung ansehen, müssten Sie sich sofort die Frage stellen, wo der Unterschiedim Vergleich zu einer Java-Anwendung zu finden ist – das Diagramm scheint, bis auf dieNamensgebung, austauschbar zu sein. Dabei verzichten wir jedoch darauf, andere spezifi-

Quellcode

MSIL-Code(.exe-Datei)

Compiler

JITter

nativer Code

Entwicklungszeit

Laufzeit


39


sche Merkmale der beiden Umgebungen zu betrachten, die bei einer genaueren Analyseauch eine Rolle spielen würden.

Vielleicht ist es Ihnen nicht aufgefallen, aber ich habe die Worte ».NET-Anwendung« und»Java-Anwendung« benutzt – eine kleine Nuance mit weitreichender Konsequenz. EineJava-Anwendung ist, darauf weist schon der Name hin, mit der Programmiersprache Javaentwickelt worden; eine .NET-Anwendung hingegen ist nicht sprachgebunden. Sicher, indiesem Buch werden wir uns mit Visual C# beschäftigen, aber es macht praktisch keinenUnterschied, ob die Anwendung in Visual C# 2010, in Visual Basic 2010 oder F# entwickeltworden ist. Ausschlaggebend ist am Ende des Kompiliervorgangs nur ein kompatibler IL-Code, ungeachtet der zugrunde liegenden Sprache.

Um sprachunabhängigen Code erzeugen zu können, muss es Richtlinien geben, an die sichalle .NET-Sprachen halten müssen, um ein Fiasko zu vermeiden. Diese Richtlinien, indenen die fundamentalen Eigenschaften einer .NET-kompatiblen Sprache festgelegt sind,werden durch die Common Language Specification (CLS) beschrieben. Die Common Langu-age Specification ist ein offener Standard. Das hatte schon frühzeitig zur Folge, dass langevor der offiziellen Einführung von .NET viele Softwareunternehmen andere Sprachen, bei-spielsweise Delphi, Eiffel und Cobol auf .NET portiert haben.

Wenn alle Sprachen tatsächlich gleichberechtigt sind und dasselbe Ergebnis liefern, stelltsich natürlich die Frage, warum es zukünftig nicht nur eine Sprache gibt. Sogar Microsoftbietet mit C#, F#, C++ und VB .NET im Visual Studio vier verschiedene Sprachen an. DerGrund ist recht einfach: Man möchte den Entwicklern nicht eine vollkommen neue Spra-che aufzwingen, sondern ihnen die gewohnte sprachspezifische Syntax lassen.

Abbildung 1.2 Die Common Language Specification als Basis der Sprachunabhängigkeit

Wenn Sie nun anmerken sollten, dass es sich bei C# um eine völlig neue Sprache handelt,die mit der Veröffentlichung des .NET Frameworks zur Verfügung gestellt worden ist,

Visual Basic C# C++

Common Language Specification (CLS)

.NET-Framework

(weitere)


40


haben Sie vollkommen recht. Allerdings assoziiert bereits der Name C# unzweifelhaft, dassdie Wurzeln dieser Sprache in C/C++ zu finden sind.

Die Konsequenzen, die sich aus der CLS ergeben, sind weitreichend – nicht für den End-anwender, den es nicht im geringsten interessiert, in welcher Sprache seine Applikationentwickelt wird, sondern vielmehr für ein heterogenes Entwicklerteam in einem Software-unternehmen. Die Entscheidung, eine Anwendung auf der Grundlage von .NET zu entwi-ckeln, ist keine Entscheidung für oder gegen eine Sprache – es ist eine konzeptionelle Fest-legung. Die Bedeutung der einzelnen Sprachen rückt in den Hintergrund, denn dieKomponenten, die in einer .NET-konformen Sprache geschrieben sind, können problemlosmiteinander interagieren. Eine Klasse, die in C# geschrieben ist, kann von einer Klasse inVisual Basic 2010 beerbt werden. Beide Klassen können Daten miteinander austauschenund Ausnahmen weiterreichen. Es gibt unter .NET keine bevorzugte Programmiersprache.

1.2.5 Das Common Type System (CTS)

Jede Entwicklungsumgebung beschreibt als eines ihrer wichtigsten Merkmale ein Typsys-tem, in dem einerseits Datentypen bereitgestellt werden und andererseits Vorschriftendefiniert sind, nach denen ein Entwickler die standardmäßigen Typen durch eigene erwei-tern kann. Darüber hinaus muss auch eine Regelung getroffen werden, wie auf die Typenzugegriffen wird.

Mit dem Common Type System (CTS) der .NET-Plattform wird die sprachübergreifende Pro-grammentwicklung spezifiziert und sichergestellt, dass Programmcode unabhängig von derzugrunde liegenden Sprache miteinander interagieren kann. Damit legt das Common TypeSystem die Grundlage für die im vorhergehenden Abschnitt erläuterte Sprachunabhängigkeit.

Alle Typen, die unter .NET zur Verfügung gestellt werden, lassen sich in zwei Kategorienaufteilen:

� Wertetypen

� Referenztypen

Wertetypen werden auf dem Stack abgelegt. Zu ihnen gehören die in der Entwicklungsum-gebung eingebauten ganzzahligen Datentypen und die Datentypen, die Fließkommazahlenbeschreiben. Referenztypen werden hingegen auf dem Heap abgelegt. Zu ihnen gehörenunter anderem die aus den Klassen erzeugten Objekte.

Obwohl Wertetypen im ersten Moment nicht den Anschein erwecken, dass sie von der.NET-Laufzeitumgebung als Objekte behandelt werden, ist dies kein Widerspruch zu derAussage von vorhin, dass .NET nur Objekte kennt. Tatsächlich erfolgt zur Laufzeit eineautomatische Umwandlung von einem Werte- in einen Referenztyp durch ein Verfahren,das als Boxing bezeichnet wird.


41


Typen können ihrerseits Mitglieder enthalten: Felder, Eigenschaften, Methoden und Ereig-nisse. Dem Common Type System nur die Festlegung von Typen zuzuschreiben, würde dievielfältigen Aufgaben nur vollkommen unzureichend beschreiben. Das CTS gibt zudem dieRegeln vor, nach denen die Sichtbarkeit dieser Typmitglieder festgelegt wird. Ein als öffent-lich deklariertes Mitglied eines vorgegebenen Typs könnte beispielsweise über die Grenzender Anwendung hinaus sichtbar sein; andere Sichtbarkeiten beschränken ein Mitglied aufdie aktuelle Anwendung oder sogar nur auf den Typ selbst.

Das vom Common Type System festgelegte Regelwerk ist grundsätzlich nichts Neues. Alleanderen Sprachen, auch die, die nicht auf .NET aufsetzen, weisen ein ähnliches Merkmalauf, um ein Typsystem in die Sprache zu integrieren. Aber es gibt einen entscheidendenUnterschied, durch den sich alle Sprachen der .NET-Umgebung vom Rest abheben: Wäh-rend die Definition des Typsystems bei herkömmlichen Sprachen Bestandteil der Spracheselbst ist, wandert das .NET-Typsystem in die Laufzeitumgebung. Die Folgen sind gravie-rend: Kommunizieren zwei Komponenten miteinander, die in unterschiedlichen Sprachenentwickelt worden sind, sind keine Typkonvertierungen mehr notwendig, da sie auf dem-selben Typsystem aufsetzen.

Stellen Sie sich vor, es würde keine Regelung durch das CTS geben und C# würde einenbooleschen Typ definieren, der 2 Byte groß ist, während C++ .NET denselben Datentypdefiniert, jedoch mit einer Größe von 4 Byte. Der uneingeschränkte Informationsaustauschwäre nicht möglich, sondern würde zu einem Merkmal der Sprache degradiert. Im gleichenMoment würde das ansonsten sehr stabile Framework wie ein Kartenhaus in sich zusam-menbrechen – eine fundamentale Stütze wäre ihm entzogen. Dieses Dilemma ist nichtunbekannt und beschert anderen Sprachen große Schwierigkeiten dabei, Funktionen derWinAPI-32 direkt aufzurufen. Ein Beispiel für diese Sprachen ist Visual Basic 6.0.

1.2.6 Das .NET Framework

Ein Framework ist ein Gerüst, mit dem Anwendungen entwickelt, kompiliert und ausge-führt werden. Es setzt sich aus verschiedenen Richtlinien und Komponenten zusammen.Sie haben in Abschnitt 1.2.4 mit der Common Language Specification (CLS) und inAbschnitt 1.2.5 mit dem Common Type System (CTS) bereits einen Teil des .NET Frame-works kennengelernt. Wir müssen aber dieses Anwendungsgerüst noch um zwei sehrwichtige Komponenten ergänzen:

� die Common Language Runtime (CLR)

� die .NET-Klassenbibliothek

Sie können in manchen Veröffentlichungen noch weitere Komponentenangaben finden,beispielsweise ADO.NET und ASP.NET. Es ist wohl mehr eine Sache der Definition, wo dieGrenzen eines Frameworks gesetzt werden, da sich dieser Begriff nicht mit einer klar


42


umrissenen Definition beschreiben lässt. Die .NET-Klassenbibliothek ihrerseits stellt einenOberbegriff dar, unter dem sich sowohl ADO.NET als auch ASP.NET eingliedern lassen.

1.2.7 Die Common Language Runtime (CLR)

Die Common Language Runtime (CLR) ist die Umgebung, in der die .NET-Anwendungenausgeführt werden – sie ist gewissermaßen die allen gemeinsame Laufzeitschicht. Der Stel-lenwert dieser Komponente kann nicht hoch genug eingestuft werden, denn mit ihrenFähigkeiten bildet die CLR den Kern von .NET.

Die CLR ist ein Verwalter – auf Englisch manager. Tatsächlich wird der Code, der in derCommon Language Runtime ausgeführt wird, auch als verwalteter Code bezeichnet – oderim Englischen als managed code. Umgekehrt kann mit Visual Studio 2010 auch unverwal-teter Code geschrieben werden. In unverwaltetem oder unmanaged code sind beispiels-weise Treiberprogramme geschrieben, die direkt auf die Hardware zugreifen und deshalbplattformabhängig sind.

Sie müssen sich die Common Language Runtime nicht als eine Datei vorstellen, der einebestimmte Aufgabe im .NET Framework zukommt, wenn verwalteter Code ausgeführtwird. Vielmehr beschreibt die CLR zahlreiche Dienste, die als Bindeglied zwischen dem ver-walteten IL-Code und der Hardware den Anforderungen des .NET Frameworks entspre-chen und diese sicherstellen. Zu diesen Diensten gehören:

� der Class Loader, um Klassen in die Laufzeitumgebung zu laden

� der Type Checker, der unzulässige Typkonvertierungen unterbindet

� der JITter, um den MSIL-Code zur Laufzeit in nativen Code zu übersetzen, der im Pro-zessor ausgeführt werden kann

� der Exception Manager, der die Ausnahmebehandlung unterstützt

� der Garbage Collector, der eine automatische Speicherbereinigung anstößt, wennObjekte nicht mehr benötigt werden

� der Code Manager, der die Ausführung des Codes verwaltet

� die Security Engine, die sicherstellt, dass der User über die Berechtigung verfügt, denangeforderten Code auszuführen

� die Debug Machine zum Debuggen der Anwendung

� der Thread Service zur Unterstützung multithreading-fähiger Anwendungen

� der COM Marshaller, der die Kommunikation mit COM-Komponenten (COM = Compo-nent Object Model) sicherstellt

Die Liste ist zwar lang, vermittelt aber einen Einblick in die verschiedenen unterschiedli-chen Aufgabenbereiche der Common Language Runtime.


43


1.2.8 Die .NET-Klassenbibliothek

Das .NET Framework, das inzwischen in der Version 4.0 vorliegt, ist ausnahmslos objekt-orientiert ausgerichtet. Für Entwickler, die sich bisher erfolgreich dem objektorientiertenKonzept widersetzt und beharrlich auf prozeduralen Code gesetzt haben (solche gibt eshäufiger, als Sie vielleicht vermuten), fängt die Zeit des Umdenkens an, denn an der Objek-torientierung führt unter .NET kein Weg mehr vorbei.

Alles im .NET Framework wird als Objekt betrachtet. Dazu zählen sogar die nativen Daten-typen der Common Language Specification wie der Integer. Die Folgen sind weitreichend,denn schon mit einer einfachen Deklaration wie

erzeugen wir ein Objekt mit allen sich daraus ergebenden Konsequenzen. Wir werden dar-auf in einem der folgenden Kapitel noch zu sprechen kommen.

Die .NET-Klassen stehen nicht zusammenhangslos im Raum, wie beispielsweise die Funkti-onen der WinAPI-32, sondern stehen ausnahmslos in einer engen Beziehung zueinander,der .NET-Klassenhierarchie. Eine Klassenhierarchie können Sie sich wie einen Familien-stammbaum vorstellen, in dem sich, ausgehend von einer Person, alle Nachkommen abbil-den lassen. Auch die .NET-Klassenhierarchie hat einen Ausgangspunkt, gewissermaßen dieWurzel der Hierarchie: Es ist die Klasse Object. Jede andere Klasse des .NET Frameworkskann darauf zurückgeführt werden und erbt daher deren Methoden. Außerdem kann esweitere Nachfolger geben, die sowohl die Charakteristika der Klasse Object erben als auchdie ihrer direkten Vorgängerklasse. Auf diese Weise bildet sich eine mehr oder wenigerausgeprägte Baumstruktur.

Für Visual C++-Programmierer ist eine Klassenhierarchie nichts Neues, sie arbeiten bereitsseit vielen Jahren mit den MFC (Microsoft Foundation Classes). Auch Java-Programmiererhaben sich an eine ähnliche Hierarchie gewöhnen müssen.

Eine Klassenhierarchie basiert auf einer Bibliothek, die strukturiert ihre Dienste zum Wohledes Programmierers bereitstellt und letztendlich die Programmierung vereinfacht. Umallerdings in den Genuss der Klassenbibliothek zu kommen, ist ein erhöhter Lernaufwanderforderlich. Wenn man aber aus dieser Phase heraus ist, kann man sehr schnell und ziel-orientiert Programme entwickeln. Die anfänglichen Investitionen zahlen sich also schnell aus.

Einen kurzen Überblick über den Inhalt der .NET-Klassenbibliothek zu geben, ist schwer,wenn nicht sogar vollkommen unmöglich, denn es handelt sich dabei um einige Tausendvordefinierte Typen. Wenn man sich jetzt vorstellt, dass in jeder Klasse mehr oder wenigerviele Methoden definiert sind, also Funktionen im prozeduralen Sinne, dann kommt mansehr schnell in Größenordnungen von einigen Zehntausend Methoden, die insgesamt vonden Klassen veröffentlicht werden. Alle zu kennen dürfte nicht nur an die Grenze derUnwahrscheinlichkeit stoßen, sondern diese sogar deutlich überschreiten. Außerdem kann

int iVar;


44


man davon ausgehen, dass im Laufe der Zeit immer weitere Klassen mit immer mehrzusätzlichen und verfeinerten Features in die Klassenhierarchie integriert werden – sowohldurch Microsoft selbst als auch durch Drittanbieter.

1.2.9 Das Konzept der Namespaces

Da jede Anwendung von Funktionalitäten lebt und der Zugriff auf die Klassenbibliothekzum täglichen Brot eines .NET-Entwicklers gehört, ist ein guter Überblick über die Klassenund insbesondere deren Handling im Programmcode sehr wichtig. Hier kommt uns einFeature entgegen, das die Arbeit deutlich erleichtert: die Namespaces. Ein Namespace isteine logische Organisationsstruktur, die völlig unabhängig von der Klassenhierarchie eineKlasse einem bestimmten thematischen Gebiet zuordnet. Damit wird das Auffinden einerKlasse, die bestimmte Leistungsmerkmale aufweist, deutlich einfacher. Das Konzept istnatürlich auch nicht ganz neu. Ob Java wieder Pate gestanden hat, wissen wir nicht. Aberin Java gibt es eine ähnliche Struktur, die als Package bezeichnet wird.

Dass das Auffinden einer bestimmten Klasse erleichert wird, ist nur ein Argument, was fürdie Namespaces spricht. Einem zweiten kommt eine ebenfalls nicht zu vernachlässigendeBedeutung zu: Jede Klasse ist durch einen Namen gekennzeichnet, der im Programmcodebenutzt wird, um daraus möglicherweise ein Objekt zu erzeugen und auf dessen Funktio-nalitäten zuzugreifen. Der Name muss natürlich eindeutig sein, schließlich können Sie auchnicht erwarten, dass ein Brief, der nur an Hans Fischer adressiert ist, tatsächlich den richti-gen Empfänger erreicht. Namespaces verhindern Kollisionen zwischen identischen Klas-senbezeichnern, sind also mit der vollständigen Adressierung eines Briefes vergleichbar.Nur innerhalb eines vorgegebenen Namespace muss ein Klassenname eindeutig sein.

Die Namespaces sind auch wieder in einer hierarchischen Struktur organisiert. Machen Sieaber nicht den Fehler, die Klassenhierarchie mit der Hierarchie der Namespaces zu ver-wechseln. Eine Klassenhierarchie wird durch die Definition der Klasse im Programmcodefestgelegt und hat Auswirkungen auf die Fähigkeiten einer Klasse, bestimmte Operationenausführen zu können, während die Zuordnung zu einem Namespace keine Konsequenzenfür die Fähigkeiten eines Objekts einer Klasse hat. Dass Klassen, die einem bestimmtenNamespace zugeordnet sind, auch innerhalb der Klassenhierarchie eng zusammenstehen,ist eine Tatsache, die aus den Zusammenhängen resultiert, ist aber kein Muss.

Wenn die Aussage zutrifft, dass Namespaces in einer baumartigen Struktur organisiert wer-den, muss es auch eine Wurzel geben. Diese heißt im .NET Framework System. DieserNamespace organisiert die fundamentalsten Klassen in einen Verbund. Weiter oben habeich erwähnt, dass sogar die nativen Datentypen wie der Integer auf Klassendefinitionenbasieren – im Namespace System ist diese Klasse neben vielen weiteren zu finden. (Falls Siedie Klasse jetzt aus Neugier suchen sollten – sie heißt nicht Integer, sondern Int32).


45

Assemblys 1.3

Unterhalb von System sind die anderen Namespaces angeordnet. Sie sind namentlich sogegliedert, dass man schon erahnen kann, über welche Fähigkeiten die einem Namespacezugeordneten Klassen verfügen. Damit Sie ein Gefühl hierfür bekommen, sind in Tabelle1.1 auszugsweise ein paar Namespaces angeführt.

Die Tabelle gibt kaum mehr als einen Bruchteil aller .NET-Namespaces wieder. Sie solltenallerdings erkennen, wie hilfreich diese Organisationsstruktur bei der Entwicklung einerAnwendung sein kann. Wenn Sie die Lösung zu einem Problem suchen, kanalisieren dieNamespaces Ihre Suche und tragen so zu einer effektiveren Entwicklung bei.

Wir können in diesem Buch natürlich nicht alle Namespaces, geschweige denn alle Klassendes .NET Frameworks behandeln. Ob das überhaupt jemals ein Buch zu leisten vermag,darf mehr als nur angezweifelt werden – zu umfangreich ist die Klassenbibliothek.

Sie sollten die wichtigsten Klassen und Namespaces kennen. Was zu den wichtigsten Kom-ponenten gezählt werden kann, ist naturgemäß subjektiv. Ich werde mich daher auf dieje-nigen konzentrieren, die praktisch in jeder Anwendung von Belang sind bzw. bei jedereigenen Klassendefinition in die Überlegung einbezogen werden müssen. In diesem Sinnewerde ich mich auf die fundamentalen Bibliotheken beschränken, einschließlich der Biblio-theken, die zur Entwicklung einer Windows-Anwendung notwendig sind.

1.3 Assemblys

Das Ergebnis der Kompilierung von .NET-Quellcode ist eine Assembly. Bei der Kompilie-rung wird, abhängig davon, welchen Projekttyp Sie gewählt haben, entweder eine EXE-oder eine DLL-Datei erzeugt. Wenn Sie nun in diesen Dateien ein Äquivalent zu den EXE-oder DLL-Dateien sehen, die Sie mit Visual Basic 6.0 oder C/C++ erzeugt haben, liegen Siefalsch – beide sind nicht miteinander vergleichbar.

Assemblys liegen im IL-Code vor. Zur Erinnerung: IL bzw. MSIL ist ein Format, das erst zurLaufzeit einer Anwendung vom JITter in nativen Code kompiliert wird. Eine Assembly

Namespace BeschreibungSystem.Collections Klassen, die Auflistungen beschreiben

System.Data Enthält die Klassen, um über ADO.NET auf Datenbanken zuzugreifen.

System.Drawing Klassen, die grafische Funktionalitäten bereitstellen

System.IO Klassen für Ein- und Ausgabeoperationen

System.Web Enthält Klassen, die im Zusammenhang mit dem Protokoll HTTP stehen.

System.Windows.Forms Enthält Klassen, um Windows-basierte Anwendungen zu entwickeln.

Tabelle 1.1 Auszug aus den Namespaces des .NET Frameworks


46


kann nicht nur eine, sondern auch mehrere Dateien enthalten – eine Assembly ist dahereher als eine Baugruppe innerhalb einer Anwendung zu verstehen.

Assemblys liegen, wie auch die herkömmlichen ausführbaren Dateien, im PE-Format (Por-table Executable) vor, einem Standardformat für Programmdateien unter Windows. DasÖffnen einer PE-Datei hat zur Folge, dass die Datei der Laufzeitumgebung übergeben undals Folge dessen ausgeführt wird. Daher wird Ihnen beim Starten auch kein Unterschiedzwischen einer Assembly und einer herkömmlichen Datei auffallen.

1.3.1 Die Metadaten

Assemblys weisen eine grundsätzlich neue, andersartige Struktur auf. Assemblys enthaltennämlich nicht nur IL-Code, sondern auch sogenannte Metadaten. Die Struktur einer kom-pilierten .NET-Komponente gliedert sich demnach in

� IL-Code und

� Metadaten.

Metadaten sind Daten, die eine Komponente beschreiben. Das hört sich im ersten Momentkompliziert an, ist aber ein ganz triviales Prinzip. Nehmen wir an, Sie hätten die Klasse Automit den Methoden Fahren, Bremsen und Hupen entwickelt. Wird diese Klasse kompiliert undder IL-Code erzeugt, lässt sich nicht mehr sagen, was der Binärcode enthält, und vor allem,wie er genutzt werden kann. Wenn eine andere Komponente auf die Idee kommt, denkompilierten Code eines Auto-Objekts zu nutzen, steht sie vor verschlossenen Türen.

Den Zusammenhang zwischen Metadaten und IL-Code können Sie sich wie das Verhältniszwischen Inhaltverzeichnis und Buchtext vorstellen: Man sucht unter einem Stichwort imInhaltverzeichnis nach einem bestimmten Begriff, findet eine Seitenzahl und kann zielge-richtet im Buch das gewünschte Thema nachlesen. Viel mehr machen die Metadaten eines.NET-Kompilats auch nicht, wenn auch die Funktionsweise naturgemäß etwas abstrakterist: Sie liefern Objektinformationen, beispielsweise die Eigenschaften eines Objekts und dieMethoden. Das geht sogar so weit, dass wir über die Metadaten in Erfahrung bringen, wiedie Methoden aufgerufen werden müssen.

Das grundsätzliche Prinzip der Aufteilung in Code und Metadaten ist nicht neu und wurdeauch schon unter COM angewandt – allerdings mit einem kleinen, aber doch sehr wesent-lichen Unterschied: COM trennt Code und Metadaten. Die Metadaten einer COM-Kompo-nente, die man auch als Typbibliothek bezeichnet, werden in die Registry eingetragen unddort ausgewertet. Das ist nicht gut, denn schließlich sollten Sie Ihren Personalausweisimmer bei sich tragen und ihn nicht irgendwo hinterlegen. Ebenso sollte auch der Codenicht von seinen Metadaten getrennt werden. COM ist dazu nicht in der Lage; erst inner-halb des .NET Frameworks wird dieser fundamentalen Forderung nach einer untrennbarenSelbstbeschreibung Rechnung getragen.


47

Die Entwicklungsumgebung 1.4

Die Metadaten versorgen die .NET-Laufzeitumgebung mit ausreichenden Informationenzum Erstellen von Objekten sowie zum Aufruf von Methoden und Eigenschaften. Sie bil-den eine klar definierte Schnittstelle und vereinheitlichen den Objektzugriff, was allen.NET-Entwicklern zugute kommt: Unabhängig von der Sprache – vorausgesetzt, sie ist.NET-konform – können problemlos Objekte verwendet werden, die von anderen Entwick-lern bereitgestellt werden. Dass die Objekte in einer beliebigen .NET-Sprache entwickeltsein können, braucht fast nicht erwähnt zu werden.

1.3.2 Das Manifest

Die Folgen der Trennung von Code und Selbstbeschreibung einer COM-Komponente sinduns wahrscheinlich allen bewusst: Durch die Installation einer neuen Anwendung werdenalte COM-Komponenten überschrieben, die für andere Anwendungen von existenziellerBedeutung sind. Die Auswirkungen können fatal sein: Eine Anwendung, die auf die Metho-den der überschriebenen Komponente zugreifen will, kann sich im schlimmsten Fall miteinem Laufzeitfehler sang- und klanglos verabschieden.

Mit Assemblierungen gehören diese Fehler definitiv der Vergangenheit an. Verantwortlichdafür sind Metadaten, die nicht die einzelnen Objekte, sondern die Assemblierung als Gan-zes beschreiben. Diese Daten werden als Manifest bezeichnet. Ein Manifest enthält die fol-genden Informationen:

� Name und Versionsnummer der Assembly

� Angaben über andere Assemblierungen, von denen die aktuelle Assembly abhängt

� die von der Assembly veröffentlichten Typen

� Sicherheitsrichtlinien, nach denen der Zugriff auf die Assembly festgelegt wird

Das Manifest befreit eine Assembly von der Notwendigkeit, sich in die Registrierung ein-tragen zu müssen, und die logischen Konsequenzen gehen sogar noch weiter: Währendsich COM-Komponenten erst durch eine Setup-Routine oder zusätzliche Tools in die Regis-trierungsdatenbank eintragen, können Sie mit den primitivsten Copy-Befehlen eine Assem-blierung in ein beliebiges Verzeichnis kopieren – Altbewährtes ist manchmal doch nicht soschlecht.

1.4 Die Entwicklungsumgebung

.NET-Anwendungen lassen sich notfalls auch mit einem Texteditor entwickeln, aber dasmacht natürlich keinen Spaß und ist mühevoll. Auf die Unterstützung, die eine moderneEntwicklungsumgebung bietet, werden Sie vermutlich nicht verzichten wollen. Microsoftbietet mit Visual Studio 2010 ein Entwicklungstool an, mit dem sich nahezu jede beliebigeAnwendung entwickeln lässt.


48


1.4.1 Editionen von Visual Studio 2010

Es gibt mehrere verschiedene Editionen, die spezifisch auf die unterschiedlichen Anforde-rungen bei der Anwendungsentwicklung zugeschnitten sind:

� Visual Studio 2010 Express Edition (für C# 2010, Visual Basic 2010 …): Im Wesentlichenbeschränken sich die Projektvorlagen auf Konsolen- und Windows-Anwendungen. Vieleandere Projektschablonen, beispielsweise Setup-Projekte oder benutzerdefinierte Steu-erelemente, werden nicht angeboten.

� Visual Studio 2010 Professional: Diese Edition ist für den professionellen Einsatz klei-nerer Entwicklerteams schon gut geeignet. Alle möglichen Projektvorlagen für die Ent-wicklung von Office-Projekten, Webanwendungen, SharePoint, SilverLight usw. sindenthalten.

� Visual Studio 2010 Premium: Diese Edition ist für Softwareentwickler und -tester geeig-net, die Enterprise Anwendungen entwickeln möchten. Die Erweiterungen im Vergleichzur Professional Edition ermöglichen eine durchgehende Qualitätssicherung.

� Visual Studio 2010 Ultimate: Diese höchstwertige Edition gibt auch großen Entwickler-teams Tools zu einer effizienten Lebenszyklusverwaltung an die Hand.

Sie können sich entscheiden, ob Sie eine der kostenlos erhältlichen Express-Editionen ein-setzen oder eine der speziell für Entwickler, Tester oder Softwarearchitekten zugeschnitte-nen Editionen.

1.4.2 Hard- und Softwareanforderungen

Es verwundert nicht, dass die Spirale der Anforderungen an die Hardware wieder einwenig weiter nach oben geschraubt worden ist.

� Betriebssysteme: Windows Server 2003 oder höher bis Windows XP, Windows Vistaund natürlich Windows7

� Architekturen: 32 Bit (x86) und 64 Bit (x64)

� Prozessor: 1,6-GHz-Pentium III+

� RAM: >= 1 GB (x86) bzw. 2 GB (x64)

� Festplatte: mindestens 3 GB Speicherplatzbedarf

� DVD-ROM-Laufwerk

� DirectX-fähige Grafikkarte, mindestens 1024 × 768 Pixel Auflösung

Setzen Sie die Express Edition ein, kommen Sie mit etwas geringeren Hardwareanforderun-gen aus. Allerdings macht das Arbeiten dann auch nicht mehr sehr viel Spaß.


49


1.4.3 Installation

Die Installation von Visual Studio 2010 verläuft in der Regel problemlos. Daher kann ichmir an dieser Stelle ausgiebige Kommentare sparen.

Nach dem Einlegen der DVD erscheint ein Dialog, in dem Sie aufgefordert werden, die zuinstallierenden Features auszuwählen. Fällt Ihre Wahl auf Vollständig, werden alle Fea-tures und gleichzeitig auch noch alle in Visual Studio verfügbaren Sprachen installiert.

Wenn Sie sich für eine benutzerdefinierte Installation entscheiden, müssen Sie darauf ach-ten, dass Sie alle Features installieren lassen, die Sie benötigen. Natürlich haben Sie späterzu jedem Zeitpunkt auch die Möglichkeit, fehlende Features nachzuinstallieren.

1.4.4 Entwicklungsumgebung von Visual Studio 2010

Hoffentlich haben Sie einen ausreichend großen Monitor mit hoher Auflösung. Visual Stu-dio 2010 bietet nämlich eine große Anzahl verschiedener informativer und hilfreicherFenster an. Zu den wichtigsten gehören:

� der Codeeditor

� der visuelle Editor

� der Projektmappen-Explorer

� das Eigenschaftsfenster

� die Toolbox

� die Fehlerliste

Hier alle Fenster aufzuführen, mit denen Sie während der Entwicklung einer .NET-Anwen-dung konfrontiert werden, ist nahezu unmöglich. Ich belasse es deshalb bei den genannten,die Sie, mit Ausnahme des Codeeditors, in Abbildung 1.3 wiederfinden. Dabei entsprichtdie Anordnung ungefähr der, die Sie nach der Installation vorfinden, wenn Sie eine WPF-Anwendung entwickeln wollen.

Nachfolgend möchte ich Ihnen kurz die wichtigsten Fenster von Visual Studio 2010 vorstellen.

Der Codeeditor

Die wichtigste Komponente der Entwicklungsumgebung ist natürlich das Fenster, in demwir unseren Programmcode schreiben. Abhängig von der gewählten Programmierspracheund der Projektvorlage wird automatisch Code generiert – gewissermaßen als Unterstüt-zung zum Einstieg in das Projekt. Sie können in den meisten Fällen diesen Code nach Belie-ben ändern – solange Sie wissen, welche mögliche Konsequenz das nach sich zieht.


50


Abbildung 1.3 Die Entwicklungsumgebung

Insgesamt gesehen ist die Handhabung des Codeeditors nicht nur sehr einfach, sondern sieunterstützt den Programmierer durch standardmäßig bereitgestellte Features. Zu diesenzählen unter anderem:

� automatischer Codeeinzug (Tabulatoreinzug). Die Breite des Einzugs lässt sich auchmanuell anders festlegen.

� automatische Generierung von Code, beispielsweise zur Kennzeichnung des Abschlusseseines Anweisungsblocks

� Ein- und Ausblendung der Anweisungsblöcke (Namespaces, Klassen, Prozeduren)

� IntelliSense-Unterstützung

� Darstellung jeder geöffneten Quellcodedatei auf einer eigenen Registerkarte

� eigene Vorder- und Hintergrundfarbe der verschiedenen Elemente

Darüber hinaus lassen sich viele Einstellungen auch noch benutzerdefiniert ändern undden eigenen Wünschen anpassen. Dazu öffnen Sie das Menü Extras und wählen hier Opti-

onen… (siehe Abbildung 1.4).


51


Abbildung 1.4 Der Dialog »Optionen«

Eine Anwendung kann sich aus mehreren Quellcodedateien zusammensetzen. Für jedegeöffnete Quellcodedatei wird im Codeeditor eine eigene Registerkarte bereitgestellt. Wirddie Anzahl der angezeigten Registerkarten zu groß, lässt sich jede einzelne über das spezifi-sche Kreuz rechts oben auf der Karte wieder schließen.

Quellcode kann sehr lang und damit insgesamt auch unübersichtlich werden. Mithilfe derZeichen »+« und »-« kann man Codeblöcke aufklappen und wieder schließen. Ist ein Blockgeschlossen, wird nur die erste Zeile angezeigt, die mit drei Punkten endet. Insgesamt trägtdiese Möglichkeit maßgeblich zu einer erhöhten Übersichtlichkeit des Programmcodes bei.

Per Vorgabe zeigt Visual Studio 2010 nur einen Codeeditor im Zentralbereich an. Nicht sel-ten werden Sie aber das Bedürfnis haben, gleichzeitig den Code von zwei Quellcodedateieneinsehen zu können, und werden nicht mehr zwischen den Registerkarten hin- und her-schalten wollen. Um das zu erreichen, müssen Sie im Editorbereich mit der rechten Maus-taste auf eine beliebige Registerkarte klicken und damit das Kontextmenü öffnen. Sie erhal-ten dann die Auswahl zwischen Neue horizontale Registerkartengruppe und Neue

vertikale Registerkartengruppe.


52


Der Projektmappen-Explorer

Jede .NET-Anwendung setzt sich aus mehreren Codekomponenten zusammen, und jede.NET-Anwendung kann ihrerseits ein Element einer Gruppe von Einzelprojekten sein, dieals Projektmappe bezeichnet wird. Der Projektmappen-Explorer zeigt die Struktur aller gela-denen Projekte an, indem er einerseits die einzelnen Quellcodedateien, die unter Visual C#die Dateiendung .cs haben, angibt und andererseits auch alle Abhängigkeiten eines Projekts(Verweise) mitteilt.

Für uns ist der Projektmappen-Explorer neben der Klassenansicht, die im folgendenAbschnitt beschrieben wird, diejenige Komponente der Entwicklungsumgebung, die unsbei der Navigation in unserem Anwendungscode maßgeblich unterstützt: ein Doppelklickauf eine der aufgelisteten Dateien öffnet im Codeeditor eine Registerkarte, die den Quell-code der Datei enthält.

Der Projektmappen-Explorer in Abbildung 1.5 enthält zwei Projekte: ConsoleApplication1

und ConsoleApplication2.

Abbildung 1.5 Der Projektmappen-Explorer

Das Eigenschaftsfenster

Ein Fenster, das sich von Anfang an in der Entwicklungsumgebung einnistet, ist das FensterEigenschaften. Seine ganze Stärke bei der Anwendungsentwicklung spielt dieses Fensterhauptsächlich dann aus, wenn grafische Oberflächen wie die einer Windows-Anwendungeine Rolle spielen. Man kann hier auf sehr einfache und übersichtliche Art und Weise dieEigenschaften von Schaltflächen, Forms etc. einstellen.

Abbildung 1.6 zeigt den Eigenschaften-Dialog, wenn im Projektmappen-Explorer einWPF-Window markiert ist. Sie könnten nun beispielsweise die Eigenschaft Background

ändern, um eine vom Standard abweichende Hintergrundfarbe des Fensters festzulegen.Ändern lassen sich natürlich nur die aktivierten Eigenschaften, die in schwarzer Schrift-farbe erscheinen. Eigenschaften in grauer Schriftfarbe sind schreibgeschützt.


53


Abbildung 1.6 Das Eigenschaftsfenster

Die Werkzeugsammlung (Toolbox)

Die Toolbox dient einzig und allein zur Entwicklung grafischer Oberflächen. Sie enthältdie Steuerelemente, die mit Visual Studio 2010 ausgeliefert werden, und ist registerkarten-ähnlich in mehrere Bereiche aufgeteilt. Welche Bereiche angeboten werden, hängt vomProjekttyp ab und variiert daher auch. Abbildung 1.7 zeigt die Werkzeugsammlung einesWPF-Anwendungsprojekts. Wenn Sie beispielsweise beabsichtigen, das Layout einer Web-form zu gestalten, werden in einer Registerkarte nur die Steuerelemente angeboten, die ineiner HTML-Seite platziert werden können.

Abbildung 1.7 Die Toolbox


54


Im zweiten Teil dieses Buches, in dem wir uns der WPF-Programmierung widmen, werdenSie lernen, die meisten der in der Toolbox angebotenen Steuerelemente einzusetzen.

Der Server-Explorer

Die meisten der bisher erwähnten Dialoge der Entwicklungsumgebung dienen der direktenEntwicklungsarbeit. Ich möchte Ihnen aber an dieser Stelle noch einen weiteren Dialog vor-stellen, der Sie bei der Anwendungserstellung zumindest indirekt unterstützt: Es ist derServer-Explorer. Sie können ihn zur Entwicklungsumgebung von Visual Studio 2010 hin-zufügen, indem Sie ihn im Menü Ansicht auswählen.

Abbildung 1.8 Der Server-Explorer

Die Leistungsfähigkeit des Server-Explorers ist wirklich beeindruckend, denn er integriertden Zugriff auf Dienste und Datenbanken in die Entwicklungsumgebung – und das nichtnur bezogen auf die lokale Maschine, sondern auch auf Systemressourcen, auf die über dasNetzwerk zugegriffen werden kann (entsprechende Berechtigungen natürlich vorausge-setzt). Ihnen bleibt es damit erspart, aus dem Visual Studio heraus immer wieder andereProgramme aufzurufen, um an benötigte Informationen zu gelangen.


55

2 Grundlagen der Sprache C#

Nach der Einführung im ersten Kapitel wenden wir uns nun der Programmierung zu, diesich – losgelöst von allen Einflüssen, die die Common Language Runtime (CLR) ausübt –grundsätzlich in zwei Kategorien einteilen lässt:

� fundamentale Sprachsyntax

� Objektorientierung

Ein tiefgehendes Verständnis beider Ansätze ist Voraussetzung, um eine auf .NET basie-rende Anwendung entwickeln zu können. Wenn Sie keine Programmierkenntnisse haben,auf die aufgebaut werden kann, ist das gleichzeitige Erlernen beider Teilbereiche schwierigund hindernisreich – ganz abgesehen von den Problemen, die der Umgang mit der komple-xen Entwicklungsumgebung aufwirft. Wir werden uns daher in diesem Kapitel zunächstder Syntax von C# zuwenden, ohne die Objektorientierung zu berücksichtigen – zumindestweitestgehend, denn ohne den einen oder anderen flüchtigen Blick in die .NET-Klassen-bibliothek werden wir nicht auskommen.

2.1 Konsolenanwendungen

2.1.1 Allgemeine Anmerkungen

Um den Einstieg möglichst einfach zu halten, insbesondere für diejenigen Leser, die sichzum ersten Mal mit der Programmierung beschäftigen, drehen wir das Rad der EDV-Geschichte zurück und werden unsere Programmbeispiele zunächst nur als Konsolenan-wendungen entwickeln. Konsolenanwendungen werden im DOS-Fenster ausgeführt, dashäufig auch als Eingabeaufforderung bezeichnet wird. Sie sind einerseits überschaubarerals Anwendungen mit visualisierter Benutzeroberfläche, andererseits kann man sich mitder Entwicklungsumgebung schrittweise vertraut machen, ohne durch die vielen Dialog-fenster und den automatisch generierten Code sofort den Überblick zu verlieren.

Das Ziel dieses Kapitels ist es, Ihnen die fundamentale Sprachsyntax von C# näherzubrin-gen. Erst danach soll der objektorientierte Ansatz in den Kapiteln 3 bis 5 eingehend erläu-tert werden.


56

Grundlagen der Sprache C#2

2.1.2 Ein erstes Konsolenprogramm

Nach dem erstmaligen Öffnen eines Projekts vom Typ Konsolenanwendung wird imCodeeditor eine Codestruktur angezeigt, die der gewählten Vorlage entspricht. Sie siehtwie folgt aus:

Dieser Coderumpf besitzt noch keinerlei Funktionalität, die wir zur Laufzeit des Pro-gramms beobachten könnten. Er gibt uns nur den minimalen Rahmen vor, in den wir unse-ren Code hineinschreiben müssen.

Eine Konsolenanwendung öffnet ein Kommandofenster und schreibt Informationen in dieses.Das wollen wir nun in unserer ersten kleinen Anwendung realisieren und uns die Zeichen-folge »C# macht Spaß.« ausgeben lassen. Dazu ergänzen Sie den Programmcode folgender-maßen:

Wir haben zwei Zeilen Programmcode eingefügt. Die erste dient dazu, eine Ausgabe in dieKonsole zu schreiben. Mit der genauen Syntax dieser Anweisung werden wir uns späternoch auseinandersetzen. Würden wir auf die zweite Anweisung verzichten, träte ein häss-liches Phänomen auf: Das Konsolenfenster würde sich zwar öffnen, aber auch sofort wiederschließen. Wir könnten kaum die Ausgabe der Zeichenfolge lesen. Mit

using System;using System.Collections.Generic;using System.Linq;using System.Text;

Dnamespace ConsoleApplication1{ class Program { static void Main(string[] args) { } }D}

...static void Main(string[] args){ Console.WriteLine("C# macht Spaß."); Console.ReadLine();}...

Console.ReadLine();


57

Konsolenanwendungen 2.1

stellen wir sicher, dass die Konsole so lange geöffnet bleibt, bis der Anwender sie mit der(¢)-Taste schließt. Nahezu gleichwertig können Sie auch

schreiben. Der Unterschied ist der, dass ReadKey auf jede Taste reagiert.

Nun wollen wir uns vom Erfolg unserer Aktion natürlich auch überzeugen und das Lauf-zeitverhalten testen. Dazu gibt es mehrere Möglichkeiten:

� Sie klicken in der Symbolleiste auf die Schaltfläche Starten.

� Sie wählen im Menü Debuggen das Element Debuggen starten.

� Sie drücken die (F5)-Taste auf der Tastatur.

Wenn jetzt die Ausführung gestartet wird, sollte das Konsolenfenster geöffnet werden undwunschgemäß die Zeichenfolge

anzeigen. Geschlossen wird die Konsole durch Drücken der (¢)-Taste. Daraufhin wird dieLaufzeit beendet, und wir gelangen wieder in die Entwicklungsumgebung zurück.

Nehmen wir an, Sie hätten einen kleinen Fehler gemacht und vergessen, hinter der Anwei-sung

ein Semikolon anzugeben. Wie Sie gleich genauer erfahren werden, muss jede C#-Anwei-sung mit einem Semikolon abgeschlossen werden. Nun würde ein syntaktischer Fehler vor-liegen, den unser C#-Compiler natürlich nicht akzeptieren kann. Sie bekommen eine Mel-dung zu dem aufgetretenen Fehler in einem separaten Fenster angezeigt, in dersogenannten Fehlerliste (siehe Abbildung 2.1).

Console.ReadKey();

Hinweis

Sie können das Projekt aus der Entwicklungsumgebung auch starten, wenn Sie im Menü Debuggen

das Untermenü Starten ohne Debuggen wählen. Das hat den Vorteil, dass Sie auf die Anweisung

Console.ReadLine();

verzichten können. Dafür wird an der Konsole automatisch die Aufforderung Drücken Sie einebeliebige Taste ... angezeigt.

C# macht Spaß.

Console.ReadLine()


58


Abbildung 2.1 Die Liste mit den Fehlermeldungen

In unserem Beispiel ist nur ein Fehler aufgetreten. Wären es mehrere, würden diese derReihe nach untereinander erscheinen. Die Beschreibung des Fehlers ist in den meisten Fällenrecht informativ – zumindest dann, wenn man etwas Erfahrung im Umgang mit .NET hat.Da sich .NET-Anwendungen in der Regel aus mehreren Dateien zusammensetzen, wirdzudem die betroffene Datei genannt und die Zeile, in der der Fehler aufgetreten ist. SolltenSie im Codefenster keine Zeilennummern sehen, können Sie die Anzeige über das MenüExtras � Optionen einstellen. Markieren Sie dazu, wie in Abbildung 2.2 gezeigt, in der Listeden Eintrag Text-Editor � Alle Sprachen, und setzen Sie das Häkchen vor Zeilennummern.

Abbildung 2.2 So setzen Sie die Option zum Anzeigen der Zeilennummern im Codeeditor.


59

Grundlagen der C#-Syntax 2.2

Wenn Sie auf einen Listeneintrag im Fenster Fehlerliste doppelklicken, springt der Einga-becursor in die Codezeile, die den Fehler verursacht hat. An dieser Stelle sei schon ange-merkt, dass mehrere Fehlereinträge nicht zwangsläufig verschiedene Fehlerursachen habenmüssen. Häufig kommt es vor, dass ein einzelner Fehler zu Folgefehlern bei der Kompilie-rung führt, die ihrerseits alle in der Liste erscheinen.

2.2 Grundlagen der C#-Syntax

2.2.1 Kennzeichnen, dass eine Anweisung abgeschlossen ist

C#-Programme setzen sich, wie auch in anderen Sprachen entwickelte Programme, aus vie-len Anweisungen zusammen, die der Reihe nach ausgeführt werden. Anweisungen legenfest, was das Programm zu tun hat und auf welche Art und Weise es das tut. Sie haben imvorherigen Abschnitt bereits Ihr erstes Programm geschrieben, das aus zwei Anweisungenbestand:

Jede Anweisung verlangt nach einer Kennzeichnung, die das Ende der Anweisung bekanntgibt. Dazu wird in C# das Semikolon eingesetzt. Wenn Sie das Semikolon vergessen, erhaltenSie einen Kompilierfehler. Im vorhergehenden Abschnitt hatten wir das sogar provoziert.

Auch wenn es sinnlos ist, so dürfen Sie durchaus mehrere Semikolons hintereinander-schreiben, ohne dass explizit eine Anweisung dazwischen stehen muss:

Weil durch ein Semikolon eine Anweisung eindeutig abgeschlossen wird, dürfen auchmehrere Anweisungen in eine Zeile geschrieben werden. Im Umkehrschluss kann eineAnweisung auch problemlos auf mehrere Zeilen verteilt werden, ohne dass sich der Com-piler daran stört.

Bei der Gestaltung des Programmcodes lässt C# Ihnen sehr viele Freiheiten. Leerzeichen,Tabulatoren und Zeilenumbrüche können nach Belieben eingestreut werden, ohne dasssich das auf die Kompilierung des Quellcodes oder die Ausführung des Programms aus-wirkt. Daher dürfte der Code unseres Beispiels auch wie folgt aussehen:

Console.WriteLine("C# macht Spaß.");Console.ReadLine();

;;;;

Console. WriteLine("C# macht Spaß.") ; Console. ReadLine () ;


60


Dass eine Streuung wie die gezeigte die gute Lesbarkeit des Codes enorm beeinträchtigt,steht außer Frage. Aber C# führt diesen Code dennoch genauso aus wie zuvor. Andererseitskann man insbesondere mit den Tabulatoren über Einrückungen zu einer guten Lesbarkeitdes Programmcodes beitragen. Vergleichen Sie dazu wieder das Beispiel von oben. Anwei-sungen, die innerhalb eines Anweisungsblocks in geschweiften Klammern stehen, werdenüblicherweise rechts eingerückt. Wenn Sie sich an den Beispielen in diesem Buch orientie-ren, werden Sie sehr schnell ein Gefühl dafür bekommen, wie Sie mit Einrückungen nichtnur optisch ansprechenden, sondern auch leichter lesbaren Code schreiben. Feste Regelngibt es dazu allerdings nicht, es sind stillschweigende Konventionen.

2.2.2 Anweisungs- und Gliederungsblöcke

C#-Programmcode ist blockorientiert, d.h., dass C#-Anweisungen grundsätzlich immerinnerhalb eines Paars geschweifter Klammern geschrieben werden. Jeder Block kann einebeliebige Anzahl von Anweisungen enthalten – oder auch keine. Somit hat ein Anweisungs-block allgemein die folgende Form:

Anweisungsblöcke lassen sich beliebig ineinander verschachteln. Dabei beschreibt jederAnweisungsblock eine ihm eigene Ebene, zum Beispiel:

Beachten Sie, wie Einzüge hier dazu benutzt werden, optisch die Zugehörigkeit einer odermehrerer Anweisungen zu einem bestimmten Block aufzuzeigen. Die Anweisungen 2 und3 sind zu einem Block zusammengefasst, der sich innerhalb eines äußeren Blocks befindet.Zum äußeren Anweisungsblock gehören Anweisung 1 und Anweisung 4 sowie natürlichauch der komplette innere Anweisungsblock.

Außer zur Blockbildung von Anweisungen werden die geschweiften Klammern dazubenutzt, Definitionsbereiche zu bilden. Beispielsweise lassen sich mehrere Klassendefiniti-onen einem bestimmten Namespace zuordnen. Um dieses Thema zu erörtern, ist es aller-dings noch zu früh.

{ Anweisung 1; Anweisung 2; ...}

{ Anweisung 1; { Anweisung 2; Anweisung 3; } Anweisung 4;}


61


2.2.3 Kommentare

Sie sollten nicht mit Kommentaren geizen. Kommentare helfen, den Programmcode derAnwendung besser zu verstehen. Sie tun nicht nur den Entwicklern damit einen Gefallen,die sich mit Ihrem Code auseinandersetzen müssen, sondern auch sich selbst. Wenn Siebereits Programmiererfahrung haben, werden Sie wissen, wie schwierig es ist, nach demdreiwöchigen Mallorca-Urlaub wieder den eigenen Code zu verstehen. Was beschreibtdiese Variable, welche Funktionalität steckt hinter jener Methode? Ersparen Sie sich undanderen die unnötige und zeitraubende Suche nach den Antworten.

C# bietet zwei Möglichkeiten, um Kommentare, die vom Compiler während des Kompilier-vorgangs ignoriert werden, in den Quellcode einzustreuen. Die am häufigsten benutzteVariante ist die Einleitung eines Kommentars mit zwei Schrägstrichen //:

Ein //-Kommentar gilt für den Rest der gesamten Codezeile, kann jedes beliebige Zeichenenthalten und darf auch nach einer abgeschlossenen Anweisung stehen.

Sollen viele zusammenhängende Zeilen zu einem längeren Kommentar zusammengefasstwerden, bietet sich die zweite Alternative an, bei der ein Kommentar mit /* eingeleitet undmit */ abgeschlossen wird. Alle Zeichen, die sich dazwischen befinden, sind Bestandteil desKommentars.

Tatsächlich kann man sogar mitten in einer Anweisung diesen Kommentar schreiben, ohnedass der C#-Compiler das als Fehler ansieht:

Die Entwicklungsumgebung des Visual Studio 2010 bietet eine recht interessante und ein-fache Alternative, um insbesondere größere Blöcke auf einmal auszukommentieren. Siemüssen dazu nur sicherstellen, dass in der Entwicklungsumgebung die Symbolleiste Text-

Editor angezeigt wird. Dazu brauchen Sie nur mit der rechten Maustaste das Kontextmenüeiner der aktuellen Symbolleisten zu öffnen. Im Kontextmenü finden Sie alle Symbolleistender Entwicklungsumgebung aufgelistet. Da die Anzahl als nicht gering bezeichnet werdenkann, lassen sich die einzelnen Symbolleisten nach Bedarf ein- oder ausblenden.

// dies ist ein Kommentar

Console.WriteLine("..."); //Konsolenausgabe

/* Console.WriteLine("..."); Console.ReadLine();*/

Console.WriteLine /* Kommentar */("...");

Hinweis

Eine weitere Variante eines Kommentars in C# ist durch drei aufeinanderfolgende Schrägstriche ///gekennzeichnet. Codezeilen, die so auskommentiert sind, werden zwar ebenfalls vom C#-Compilerignoriert, ihnen kommt aber eine weiterreichende Bedeutung zu: Sie dienen zum Erstellen einerXML-basierten Dokumentation.


62


Die Symbolleiste Text-Editor enthält zwei Schaltflächen, um markierte Codeblöcke auszu-kommentieren oder eine Kommentierung wieder aufzuheben (siehe Abbildung 2.3).

Abbildung 2.3 Kommentare mithilfe der Symbolleiste

In der Entwicklungsumgebung erscheinen Kommentare in einer anderen Schriftfarbe alsder Programmcode selbst. Sie können die Farbgebung ganz individuell festlegen, wenn Sieden Dialog Optionen öffnen und im Knoten Umgebung den Punkt Schriftarten und Far-

ben auswählen. Rechts neben dem Listenfeld bieten sich anschließend mehrere Optionen,um die Darstellung des Programmcodes im Codefenster zu beeinflussen.

2.2.4 Groß- und Kleinschreibung

C# gehört zu der Gruppe von Programmiersprachen, die zwischen Groß- und Kleinschrei-bung unterscheiden. Falls Sie die Anweisung zur Konsolenausgabe mit

codieren, werden Sie bei der Kompilierung mit einer Fehlermeldung konfrontiert. Korrektmüsste es lauten:

Es ist Ansichtssache, ob man diese kleinkarierte Interpretation von C# für positiv odernegativ hält, denn beispielsweise macht VB.NET hier keinen Unterschied. Positiv ist jeden-falls zu bemerken, dass zwei gleichlautende Bezeichner, die sich nur durch Groß- undKleinschreibung unterscheiden, in C# auch für zwei unterschiedliche Programmelementestehen. Manchmal erleichtert C# die Festlegung eines Bezeichners für eine Variable undkann außerdem zur eindeutigen Zuordnung zweier miteinander in einer logischen Bezie-hung stehenden Variablen dienen.

Anmerkung

In diesem Buch werden alle Kommentare grau hinterlegt, um auf einen Blick deutlich zwischenCode und Kommentar unterscheiden zu können. Außerdem bezieht sich jeder Kommentar auf diefolgende Codezeile.

Console.Writeline("...");

Console.WriteLine("...");

Kommentiert die ausgewählten Textzeilen aus.

Hebt die Auskommentierung der ausgewählten Textzeilen auf.


63


2.2.5 Struktur einer Konsolenanwendung

Sehen wir uns noch einmal den Code an, den uns die Entwicklungsumgebung nach demÖffnen eines neuen Projekts vom Typ Konsolenanwendung anbietet:

Wir erkennen nun eindeutig mehrere ineinandergeschachtelte Blockstrukturen. Der äußereBlock definiert einen Namespace mit dem Namen ConsoleApplication1. Namespaces die-nen dazu, die Typen der .NET-Klassenbibliothek funktionell orientiert zu organisieren undinnerhalb eines Namespace die namentliche Eindeutigkeit zu gewährleisten.

Im Namespace eingebettet ist eine Klassendefinition, die einen eigenen Anweisungsblockbeschreibt:

C# ist eine 100%ig objektorientierte Sprache. Das bedeutet, dass grundsätzlich immer eineKlassendefinition vorliegen muss, um mit einem Objekt arbeiten zu können. Eine Klassebeschreibt einen Typ, und in unserem Fall heißt dieser Typ Program. Der BezeichnerProgram ist nur als Vorschlag der Entwicklungsumgebung anzusehen und darf im Rahmender Eindeutigkeit innerhalb des aktuellen Namespace (hier also ConsoleApplication1)

using System;using System.Collections.Generic;using System.Text;

namespace ConsoleApplication1{ class Program { static void Main(string[] args) { } }}

Anmerkung

Der Bezeichner eines Namespace, in unserem Beispiel ConsoleApplication1, wird beim Starteines neuen Projekts automatisch vergeben und entspricht dem Projektnamen. Sie können dieseVorgabe ändern, solange der frei gewählte Name seinerseits innerhalb seines Definitionsbereichseindeutig ist.

namespace ConsoleApplication1 { class Program { }}


64


nahezu frei vergeben werden. Über die Einschränkungen werden wir uns später nochGedanken machen müssen.

Wie Sie sehen, kommen wir schon an dieser Stelle zum ersten Mal mit Klassen in Kontakt,die uns bei allen auf dem .NET Framework basierenden Anwendungen begleiten. Was eineKlasse selbst darstellt und wie man sie einsetzt, wird einen wesentlichen Teil dieses Buchesausmachen. Wir wollen es hier aber zunächst bei dieser kurzen Erwähnung belassen, dennin diesem Kapitel werden Sie die grundlegende Syntax von C# lernen, ohne die Gesichts-punkte des objektorientierten Paradigmas berücksichtigen zu müssen.

Interessanter ist für uns momentan die dritte Blockebene, die innerhalb der Klasse Programvordefiniert ist, nämlich die durch Main beschriebene:

Bei Main handelt es sich um eine Prozedur, die für uns von herausragender Bedeutung ist:Wenn wir die Laufzeitumgebung einer Anwendung starten, werden zuerst Main und diedarin enthaltenen Anweisungen ausgeführt. Sie dürfen den Namen dieser Prozedur nichtändern und müssen natürlich auch die Großschreibweise berücksichtigen, denn beim Startder Laufzeitumgebung wird immer nach Main gesucht und nicht nach main oder nach start.

Weiter oben wurde gesagt, dass Anweisungen immer innerhalb eines Blocks aus geschweif-ten Klammern codiert werden. Wir können diese Aussage nun präzisieren: Anweisungenwerden grundsätzlich immer innerhalb des Anweisungsblocks einer Prozedur implemen-tiert. Wir haben das schon bei unserem ersten Beispiel gesehen:

An dieser Stelle wollen wir uns schon mit einem weiteren Begriff anfreunden, der Ihnen indiesem Kapitel immer wieder begegnen wird, dessen Bedeutung allerdings erst in Kapitel 3exakt beschrieben wird: Es handelt sich hierbei um den Begriff der Methode. In Program-miersprachen, die nicht auf Klassen und Objekten basieren, wird eine Prozedur als einezusammengehörige Anweisungsfolge definiert, die zur Laufzeit der Reihe nach abgearbeitetwird – nicht anders verhält sich Main. Tatsächlich ist die Verwandtschaft zwischen einerProzedur und einer Methode auch nicht von der Hand zu weisen. Weil Main jedoch inner-halb einer Klasse definiert ist, in unserem Fall in Program, dürfen wir statt von der Main-Pro-zedur auch von der Main-Methode sprechen.

static void Main(string[] args) { }

static void Main(string[] args) { Console.WriteLine("C# macht Spaß."); Console.ReadLine();}


65

Variablen und Datentypen 2.3

Sehen wir uns nun noch kurz die Definition der Main-Methode an. Die beiden dem Bezeich-ner vorausgehenden Schlüsselwörter static und void sind zwingend notwendig. SolltenSie bereits mit C++ oder Java Anwendungen entwickelt haben, werden Sie die Bedeutungdieser beiden Modifizierer kennen: Mit static werden Methoden bezeichnet, die beimAufruf kein konkretes Objekt voraussetzen, und void beschreibt eine Methode ohne Rück-gabewert. Im Moment soll diese Information genügen, denn eine genauere Kenntnis hättederzeit keine Auswirkungen auf die ersten Schritte in die Welt der C#-Programme.

Sie starten ein Konsolenprogramm, indem Sie den Namen der Anwendungsdatei mit derDateierweiterung .EXE an der Konsole eingeben (die anderen sich bietenden Möglichkeitenüber den Explorer bzw. über Start � Ausführen seien hier nur am Rande erwähnt). Manch-mal ist es notwendig, dem Programm beim Start Anfangswerte mitzuteilen, die vom laufen-den Programm zur Ausführung und Weiterverarbeitung benötigt werden. Angenommen,Sie wollen einer Konsolenanwendung mit dem Dateinamen MyApplication.exe die dreiZahlen 10, 14 und 17 übergeben, dann sähe der Aufruf an der Eingabeaufforderung wiefolgt aus:

Diese drei Zahlen werden von der Parameterliste, die hinter dem Bezeichner Main in run-den Klammern angegeben ist, in Empfang genommen:

Wie die übergebenen Daten mittels Programmcode verarbeitet werden, erkläre ich später.Die Angabe der Parameterliste ist optional. Benötigt ein Programm bei seinem Aufruf keineDaten, kann die Parameterliste leer bleiben. Die Angabe der runden Klammern ist aberunbedingt erforderlich:

2.3 Variablen und Datentypen

Dateninformationen bilden die Grundlage der Datenverarbeitung und hauchen einem Pro-gramm Leben ein: Daten können anwendungsspezifisch sein, den Zustand von Objektenbeschreiben, Informationen aus Datenbanken repräsentieren oder auch nur eine Netzwerk-adresse. Daten bilden also gemeinhin die Basis der Gesamtfunktionalität einer Anwendung.

2.3.1 Variablendeklaration

Praktisch jedes Programm benötigt Daten, um bestimmte Aufgaben zu erfüllen. Daten wer-den in Variablen vorgehalten. Dabei steht eine Variable für eine Adresse im Hauptspeicherdes Rechners. Ausgehend von dieser Adresse wird eine bestimmte Anzahl von Bytes reser-

MyApplication.exe 10 14 17

Main(string[] args) ...

static void Main() ...


66


viert – entsprechend dem Typ des Werts. Das, was eine Variable repräsentiert, kann vielfäl-tiger Art sein: eine einfache Zahl, eine große Fließkommazahl, ein einzelnes Zeichen, eineZeichenkette, eine Datums- oder Zeitangabe, aber auch die Referenz auf die Startadresseeines Objekts.

Der Variablenname, auch Bezeichner genannt, dient dazu, die Speicheradresse im Programm-code mit einem Namen anzusprechen, der sich einfach merken lässt. Er ist also vom Wesenher nichts anderes als ein Synonym oder Platzhalter eines bestimmten Speicherorts.

Variablen müssen deklariert werden. Unter einer Variablendeklaration wird die Bekannt-gabe des Namens der Variablen sowie des von ihr repräsentierten Datentyps verstanden.Die Deklaration muss vor der ersten Wertzuweisung an die Variable erfolgen. Dabei wirdzuerst der Datentyp angegeben, dahinter der Variablenname. Abgeschlossen wird dieDeklaration mit einem Semikolon. Damit lautet die allgemeine Syntax:

Beispielsweise könnte eine zulässige Deklaration wie folgt aussehen:

Damit wird dem Compiler mitgeteilt, dass der Bezeichner value für einen Wert steht, dervom Typ einer Ganzzahl, genauer gesagt vom Typ int (Integer) ist. Mit

wird dieser Variablen ein gültiger Wert zugewiesen. Man spricht dann auch von der Initi-alisierung der Variablen.

Wenn Sie versuchen, auf eine nicht deklarierte Variable zuzugreifen, wird der C#-Compilereinen Fehler melden. Ebenso falsch ist es, den Inhalt einer nicht initialisierten Variablenauswerten zu wollen.

Deklaration und Initialisierung können auch in einer einzigen Anweisung erfolgen:

Auf diese Weise vermeiden Sie eine nicht initialisierte Variable.

Müssen Sie mehrere Variablen gleichen Typs deklarieren, können Sie die Bezeichner,getrennt durch ein Komma, hintereinander angeben:

Datentyp Bezeichner;

int value;

value = 1000;

Hinweis

Variablen, die innerhalb einer Prozedur (Methode) wie beispielsweise Main deklariert sind, geltennoch nicht als initialisiert. Sie enthalten keinen gültigen Wert, auch nicht 0. Daher kann ihr Inhaltauch nicht ausgewertet werden.

int value = 0;


67


Sie können dann auch eine oder mehrere Variablen sofort initialisieren:

2.3.2 Variablenbezeichner

Ein Variablenname kann nahezu beliebig festgelegt werden, unterliegt aber besonderenReglementierungen:

� Ein Bezeichner darf sich nur aus alphanumerischen Zeichen und dem Unterstrich zusam-mensetzen. Leerzeichen und andere Sonderzeichen wie beispielsweise #, §, $ usw. sindnicht zugelassen.

� Ein Bezeichner muss mit einem Buchstaben oder dem Unterstrich anfangen.

� Ein einzelner Unterstrich als Variablenname ist nicht zulässig.

� Der Bezeichner muss eindeutig sein. Er darf nicht gleichlautend mit einem Schlüssel-wort, einer Prozedur, einer Klasse oder einem Objektnamen sein.

Zur Verdeutlichung dieser Regeln folgen hier einige Beispiele für korrekte und falsche Vari-ablenbezeichner:

Noch ein Hinweis zur Namensvergabe: Wählen Sie grundsätzlich beschreibende Namen,damit Ihr Code später besser lesbar wird. Einfache Bezeichner wie x oder y usw. sind wenigaussagekräftig. Besser wäre eine Wahl wie farbe, gehalt, vorname usw. Nur den Zählerva-riablen von Schleifen werden meistens Kurznamen gegeben.

int a, b, c;

int a, b = 9, c = 12;

// korrekte Variablendeklarationenlong lngMyVar;byte bResult_12;int intCarColor;// fehlerhafte Variablendeklarationenint 34M;string strMessage Text;long longSalary%Tom;

Hinweis

Die hier exemplarisch angegebenen Variablenbezeichner fangen alle mit einem Kleinbuchstabenan. Folgen Sie der allgemeinen .NET-Namenskonvention, sollten Sie bei der Wahl der Groß- undKleinschreibung des ersten Buchstabens die Lokalität der Variablen im Code berücksichtigen. Vari-ablen innerhalb eines Anweisungsblocks (lokale Variablen) mit einem Kleinbuchstaben zu begin-nen, entspricht der Konvention. Alle anderen Fälle jetzt aufzuführen, würde momentan den Rah-men sprengen. Deshalb wird auf eine weitergehende Erläuterung an dieser Stelle verzichtet.


68


2.3.3 Zugriff auf eine Variable

Wir wollen uns jetzt noch ansehen, wie wir uns den Inhalt einer Variablen an der Konsoleausgeben lassen können. Wir deklarieren dazu eine Variable vom Typ long und weisen ihreinen Wert zu, den wir danach an der Konsole ausgeben lassen.

Deklaration und Initialisierung bieten keine Neuigkeiten, im Gegensatz zu der Anweisung,die eine Ausgabe an der Konsole bewirkt:

Die Ausgabe im Befehlsfenster wird wie folgt lauten:

Sie haben bereits gesehen, dass mit Console.WriteLine eine einfache Konsolenausgabecodiert wird. WriteLine ist eine Methode, die in der Klasse Console definiert ist. Jetzt fehltnoch die genaue Erklärung der verwendeten Syntax.

2.3.4 Ein- und Ausgabemethoden der Klasse »Console«

Es bleibt uns nichts anderes übrig, als an dieser Stelle schon einen kleinen Ausflug in dieWelt der Klassen und Objekte zu unternehmen. Obwohl wir uns erst ab Kapitel 3 intensivmit diesen Themen auseinandersetzen werden, kommen wir in diesem Kapitel nicht daranvorbei, weil wir immer wieder mit den Methoden verschiedener Klassen arbeiten werden.Es handelt sich dabei meist um Methoden, um an der Eingabekonsole Ein- und Ausgabe-operationen durchzuführen: Write und WriteLine sowie Read und ReadLine.

Die Methoden »WriteLine«, »ReadLine«, »Write« und »Read«

Die Klasse Console ermöglicht es, über die beiden Methoden Write und WriteLine auf dieStandardausgabeschnittstelle zuzugreifen. Der Begriff »Ausgabeschnittstelle« mag im erstenMoment ein wenig verwirren, aber tatsächlich wird darunter die Anzeige an der Konsoleverstanden.

WriteLine und Write unterscheiden sich dahingehend, dass die erstgenannte Methode demAusgabestring automatisch einen Zeilenumbruch anhängt und den Cursor in die folgendeAusgabezeile setzt. Nach dem Aufruf der Methode Write verbleibt der Eingabecursor wei-terhin in der aktuellen Ausgabezeile.

static void Main(string[] args){ long value = 4711; Console.WriteLine("value = {0}", value); Console.ReadLine();}

Console.WriteLine("value = {0}",value);

value = 4711


69


Ein Zeilenumbruch ist die Kombination aus Wagenrücklauf und Zeilenvorschub und ent-spricht den ASCII-Werten 13 und 10. Auf der Tastatur erzeugen Sie einen Zeilenumbruchdurch Drücken der mit (¢) bzw. (Return) beschrifteten Eingabetaste.

Beide Methoden sind auf vielfältige Weise einsetzbar. Denn unabhängig vom zugrunde lie-genden Datentyp werden beide Ausgabemethoden ohne zu murren die gewünschten Datenim Konsolenfenster anzeigen.

Wollen wir die Methode eines Objekts aufrufen, geben wir den Objektnamen an und vondiesem durch einen Punkt getrennt – dies ist die sogenannte Punktnotation – den Namender Methode. Hinter dem Methodennamen schließt sich ein Klammerpaar an. Allgemeinlautet die Syntax also:

Sie können sich mit dieser Syntax durchaus schon vertraut machen, denn sie wird Ihnen absofort überall begegnen, da sie in objektorientiertem Programmcode elementar ist.

Das runde Klammerpaar hinter der Read- bzw. ReadLine-Methode bleibt immer leer, undbei den Methoden Write und WriteLine werden innerhalb der Klammern die auszugeben-den Daten einschließlich ihres Ausgabeformats beschrieben. Allerdings dürfen auch beiden beiden letztgenannten Methoden die Klammern leer bleiben.

Im einfachsten Fall kann einer der beiden Ausgabemethoden eine Zeichenfolge in Anfüh-rungsstrichen übergeben werden:

Formatausdrücke in den Methoden »Write« und »WriteLine«

Damit sind die Möglichkeiten der Write/WriteLine-Methoden noch lange nicht erschöpft.Die flexiblen Formatierungsmöglichkeiten erlauben die Ausgabe von Daten an beliebigenPositionen innerhalb der Ausgabezeichenfolge. Dazu dient ein Platzhalter, der auch als For-matausdruck bezeichnet wird. Dieser ist an den geschweiften Klammern zu erkennen undenthält zumindest eine Zahl. Hinter der auszugebenden Zeichenfolge werden, durch einKomma getrennt, die Informationen übergeben, was anstelle des Formatausdrucks auszu-geben ist. Sehen wir uns dazu ein Beispiel an:

Hier sind die beiden Variablen text1 und text2 vom Typ string deklariert, die mit einerin Anführungsstrichen gesetzten Zeichenfolge initialisiert werden.

Die auszugebende Zeichenfolge wird in Anführungsstriche gesetzt. Getrennt durch Kom-mata, werden dahinter die beiden Variablen text1 und text2 bekannt gegeben. Der Inhalt

Objektname.Methodenname();

Console.WriteLine("C# macht Spaß.");

string text1 = "C#";string text2 = "Spaß";Console.Write("{0} macht {1}.", text1, text2);


70


der zuerst genannten Variablen text1 ersetzt den Formatausdruck {0} innerhalb der Aus-gabezeichenfolge, die zweite Variable text2 ersetzt den Formatausdruck {1}. Entscheidendist, dass dem ersten Parameter die Zahl 0 zugeordnet wird, dem zweiten die Zahl 1 usw. DieKonsolenausgabe lautet:

Innerhalb des Ausgabestrings müssen die anzuzeigenden Listenelemente nicht der Reihen-folge nach durchlaufen werden. Man kann sie beliebig ansprechen oder sogar einfach unge-nutzt lassen. Die Anweisung

würde demnach zu der folgenden Ausgabe führen:

Der Formatausdruck {} dient nicht nur zur eindeutigen Bestimmung des Elements, erermöglicht auch eine weitergehende Einflussnahme auf die Ausgabe. Soll der einzuset-zende Wert eine bestimmte Breite einnehmen, gilt die syntaktische Variante:

Dabei gilt Folgendes:

� N ist ein nullbasierter Zähler.

� M gibt die Breite der Ausgabe an.

Unbesetzte Plätze werden durch eine entsprechende Anzahl von Leerzeichen aufgefüllt.Sehen wir uns dazu ein Codefragment an:

Die Ausgabe lautet hier:

Die erste Ausgabe hat eine Gesamtbreite von drei Zeichen, die Zahl selbst ist allerdings nurzwei Ziffern breit. Daher wird vor der Zahl ein Leerzeichen gesetzt. Da für die Breite derzweiten Ausgabe zehn Zeichen vorgeschrieben sind, werden links von der Zahl acht Leer-stellen eingefügt.

Die Breite darf auch eine negative Zahl sein. Die Ausgabe erfolgt dann allerdings linksbün-dig, daran schließen sich die Leerstellen an.

C# macht Spaß.

Console.Write("{1} macht {0}.", text1, text2);

Spaß macht C#.

{N, M}

int value = 10;Console.WriteLine("Ich kaufe {0,3} Eier", value);Console.WriteLine("Ich kaufe {0,10} Eier", value);

Ich kaufe 10 EierIch kaufe 10 Eier


71


Sie können den Formatausdruck so spezifizieren, dass numerische Ausgabedaten einebestimmte Formatierung annehmen. Das führt uns zu der vollständigen Syntax des Format-ausdrucks:

Format spezifiziert, wie die Daten angezeigt werden. In Tabelle 2.1 werden die möglichenOptionen aufgelistet.

An alle Formatangaben kann eine Zahl angehängt werden, aus der die Anzahl der signifi-kanten Stellen hervorgeht. Nachfolgend sollen einige Beispiele den Einsatz der Formatan-gaben demonstrieren:

// Syntax: Formatausdruck{N [,M ][: Format]}

Format-angabe

Beschreibung

C Zeigt die Zahl im lokalen Währungsformat an.

D Zeigt die Zahl als dezimalen Integer an.

E Zeigt die Zahl im wissenschaftlichen Format an (Exponentialschreibweise).

F Zeigt die Zahl im Festpunktformat an.

G Eine numerische Zahl wird entweder im Festpunkt- oder im wissenschaftlichen Format angezeigt. Zur Anzeige kommt das »kompakteste« Format.

N Zeigt eine numerische Zahl einschließlich Kommaseparatoren an.

P Zeigt die numerische Zahl als Prozentzahl an.

X Die Anzeige erfolgt in Hexadezimalnotation.

Tabelle 2.1 Formatangaben zur Formatausgabe

int value = 4711;Console.WriteLine("value={0:C}", value); // Ausgabe: value=4.711,00 DM

Console.WriteLine("value={0:E}", value); // Ausgabe: value=4,711000E+003

Console.WriteLine("value={0:E2}", value); // Ausgabe: value=4,71E+003

int value = 225;Console.WriteLine("value={0:X}", value); // Ausgabe: value=E1

float value = 0.2512F;Console.WriteLine("value={0,10:G}", value); // Ausgabe: value= 0,2512

Console.WriteLine("value={0:P4}", value); // Ausgabe: value=25,1200%


72


Escape-Zeichen

Ähnlich wie in den Sprachen C++ und Java stellt C# eine Reihe von Escape-Sequenzen zurVerfügung, die dann verwendet werden, wenn Sonderzeichen innerhalb einer Zeichen-folge ausgegeben werden sollen. Beispielsweise kann man mit dem Zeichen \n einen Zeilen-umbruch erzwingen:

An der Konsole wird dann

angezeigt.

Mit Escape-Sequenzen lässt sich die Ausgabe von Sonderzeichen sicherstellen. Es ist aberauch vorstellbar, dass Zeichen, die vom Compiler als Escape-Sequenz interpretiert werden,selbst Bestandteil der Zeichenfolge sind. Fügen Sie dazu nur noch einen weiteren Schräg-strich ein. Dazu ein kleines Beispiel. Angenommen, Sie möchten die Ausgabe

erzwingen. Sie müssten dann die folgende Anweisung codieren:

Um die Interpretation als Escape-Sequenz für eine gegebene Zeichenfolge vollständig abzu-schalten, wird vor der Zeichenfolge das Zeichen @ gesetzt.

Console.Write("C#\nmacht\nSpaß.");

C#machtSpaß.

Escape-Zeichen Beschreibung\' Fügt ein Hochkomma in die Zeichenfolge ein.

\'' Fügt Anführungsstriche ein.

\\ Fügt einen Backslash in die Zeichenfolge ein.

\a Löst einen Alarmton aus.

\b Führt zum Löschen des vorhergehenden Zeichens.

\f Löst einen Formularvorschub bei Druckern aus.

\n Löst einen Zeilenvorschub aus (entspricht der Funktionalität der (¢)-Taste).

\r Führt zu einem Wagenrücklauf.

\t Führt auf dem Bildschirm zu einem Tabulatorsprung.

\u Fügt ein Unicode-Zeichen in die Zeichenfolge ein.

\v Fügt einen vertikalen Tabulator in eine Zeichenfolge ein.

Tabelle 2.2 Die Escape-Zeichen

Hallo\nWelt

Console.WriteLine("Hallo\\nWelt");


73


Jetzt lautet die Konsolenausgabe:

Die Methoden »ReadLine« und »Read«

Die Methode ReadLine liest ein oder mehrere Zeichen aus dem Eingabestrom – in unseremFall ist das die Tastatur. Die Bereitschaft der Methode, auf Zeichen zu warten, endet mitdem Zeilenumbruch, der jedoch selbst nicht zu den eingelesenen Daten gehört. Die einge-lesene Zeichenfolge wird von der Methode als Zeichenfolge vom Typ string zurückgelie-fert und kann somit einer string-Variablen zugewiesen werden.

Wir haben bisher die ReadLine-Methode dazu benutzt, um die Konsole bis zum Drückender (¢)-Taste geöffnet zu halten. In diesem Fall war der Eingabestrom immer leer, derRückgabewert wurde ignoriert und landete im Nirwana.

Werfen wir nun einen Blick auf die Read-Methode. Diese nimmt nur ein Zeichen aus demEingabestrom und gibt dessen ASCII-Wert zurück. Der Rückgabewert von Read ist daherkeine Zeichenfolge, sondern eine Zahl vom Typ int.

Es gibt aber noch einen weiteren, nicht weniger wichtigen Unterschied zwischen Read undReadLine: Die ReadLine-Methode liest eine ganze Zeile und benutzt den Zeilenumbruchdazu, das Ende der Eingabe zu erkennen. Danach wird der Zeilenumbruch dem Eingabe-strom entnommen und gelöscht. Die Read-Methode arbeitet anders, denn der Zeilenum-bruch wird nicht aus dem Eingabestrom geholt, sondern verbleibt dort und wird so langegepuffert, bis er von einer anderen Anweisung gelöscht wird. Das kann wiederum nur dieMethode ReadLine sein. Schauen Sie sich dazu das folgende Codefragment an:

Nach dem Start des Programms wartet Read auf die Eingabe des Anwenders und erkenntam Zeilenumbruch das Eingabeende. Der Zeilenumbruch befindet sich weiterhin im Einga-bestrom und harrt geduldig der kommenden Anweisungen. Die Anweisung in der letztenZeile, die ReadLine-Methode, reagiert als Erstes wieder auf den Eingabestrom, erkenntdarin den Zeilenumbruch und verarbeitet ihn. Das ist gleichzeitig auch das Signal, mit dernächsten Anweisung fortzufahren. Da aber das Ende der Main-Methode erreicht ist, schließt

Console.Write(@"C#\nmacht\nSpaß.");

C#\nmacht\nSpaß.

string eingabe = Console.ReadLine();Console.WriteLine(eingabe);

static void Main(string[] args){ int eingabe = Console.Read(); Console.WriteLine(eingabe); Console.ReadLine();}


74


sich das Konsolenfenster sofort. Erst ein zweiter Aufruf von ReadLine würde den eigentlichangedachten Zweck erfüllen, nämlich das Fenster geöffnet zu halten und die Ausgabe derWriteLine-Methode auf unbestimmte Zeit anzuzeigen.

Wenn mehrere Zeichen an der Konsole eingegeben werden, kann Read nur das erste aus-werten. Alle weiteren Zeichen bleiben zusammen mit dem Zeilenumbruch im Eingabe-strom. Mit

könnten Sie sich diese Zeichen anzeigen lassen.

2.3.5 Einfache Datentypen

Die .NET-Laufzeitumgebung verfolgt das Konzept der Objektorientierung nach strengenMaßstäben. Selbst einfache Datentypen werden als Objekte angesehen, die Methodenbereitstellen, um mit einer Variablen bestimmte Aktionen auszuführen. In Tabelle 2.3 sindalle nativen Datentypen von C# zusammenfassend aufgeführt.

Console.WriteLine(Console.ReadLine());

.NET-Laufzeittyp

C#-Alias CLS-kompatibel

Wertebereich

Byte byte ja 0 ... 255

SByte sbyte nein –128 ... 127

Int16 short ja –215 … 215 –1

UInt16 ushort nein 0 … 65.535

Int32 int ja –231 … 231 –1

UInt32 uint nein 0 ... 232 –1

Int64 long ja –263 … 263 –1

UInt64 ulong nein 0 … 264 –1

Single float ja 1,4 * 10–45 bis 3,4 * 1038

Double double ja 5,0 * 10–324 bis 1,7 * 10308

Decimal decimal ja ±79E27 ohne Dezimalpunktangabe; ±7.9E–29, falls 28 Stellen hinter dem Dezimalpunkt angegeben werden. Die kleinste darstellbare Zahl beträgt ±1.0E–29.

Char char ja Unicode-Zeichen zwischen 0 und 65.535

String string ja ca. 231 Unicode-Zeichen

Boolean bool ja true oder false

Object object ja Ein Variable vom Typ Object kann jeden anderen Datentyp enthalten, ist also universell.

Tabelle 2.3 Die elementarsten Datentypen


75


In der ersten Spalte ist der Typbezeichner in der .NET-Klassenbibliothek angeführt. In derzweiten Spalte steht der C#-Alias, der bei der Deklaration einer Variablen dieses Typs ange-geben werden kann.

Zu den Angaben in der dritten Spalte (CLS-kompatibel) muss ich Ihnen eine Erklärunggeben. .NET verfolgt nicht nur ein plattformunabhängiges Konzept, sondern auch einsprachunabhängiges. Das bedeutet, dass eine Komponente, die in einer fiktiven .NET-Pro-grammiersprache A geschrieben wird, auch den vollen Zugriff auf alle Features einer Kom-ponente haben sollte, die in einer anderen .NET-Sprache, nennen wir sie hier der Einfach-heit halber B, implementiert ist.

Das kann nur dann problemlos funktionieren, wenn sich beide auf einen gemeinsamenNenner hinsichtlich der Sprachfeatures geeignet haben, zu denen auch die elementarenDatentypen zu rechnen sind. Dieser gemeinsame Nenner wird durch die Common Langu-age Specification (CLS) vorgegeben. Das bedeutet: Wenn eine .NET-Anwendung CLS-kon-form codiert wird, ist damit eine Garantie verbunden, dass jeder andere .NET-Code Zugriffauf die (öffentlichen) Komponenten der CLS-konformen Anwendung hat – unabhängigdavon, in welcher Sprache sie codiert ist.

Wie Sie sehen, sind nicht alle Datentypen der Tabelle 2.3 CLS-konform. Sie können diesezwar innerhalb Ihrer Anwendung problemlos einsetzen, aber in der öffentlichen Schnitt-stelle haben sie nichts zu suchen.

Wie Tabelle 2.3 zu entnehmen ist, basieren alle Typen auf einer entsprechenden Definitionim .NET Framework. Das hat zur Folge, dass anstelle der Angabe des C#-Alias zur Typbe-schreibung auch der .NET-Laufzeittyp genannt werden kann. Damit sind die beiden folgen-den Deklarationen der Variablen value absolut gleichwertig:

Wertetypen und Referenztypen

.NET unterscheidet zwei wesentliche Gruppen von Datentypen:

� Wertetypen: Zu dieser Gruppe werden die elementarsten Datentypen gezählt, z. B.Int16, Int32, Boolean, Double usw. Das entscheidende Kriterium besteht darin, dass diezugrunde liegende Typdefinition von der Klasse ValueType abgeleitet ist.

Anmerkung

Vielleicht können Sie an dieser Stelle mit dem Begriff der öffentlichen Schnittstelle noch nicht allzuviel anfangen. Am Ende von Kapitel 4 werden Sie aber wissen, was damit gemeint ist. So langemuss ich Sie noch vertrösten.

int value;Int32 value;


76


� Referenztypen: Zu dieser Gruppe werden alle Typen gezählt, deren Typdefinition nichtvon ValueType abgeleitet ist. Das ist der überwiegende Teil aller Klassen der .NET-Bibli-othek. Kennzeichnend für diese Gruppe ist, dass die Variable eines Referenztyps einenZeiger auf einen Speicherbereich repräsentiert.

In Tabelle 2.3 sind die wichtigsten und somit auch elementarsten .NET-Datentypen aufge-führt. Bis auf Object und String sind alle der Gruppe der Wertetypen zuzurechnen. Damitstellt sich auch die Frage, warum .NET diese strikte Trennung bei den Datentypen macht.Die Antwort lautet: um die Effizienz zu steigern. Da .NET konsequent den objektorientier-ten Ansatz verfolgt, müssen ausnahmslos alle Daten Objekte sein. Da ein Objekt jedochauch mit einem verwaltungstechnischen Overhead verbunden ist, werden die einfachstenDatentypen erst zur Laufzeit als Objekte betrachtet.

Initialisierung von Variablen

Wenn Sie Variablen im Gültigkeitsbereich einer Methode (beispielsweise Main) deklarie-ren, gilt diese zwar als bekannt, jedoch nicht als mit einem bestimmten Startwert initiali-siert. Sie müssen einer methodeninternen, lokalen Variablen daher ausdrücklich einenWert zuweisen, bevor Sie zum Beispiel mit der Methode Console.WriteLine zum erstenMal darauf lesend zugreifen. Der folgende Code führt deshalb auch zu einem Compilerfeh-ler bei der Kompilierung:

Um eine Variable zu initialisieren, können Sie ihr bei der Deklaration einen Startwertzuweisen, z. B.:

Oder – um Ihnen schon an dieser Stelle eine andere syntaktische Variante vorzustellen – Sieverwenden den new-Operator:

Sollten Sie bei der Initialisierung oder während der Laufzeit versuchen, einer Variableneinen Wert zuzuweisen, der größer oder kleiner ist als der durch den Typ beschriebeneWertebereich, erhalten Sie einen Compiler- bzw. Laufzeitfehler.

static void Main(string[] args) { // fehlerhafter Code, ausgelöst durch eine nicht initialisierte // Variable!!! long value; Console.WriteLine(value);}

long value = 0;

long value = new long();


77


Ganzzahlige Datentypen

C# stellt acht ganzzahlige Datentypen zur Verfügung, von denen vier vorzeichenbehaftetsind, der Rest nicht. Die uns interessierenden CLS-konformen Datentypen sind:

� Byte

� Int16

� Int32

� Int64

Int16, Int32 und Int64 haben einen Wertebereich, der nahezu gleichmäßig über die nega-tive und positive Skala verteilt ist. Die vorzeichenlosen Datentypen, zu denen auch Bytegehört, decken hingegen nur den positiven Wertebereich, beginnend bei 0, ab. Der vorzei-chenlose Typ Byte, der im Gegensatz zu SByte CLS-konform ist, ist insbesondere dann vonInteresse, wenn auf binäre Daten zugegriffen wird.

Ganzzahlige Literale können in Dezimal- oder Hexadezimalform übergeben werden. Hexa-dezimale Zahlen (Basis = 16) erhalten zusätzlich das Präfix 0x. Die folgende Variable hexabeschreibt die Dezimalzahl 225:

Dezimalzahlen

Versuchen Sie einmal, die beiden folgenden Codezeilen zu kompilieren:

Normalerweise würde man erwarten, dass der C#-Compiler daran nichts zu beanstandenhat. Dennoch zeigt er erstaunlicherweise einen Kompilierfehler an. Wie ist das zu erklären?

Auch ein Literal wie unsere Zahl 0,123456789 muss zunächst temporär in den Speichergeschrieben werden, bevor es endgültig der Variablen zugewiesen werden kann. Um eineZahl im Speicher abzulegen, muss die Laufzeitumgebung aber eine Entscheidung treffen: Esist die Entscheidung darüber, wie viel Speicherplatz dem Literal zugestanden wird. Daskommt aber auch der Festlegung auf einen bestimmten Datentyp gleich. Bei Dezimalzahlli-teralen ist diese Festlegung immer eindeutig:

Nun kommt es bei der Zuweisung unseres Literals an value jedoch zu einem Problem: DasLiteral ist vom Typ double, und die Variable, die den Inhalt aufnehmen soll, ist vom Typ

int hexa = 0xE1;

float value = 0.123456789;Console.WriteLine(value);

Hinweis

Literale, die eine Dezimalzahl beschreiben, werden von der .NET-Laufzeitumgebung als double-Typ angesehen.


78


float. Per Definition weist double aber einen größeren Wertebereich als float auf – mitder Folge, dass unter Umständen vom Literal ein Wert beschrieben sein könnte, der größerist als der, den ein float zu speichern vermag. Der Compiler verweigert deshalb dieseZuweisung.

Es gibt einen sehr einfachen Ausweg aus diesem Dilemma: Man hängt dazu an das Literalein passendes Suffix an, hier F (oder gleichwertig f), mit dem wir den Typ float für dasLiteral erzwingen:

Nun ist der C#-Compiler in der Lage, den Inhalt an der Konsole anzuzeigen – vorausgesetzt,die Zahl entspricht dem Wertebereich eines float.

Genauigkeit von Dezimalzahlen

Die drei Typen float, double und decimal, mit denen unter C# Fließkommazahlen darge-stellt werden können, beschreiben nicht nur unterschiedliche Wertebereiche, sondernauch – was im Grunde genommen noch viel wichtiger ist – unterschiedliche Genauigkeiten.Auf herkömmlichen Systemen beträgt die Genauigkeit eines float-Typs etwa zehn Stellen,die eines double-Typs etwa 16 Stellen. Abhängig ist die Genauigkeit dabei immer von derAnzahl der Ziffern des ganzzahligen Anteils der Dezimalzahl.

Das folgende Codefragment demonstriert die Genauigkeit, die mit einem float erreichtwerden kann:

float value = 0.123456789F;Console.WriteLine(value);

Suffix Fließkommatyp

F oder f float

D oder d double

M oder m decimal

Tabelle 2.4 Typsuffix der Fließkommazahlen

// --------------------------------------------------------------// Beispiel: ...\Kapitel 2\DezimalGenauigkeit// --------------------------------------------------------------using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace DezimalGenauigkeit{ class Program { static void Main(string[] args) {


79


Es werden zunächst zwei Variablen vom Typ float deklariert. Danach wird beiden einWert zugewiesen, der sich nur an der zehnten Nachkommastelle unterscheidet. Mit derAnweisung

werden die Inhalte der beiden Variablen auf Gleichheit überprüft. Entspricht der von xrepräsentierte Wert dem von y, soll die Meldung Beide Werte sind gleich. ausgegebenwerden; weichen die Variableninhalte voneinander ab, sollte die Ausgabe Beide Wertesind ungleich. lauten.

Erstaunlicherweise erscheint nach dem Start der Laufzeitumgebung die Meldung, die vonden beiden Variablen beschriebenen Werte seien gleich. Diese offensichtliche Falschaus-sage ist darauf zurückzuführen, dass ein float nicht in der Lage ist, alle im vorliegendenFall angegebenen Nachkommastellen exakt zu interpretieren – der Typ ist schlichtwegüberfordert. Für Berechnungen, die eine höhere Genauigkeit erfordern, ist ein float daherweniger gut geeignet.

Ein ähnlicher Test, diesmal mit einem double-Typ, führt zu demselben Ergebnis – allerdingstritt dieser Effekt erst auf, wenn die Anzahl der Nachkommastellen erhöht wird. Dies istauch häufig der Grund dafür, sich für den einen oder anderen Dezimaldatentyp zu ent-scheiden. Die Größenordnung, die bereits ein float darstellen kann, ist per Definitionschon so groß, dass hier weniger das Entscheidungskriterium zu suchen ist.

Wenn von der Genauigkeit von Fließkommazahlen gesprochen wird, bedeutet das nicht,dass die Genauigkeit auf den Dezimalteil bezogen wird. Vielmehr ist es die Genauigkeit,mit der beispielsweise beim float die ersten zehn Zahlen – beginnend links mit der ersten– unterschieden werden können. Um dies zu testen, brauchen Sie nur die beiden Literaledes vorhergehenden Beispiels zu ändern, z. B.:

float x, y; x = 0.123456789F; y = 0.1234567891F; // Prüfung, ob die Inhalte der Variablen x und y gleich sind if(x == y) Console.WriteLine("Beide Werte sind gleich."); else Console.WriteLine("Beide Werte sind ungleich."); Console.ReadLine(); } }}

if(x == y)

static void Main(string[] args) { float x, y;


80


Wenn Sie diesen Code laufen lassen, werden Sie die folgende Ausgabe erhalten:

Wenn Sie die Zahl 7 als letzte Nachkommastelle an die Variable x anhängen, also

sieht der Compiler beide Variableninhalte als gleich an. Er berücksichtigt demnach dieachte Nachkommastelle nicht mehr für den Vergleich. Zum Vergleich: Im Beispiel miteinem einziffrigen ganzzahligen Anteil war es die zehnte Nachkommastelle.

Die Forderung nach sehr hoher Genauigkeit einer Dezimalzahl können die beiden Datenty-pen float und double manchmal nicht ausreichend erfüllen. Bei noch höheren Ansprüchenmuss die Wahl auf einen deutlich präziseren Datentyp fallen: decimal. Damit lassen sichZahlen darstellen, die eine Genauigkeit von bis zu 28 Nachkommastellen aufweisen.

Während die Zuweisung eines ganzzahligen Literals an eine decimal-Variable in bekannterArt und Weise erfolgt, also beispielsweise mit

muss bei der Zuweisung einer numerischen Zahl mit hohem Dezimalanteil wieder ein klei-ner Trick angewendet werden. Wenn Sie im Texteditor beispielsweise

eingeben, erhalten Sie bei der Kompilierung einen Compilerfehler. Nach den Gesetzen derTypkonvertierung, die wir in Abschnitt 2.3.6, »Typkonvertierung«, behandeln werden,kann eine Zahl vom Typ int einem decimal zugewiesen werden, ohne dass es zu einemDatenverlust kommt. Der int wird dabei implizit in decimal umgewandelt. Dieselbe Aus-sage gilt allerdings nicht, wenn ein double einem decimal zugewiesen werden soll – eskommt zu einer Fehlermeldung in der Entwicklungsumgebung, da der Compiler ein Dezi-malzahlliteral als double-Typ ansieht. Dieses Verhalten kann wieder durch ein Suffix, hierverwendet man den Buchstaben M bzw. m, vermieden werden:

x = 10.123456F; y = 10.1234567891F; if(x == y) Console.WriteLine("Beide Werte sind gleich."); else Console.WriteLine("Beide Werte sind ungleich."); Console.Read();}

Beide Werte sind ungleich.

x = 10.1234567

decimal decA = 120;

decA = 0.1234567890123456789012;

decA = 0.1234567890123456789012M;


81


Diese Erkenntnis wollen wir nun benutzen, um zum Abschluss die Genauigkeit zu testen,mit der eine Zahl vom Typ decimal arbeiten kann. Dazu dient uns der folgende Code:

Beachten Sie, dass die beiden Variablen x und y identisch sind, während sich x und z in der28. Nachkommastelle unterscheiden. Wenn Sie das Programm laufen lassen, wird an derKonsole folgende Ausgabe angezeigt:

Die Laufzeitumgebung erkennt den Unterschied an der 28. Nachkommastelle. Das istnatürlich eine deutliche Steigerung gegenüber float und double.

Wird der ganzzahlige Anteil eines decimal vergrößert, z. B. in

// --------------------------------------------------------------// Beispiel: ...\Kapitel 2\DecimalVergleich// --------------------------------------------------------------using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace DecimalVergleich{ class Program { static void Main(string[] args) { decimal x, y, z; x = 0.1234567890123456789012345678M; y = 0.1234567890123456789012345678M; z = 0.1234567890123456789012345679M; // Vergleich der Variablen x und y if(x == y) Console.WriteLine("x und y sind gleich."); else Console.WriteLine("x und y sind ungleich."); // Vergleich der Variablen x und z if(x == z) Console.WriteLine("x und z sind gleich."); else Console.WriteLine("x und z sind ungleich."); Console.ReadLine(); } }}

x und y sind gleich.x und z sind ungleich.

decA = 1000.1234567890123456789012346D


82


bewirkt jede weitere Ziffer links vom Komma einen Verlust an Genauigkeit. Im Beispielvon decA weist der Dezimalteil nur noch eine Genauigkeit von 25 Stellen rechts vomKomma auf.

Zeichenbasierte Datentypen

Variablen vom Typ char können ein Zeichen des Unicode-Zeichensatzes aufnehmen. Uni-code ist die Erweiterung des ein Byte großen ASCII- bzw. ANSI-Zeichensatzes mit seineninsgesamt 256 verschiedenen Zeichen. Unicode berücksichtigt die Bedürfnisse außereuro-päischer Zeichensätze, für die eine Ein-Byte-Codierung nicht ausreichend ist. Jedes Uni-code-Zeichen beansprucht zwei Byte, folglich ist der Unicode-Zeichensatz auch auf 65.536Zeichen beschränkt. Die ersten 128 Zeichen (0–127) entsprechen denen des ASCII-Zeichen-satzes, die folgenden 128 Zeichen beinhalten unter anderem Sonderzeichen und Wäh-rungssymbole.

Literale, die dem Typ char zugewiesen werden, werden in einfache Anführungsstrichegesetzt, zum Beispiel:

Um den ASCII-Wert eines einzelnen Zeichens zu erhalten, braucht man nur den Typ chareinem Zahlentyp wie beispielsweise int, long oder float zuzuweisen:

Die implizite Umwandlung eines char in einen Zahlenwert bereitet anscheinend keine Pro-bleme, der umgekehrte Weg – die Umwandlung eines Zahlenwerts in einen char – ist aller-dings nicht möglich.

char beschränkt sich nur auf ein Zeichen. Um eine Zeichenkette, die sich aus keinem oderbis zu maximal ca. 231 Einzelzeichen zusammensetzt, zu speichern oder zu bearbeiten,deklarieren Sie eine Variable vom Datentyp string. Die Einzelzeichen werden dabei wiebei char als Unicode-Zeichen der Größe 16 Bit behandelt. Zeichenketten werden grundsätz-lich in doppelte Anführungsstriche gesetzt:

Weitere Datentypen

Variablen vom Typ bool (Boolean) können nur zwei Zustände beschreiben, nämlich trueoder false, z. B.:

false ist der Standardwert.

char chrZeichen = 'A';

char chrZeichen = 'A';int intASCII = chrZeichen;Console.WriteLine(intASCII); // die Ausgabe lautet 65

string str = "C# ist spitze."

bool myBol = true;


83


Der allgemeinste aller Datentypen ist object. Er beschreibt in seinen vier Byte einen Zeigerauf die Speicheradresse eines Objekts. Eine Variable dieses Typs kann jeden beliebigenanderen Datentyp beschreiben: Es spielt dabei keine Rolle, ob es sich um eine Zahl, eineZeichenfolge, eine Datenbankverbindung oder um ein anderes Objekt wie zum Beispiel umdie Schaltfläche in einem Windows-Fenster handelt. Zur Laufzeit wird eine auf objectbasierende Variable passend aufgelöst und die gewünschte Operation darauf ausgeführt.

Um das zu demonstrieren, ist im folgenden Codefragment eine Variable vom Typ objectdeklariert, der zuerst ein Zahlenliteral und anschließend eine Zeichenfolge zugewiesenwird:

Die Variable objUniversal schluckt beide Zuweisungen anstandslos – an der Konsole wirdzuerst die Zahl 5 und danach die Zeichenfolge angezeigt.

Ganz gleich, was eine Variable vom Typ object beinhaltet, sie enthält grundsätzlich immernur einen Zeiger (auch als Verweis oder Referenz bezeichnet) auf ein Objekt – selbst dann,wenn es sich um eine Zahl handelt. Herkömmliche Betriebssysteme beschreiben 32-Bit-Speicheradressen. Daraus folgt auch die einheitliche Größe dieses Datentyps von vier Byte– unabhängig davon, welcher Typ referenziert wird.

Einfache Datentypen als Objekte

Eine Variable zu deklarieren sieht harmlos und unscheinbar aus. Und dennoch, hinter demVariablennamen verbergen sich Möglichkeiten, die Sie bisher vermutlich noch nicht erah-nen. In der .NET-Laufzeitumgebung wird alles durch die objektorientierte Brille betrachtet– sogar die einfachen Datentypen.

Ein simples Short soll ein Objekt sein? Wenn Sie dieser Aussage keinen Glauben schenkenwollen, schreiben Sie folgende Codezeile:

Hinweis

In vielen Programmiersprachen wird false numerisch mit 0 beschrieben und true durch alleWerte, die von 0 abweichen. .NET ist hier sehr viel strenger. Hier ist true nicht 1 und auch nicht67, sondern ganz schlicht true. Aus diesem Grund ist auch die folgende Anweisung falsch, die soin anderen Programmiersprachen durchaus möglich ist:

bool myBool = 2;

Das hat natürlich auch Auswirkungen auf Bedingungsprüfungen, wie Sie später noch sehen werden.

object objUniversal;objUniversal = 5;Console.WriteLine(objUniversal);objUniversal = "Hallo Welt.";Console.WriteLine(objUniversal);


84


Beachten Sie bitte hierbei den Punkt, der auf Int16 folgt. Sie werden feststellen, dass hinterder Punktangabe eine Liste aufgeklappt wird, die IntelliSense-Unterstützung (siehe Abbil-dung 2.4).

Abbildung 2.4 IntelliSense-Unterstützung in der Entwicklungsumgebung

In dieser Liste sind alle Eigenschaften und Methoden aufgeführt, die ein Objekt vom TypInt16 auszeichnen. Sie können aus dem Angebot auswählen, wenn Sie mit den Pfeiltastenzu der gewünschten Funktionalität navigieren und dann die (ÿ)-Taste drücken. Der ausge-wählte Eintrag aus IntelliSense wird sofort vom Code übernommen, was den Vorteil hat,dass ein Schreibfehler ausgeschlossen ist.

Wenn Sie beispielsweise wissen wollen, wo die wertmäßige Ober- bzw. Untergrenze desInt16-Typs liegt, könnten Sie dies mit dem folgenden Codefragment abfragen:

An der Konsole erfolgt danach die Anzeige:

Wahrscheinlich werden Sie schon festgestellt haben, dass IntelliSense nicht nur im Zusam-menhang mit der Punktnotation funktioniert. Sobald Sie in einer Codezeile den erstenBuchstaben eintippen, wird IntelliSense geöffnet und bietet Ihnen alle programmierbarenOptionen an, auf die mit dem eingegebenen Buchstaben zugegriffen werden kann. Die Aus-wahl erfolgt analog wie oben beschrieben.

Int16.

Console.WriteLine("Int16(min) = {0}", Int16.MinValue);Console.WriteLine("Int16(max) = {0}", Int16.MaxValue);

Int16(min) = -32768Int16(max) = 32767


85


2.3.6 Typkonvertierung

Sehen wir uns die folgenden beiden Anweisungen an:

Hier wird die Variable intValue vom Typ int deklariert und ihr ein Wert zugewiesen. Imzweiten Schritt erfolgt wiederum eine Variablendeklaration, diesmal vom Typ long. DerInhalt der zuvor deklarierten Variablen intValue wird lngValue zugewiesen. Der C#-Com-piler wird beide Anweisungen anstandslos kompilieren.

Nun ändern wir die Reihenfolge ab, deklarieren zuerst die long-Variable, weisen ihr einenWert von 12000 zu und versuchen dann, lngValue der int-Variablen zuzuweisen:

Diesmal ist das Ergebnis nicht wie vielleicht erwartet – der C#-Compiler quittiert die Zuwei-sung des long-Typs an den int-Typ mit einer Fehlermeldung, obwohl der Wertebereicheines int die Zuweisung von 12000 eindeutig verkraftet.

Das auftretende Problem beruht auf einer einengenden Datentypumwandlung: Der Werte-bereich eines int ist kleiner als der eines long. Im Gegensatz dazu ist die Zuweisung einesint an einen long eine aufweitende Operation, weil der long einen größeren Wertebereichals int hat.

Immer dann, wenn bei einer Operation zwei unterschiedliche Datentypen im Spiel sind,muss der Typ, der rechts vom Zuweisungsoperator steht, in den Typ umgewandelt werden,der sich auf der linken Seite befindet. Man spricht hierbei auch von der Konvertierung.

Prinzipiell werden zwei Arten der Konvertierung unterschieden:

� die implizite Konvertierung

� die explizite Konvertierung

Implizite Konvertierung

Eine implizite Konvertierung nimmt der C#-Compiler selbst vor. Dies setzt eine aufwei-tende Zuweisungsoperation voraus. Am besten schauen Sie sich dazu Abbildung 2.5 an.

Die Pfeilrichtung gibt eine aufweitende, also implizite Konvertierung vor; entgegengesetztder Pfeilrichtung wäre eine Konvertierung einengend. Demzufolge wird ein byte anstands-los implizit in einen short, int, long usw. konvertiert, aber nicht umgekehrt beispielsweiseein int in byte. Beachten Sie insbesondere, dass es keine impliziten Konvertierungen zwi-schen den Gleitkommatypen float/double und decimal gibt.

int intValue = 12000;long lngValue = intVar;

long lngValue = 12000;int intValue = lngValue;


86


Abbildung 2.5 Implizite Konvertierung einfacher Datentypen

Eine besondere Stellung nehmen bool, string, char und object ein. Mit einem bool odereinem string sind keine impliziten Konvertierungen möglich, ein char kann mit Aus-nahme von byte und short jedem anderen Typ zugewiesen werden. Variablen vom Typobject wiederum unterliegen Gesichtspunkten, die wir erst ab Kapitel 3 erörtern.

Unter Berücksichtigung der zuvor beschriebenen Gesetzmäßigkeiten sind die folgendenimpliziten Konvertierungen möglich:

Die folgenden drei Versuche werden hingegen vom C#-Compiler abgelehnt:

// zulässige implizite Konvertierungenint intVar = 15;decimal decVar = intVar;

char chrVar = 'K';int intValue = chrVar;

short shtVar = 11;double dblVar = shtVar;

// unzulässige implizite Konvertierungenfloat fltVar = 3.12F;decimal decVar = fltVar;

byte bytVar = 20;char c = bytVar;

int iVar = 1;bool bolVar = iVar;

charbool

string

object

byte

short

int

long

float decimal

double


87


Explizite Konvertierung

Unter expliziter Konvertierung versteht man die ausdrückliche Anweisung an den Compi-ler, den Wert eines bestimmten Datentyps in einen anderen umzuwandeln. Explizite Kon-vertierung folgt einer sehr einfachen Syntax: Vor dem zu konvertierenden Ausdruck wirdin runden Klammern der Typ angegeben, in den die Konvertierung erfolgen soll, also:

Man spricht bei den so eingesetzten runden Klammern auch vom Typkonvertierungsoperator.

Mit der expliziten Konvertierung wären die folgenden beiden Zuweisungen möglich, dieweiter oben noch einen Kompilierfehler verursacht haben:

Obwohl die explizite Konvertierung weitere Möglichkeiten eröffnet, sind ihr naturgemäßauch Grenzen gesetzt, da nur dann in einen anderen Typ umgewandelt werden kann, wennder Zieldatentyp in Beziehung zum Ursprungsdatentyp steht (siehe Abbildung 2.5). Bei-spielsweise bleibt ein boolescher Wert unter .NET immer ein boolescher Wert. Damit istdie folgende Konvertierung unter C# falsch, obwohl sie in anderen Programmiersprachendurchaus zulässig ist:

Sehr ähnlich, jedoch einfacher zu verstehen ist, dass der Konvertierungsversuch einesstring in einen int jeglicher Logik entbehrt:

Explizite Konvertierung mit den Methoden der Klasse »Convert«

Die explizite Konvertierung mit dem Typkonvertierungsoperator ist eine Möglichkeit,einen Datentyp zu erzwingen. Eine zweite Möglichkeit bietet die .NET-Klassenbibliothek.Es handelt sich hierbei um die Klasse Convert im Namespace System, die eine Reihe vonMethoden für diesen Zweck bereitstellt.

// Syntax: explizite Konvertierung(Zieldatentyp)Ausdruck

float fltVar = 3.12F;decimal decVar = (decimal)fltVar;

byte bytVar = 20;char c = (char)bytVar;

int iVar = 1; // fehlerbehaftete explizite Konvertierungbool bolVar = (bool)iVar;

string strText = "Hallo";int intVar = strText; // FALSCH!!


88


Damit ist das Codefragment

gleichwertig mit:

In zwei ganz wesentlichen Punkten unterscheidet sich die Konvertierung mit den Metho-den der Convert-Klasse von der mit dem Konvertierungsoperator:

� Grundsätzlich werden alle Konvertierungen mit den Methoden der Convert-Klasse aufeinen eventuellen Überlauf hin untersucht.

� Es können Konvertierungen durchgeführt werden, die mit dem Typkonvertierungsope-rator unzulässig sind.

Den erstgenannten Punkt werden wir im folgenden Abschnitt behandeln, während wir unsan dieser Stelle zunächst nur dem zweiten Punkt zuwenden. Angenommen, wir wollen ander Eingabeaufforderung die Eingabe in einer Integervariablen speichern, muss die Anwei-sung dazu wie folgt lauten:

Methode Beschreibung

ToBoolean (Ausdruck) Konvertiert den Ausdruck in einen bool-Typ.

ToByte (Ausdruck) Konvertiert den Ausdruck in einen byte-Typ.

ToChar (Ausdruck) Konvertiert den Ausdruck in einen char-Typ.

ToDecimal (Ausdruck) Konvertiert den Ausdruck in einen decimal-Typ.

ToDouble (Ausdruck) Konvertiert den Ausdruck in einen double-Typ.

ToInt16 (Ausdruck) Konvertiert den Ausdruck in einen short-Typ.

ToInt32 (Ausdruck) Konvertiert den Ausdruck in einen int-Typ.

ToInt64 (Ausdruck) Konvertiert den Ausdruck in einen long-Typ.

ToSByte (Ausdruck) Konvertiert den Ausdruck in einen sbyte-Typ.

ToSingle (Ausdruck) Konvertiert den Ausdruck in einen float-Typ.

ToString (Ausdruck) Konvertiert den Ausdruck in einen string-Typ.

ToUInt16 (Ausdruck) Konvertiert den Ausdruck in einen ushort-Typ.

ToUInt32 (Ausdruck) Konvertiert den Ausdruck in einen uint-Typ.

ToUInt64 (Ausdruck) Konvertiert den Ausdruck in einen ulong-Typ.

Tabelle 2.5 Die Konvertierungsmethoden der Klasse »Convert«

long lngVar = 4711;int intVar = (int)lngVar;

long lngVar = 4711;int intVar = Convert.ToInt32(lngVar);

int intDigit = Convert.ToInt32(Console.ReadLine());


89


Bekannterweise liefert ReadLine die Benutzereingabe als Zeichenfolge vom Typ stringzurück. Wäre die Methode Convert.ToInt32 gleichwertig mit dem Typkonvertierungsope-rator, würde der C#-Compiler auch die folgende Anweisung anstandslos kompilieren:

Allerdings wird uns der Compiler diese Anweisung mit der Fehlermeldung

quittieren, denn eine explizite Konvertierung des Typs string in einen numerischen Typmit dem Typkonvertierungsoperator ist auch dann unzulässig, wenn die Zeichenfolge eineZahl beschreibt. string und int stehen nach Aussage von Abbildung 2.5 in keinerlei Bezie-hung zueinander. Die Methoden der Klasse Convert sind aber so ausgebildet, dass in diesenFällen dennoch eine Konvertierung erfolgt.

Wie wir gesehen haben, können sich die Methoden der Convert-Klasse über diese Gesetz-mäßigkeit hinwegsetzen, natürlich vorausgesetzt, dass die Konvertierung aus logischerSicht sinnvoll ist. Solange aber eine Zeichenfolge eine Zahl beschreibt, darf auch eine Zei-chenfolge durchaus in einen numerischen Typ überführt werden.

Bereichsüberschreitung infolge expliziter Konvertierung

Eine explizite Konvertierung lässt eine typeinengende Umwandlung zu. Damit drängt sichsofort eine Frage auf: Was passiert, wenn der Wert des Ausgangsausdrucks größer ist alsder Maximalwert des Typs, in den konvertiert wird? Nehmen wir dazu beispielsweise an,wir hätten eine Variable vom Typ short deklariert und ihr den Wert 436 zugewiesen. Nunsoll diese Variable in den Typ byte überführt werden, der den Wertebereich zwischen 0–255 beschreibt.

Dieser Code resultiert in der folgenden Ausgabe:

Um zu verstehen, wie es zu dieser zunächst unverständlichen Ausgabe kommt, müssen wiruns die bitweise Darstellung der Zahlen ansehen. Für den Inhalt der Variablen shtVar ist dies:

Nach der Konvertierung liegt das Ergebnis 180 vor, beschrieben durch:

// FALSCH!!int intDigit = (int)Console.ReadLine();

Konvertierung des Typs 'string' zu 'int' nicht möglich

short shtVar = 436;byte byteVar = (byte)shtVar;Console.WriteLine(byteVar);

180

436 = 0000 0001 1011 0100

180 = 1011 0100


90


Vergleichen wir jetzt die bitweise Darstellung der beiden Zahlen, kommen wir sehr schnellzu der Erkenntnis, dass bei einer expliziten Konvertierung mit dem Typkonvertierungsope-rator beim Überschreiten der Bereichsgrenze des Zieldatentyps die überschüssigen Bits ein-fach ignoriert werden. Aus dem verbleibenden Rest wird schließlich die neue Zahl gebildet.

Dieses Verhalten kann zu sehr schwer zu lokalisierenden, ernsthaften Fehlern in einer lau-fenden Anwendung führen. Wenn Sie in einer Anwendung Code entwickeln und explizitkonvertieren müssen, sollten Sie daher die Kontrolle über einen eventuell eintretendenÜberlauf haben. Unter C# gibt es dazu drei Alternativen:

� die Operatoren checked und unchecked

� die Einstellung im Projekteigenschaftsfenster

� den Verzicht auf den Typkonvertierungsoperator und stattdessen die verwendung einerMethode der Klasse Convert, die zur Auslösung einer Fehlermeldung führt

Die Operatoren »checked« und »unchecked«

Wenden wir uns zunächst den Schlüsselwörtern checked und unchecked zu, und schauenwir uns an einem Beispiel den Einsatz und die Wirkungsweise an:

Nach dem Starten der Anwendung wird der Benutzer dazu aufgefordert, eine Zahl imBereich von 0 bis zum Maximalwert eines short einzugeben. Entgegengenommen wird die

// --------------------------------------------------------------// Beispiel: ...\Kapitel 2\CheckedDemo// --------------------------------------------------------------using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace CheckedDemo{ class Program { static void Main(string[] args) { // Zahleneingabe anfordern Console.Write("Geben Sie eine Zahl im Bereich von "); Console.Write("0...{0} ein: ", Int16.MaxValue); // Eingabe einem short-Typ zuweisen short shtVar = Convert.ToInt16(Console.ReadLine()); // Überlaufüberprüfung einschalten byte byteVar = checked((byte)shtVar); Console.WriteLine(byteVar); Console.ReadLine(); } }}


91


Eingabe durch die Methode Console.ReadLine, die ihrerseits die Eingabe als Zeichenfolge,also vom Typ string zurückliefert. Um die gewünschte Zahl einer short-Variablen zuwei-sen zu können, muss explizit konvertiert werden. Beachten Sie bitte, dass wir dazu dieMethode ToInt16 der Klasse Convert einsetzen müssen, da eine Konvertierung einesstring in einen short mit dem Typkonvertierungsoperator nicht zulässig ist:

Gibt der Anwender eine Zahl ein, die den Wertebereich des short-Typs überschreitet, wirdein Laufzeitfehler ausgelöst und die Laufzeit der Anwendung beendet. Falls der Wertebe-reich nicht überschritten wird, wird die dann folgende Anweisung ausgeführt:

In dieser Anweisung steckt allerdings eine Gemeinheit, denn nun soll der Inhalt der short-Variablen einer byte-Variablen zugewiesen werden. Je nachdem, welche Zahl der Anwen-der eingegeben hat, wird die Zuweisung fehlerfrei erfolgen oder – bedingt durch die Über-prüfung mit checked – zu einem Fehler führen. Löschen Sie checked aus dem Programm-code, wird die Zuweisung einer Zahl, die den Wertebereich eines byte-Typs überschreitet,in keinem Fall einen Fehler verursachen.

checked ist ein Operator und wird verwendet, um einen eventuell auftretenden arithmeti-schen Überlauf zu steuern. Die allgemeine Syntax hierzu lautet:

Tritt zur Laufzeit ein Überlauf ein, weil der Anwender eine Zahl eingegeben hat, die denWertebereich des Typs überschreitet, in den konvertiert werden soll, wird ein Laufzeitfeh-ler ausgelöst, der unter .NET auch als Ausnahme bzw. Exception bezeichnet wird. Gebenwir beispielsweise an der Konsole die Zahl 436 ein, werden wir die Mitteilung aus Abbil-dung 2.6 erhalten.

Abbildung 2.6 Fehlermeldung durch Überlauf

short shtVar = Convert.ToInt16(Console.ReadLine());

byte byteVar = checked((byte)shtVar);

// Syntax: Der checked-Operatorchecked(Ausdruck);


92


Nach dem Schließen der Fehlermeldung wird die unplanmäßige Anwendung beendet. Nunkönnten Sie argumentieren, dass das Beenden der Laufzeitumgebung auch nicht das seinkann, was unbedingt erstrebenswert ist. Dieses Argument ist vollkommen richtig, aberLaufzeitfehler lassen sich mittels Programmcode abfangen, und die Anwendung bleibtdanach in einem ordnungsgemäßen Laufzeitzustand. Diesem Thema werden wir uns inKapitel 7, »Weitere Möglichkeiten von C#«, noch ausgiebig widmen.

Falls nicht nur ein einzelner Ausdruck, sondern mehrere Ausdrücke innerhalb eines Anwei-sungsblocks auf einen möglichen Überlauf hin kontrolliert werden sollen, können Sie hin-ter checked einen Anweisungsblock angeben, innerhalb dessen der unkontrollierte Über-lauf durch die Auslösung eines Laufzeitfehlers unterbunden wird.

Wie diese Variante von checked eingesetzt wird, können Sie dem nachfolgenden Beispielentnehmen.

Wir können festhalten, dass wir mit checked eine gewisse Kontrolle ausüben können, fallszur Laufzeit, bedingt durch die explizite Konvertierung, ein Überlauf eintreten kann. DerOperator unchecked ist die Umkehrung der Arbeitsweise von checked: Er schaltet die Über-prüfung des Überlaufs aus und ist der Standard.

Während checked sich nur lokal auf den in runden Klammern stehenden Ausdruck bzw.einen eingeschlossenen Anweisungsblock bezieht, können Sie durch eine Änderung imProjekteigenschaftsfenster die Kontrolle über sämtliche auftretenden Überläufe in einerAnwendung ausüben. Öffnen Sie dieses Fenster, indem Sie im Projektmappen-Explorer dasProjekt markieren, dessen Kontextmenü mit der rechten Maustaste öffnen und dann Eigen-

schaften wählen.

Das Projekteigenschaftsfenster wird als zusätzliche Lasche im Codeeditor angezeigt. Am lin-ken Rand werden mehrere Auswahloptionen angeboten. Um unser Problem zu lösen, müs-sen Sie sich für Erstellen entscheiden (siehe Abbildung 2.7).

checked {/*...*/}

static void Main(string[] args) { checked { short shtVar = 436; int intVar = 1236555; byte byteVar = (byte)shtVar; shtVar = (short)intVar; Console.WriteLine(byteVar); Console.ReadLine(); }}


93


Abbildung 2.7 Das Projekteigenschaftsfenster

Rechts unten sehen Sie die Schaltfläche, die mit Erweitert ... beschriftet ist. Darüber wirdein Dialog geöffnet, der die gesuchte Option anbietet: Auf arithmetischen Über-/Unter-

lauf überprüfen (Abbildung 2.8). Markieren Sie das Kontrollkästchen, um sicherzustellen,dass eine generelle Überprüfung auf eine Über- oder Unterschreitung des Wertebereichserfolgt. Damit vermeiden Sie Datenverlust.

Abbildung 2.8 Einstellen der standardmäßigen Überprüfung des Überlaufs im Projekteigenschaftsfenster


94


Jetzt können Sie auf alle expliziten Angaben von checked verzichten, denn die Überprüfungdes Unter- bzw. Überlaufs wird in der Anwendung zum Standard erklärt. Möchte man ausbestimmten Gründen auf die Überprüfung verzichten, kommt der Operator unchecked insSpiel und hebt für den entsprechenden Ausdruck die Überprüfung wieder auf.

2.4 Operatoren

Im vorigen Abschnitt haben wir uns eingehend mit den Daten auseinandergesetzt. Nunwerden Sie lernen, wie diese Daten mit C# verarbeitet werden können. Bevor wir uns andie Details begeben, müssen wir uns zunächst mit der Terminologie befassen.

An oberster Stelle steht der Begriff Ausdruck. Ein Ausdruck ist die kleinste ausführbare Ein-heit eines Programms und setzt mindestens einen Operator voraus. Im einfachsten Fall giltschon die Anweisung

als Ausdruck. Ein Ausdruck wird immer aus mindestens einem Operanden und einem Ope-rator gebildet. Der Operator im Beispiel oben ist das Gleichheitszeichen, als Operand gel-ten sowohl die Konstante 22 als auch die Variable value. Operatoren verknüpfen Operan-den miteinander und führen Berechnungen durch, ermitteln also als Ergebnis derOperation neue Werte. Nahezu alle Operatoren von C# benötigen zwei Operanden. DasKernkonstrukt von Ausdrücken sind die Operatoren, die sich entsprechend ihrer Arbeits-weise in verschiedene Gruppen aufteilen lassen:

� arithmetische Operatoren

� Vergleichsoperatoren

� logische Operatoren

� bitweise Operatoren

� Zuweisungsoperatoren

� sonstige Operatoren

2.4.1 Arithmetische Operatoren

C# kennt die üblichen Operatoren der vier Grundrechenarten Addition, Subtraktion, Divi-sion und Multiplikation. Darüber hinaus werden von dieser Gruppe noch weitere Operato-ren beschrieben, die in ihrem Kontext eine besondere Bedeutung haben. Tabelle 2.6 gibtzunächst einen allgemeinen Überblick.

value = 22;


867

19 WPF-Steuerelemente

In diesem Kapitel erfahren Sie, wie Sie die Steuerelemente der WPF, wie z. B. verschiedeneButtontypen, Textboxen, Tooltips, List- und Comboboxen, Flowdocuments etc., einfügenund positionieren.

19.1 Hierarchie der WPF-Komponenten

Alle WPF-Komponenten befinden sich innerhalb einer tiefreichenden Vererbungshierarchie.Ausgehend von Object werden mit jeder weiteren Ableitung neue Eigenschaften und Metho-den eingeführt, was zu einer immer weiter fortschreitenden Spezialisierung der Typen führt.In Abbildung 19.1 sehen Sie einen Ausschnitt aus dieser Vererbungshierarchie.

Abbildung 19.1 Vererbungshierarchie der WPF-Komponenten

Object

DispatcherObject

DependencyObject

Visual

UIElement

FrameworkElement

Control

ContentElement

FrameworkContentElement

Freezable


868

WPF-Steuerelemente19

Sie erhebt keinen Anspruch auf Vollständigkeit, soll Ihnen aber einen Überblick über diewichtigsten Basisklassen verschaffen, die in diesem und dem folgenden Kapitel häufigergenannt werden.

In Tabelle 19.1 werden die wichtigsten Merkmale der Klassen genannt.

Klasse BeschreibungDispatcherObject Die von dieser Klasse abgeleiteten Klassen erlauben nur den Zugriff aus

dem Thread, in dem das Objekt erzeugt worden ist. Die meisten Klas-sen haben DispatcherObject als Basis sind deshalb auch nicht thread-sicher.

DependencyObject Diese Klasse ist die Basis für alle Klassen, die abhängige Eigenschaften unterstützen. In dieser Klasse sind die Methoden GetValue und Set-Value definiert.

Freezable Die Klasse Freezable dient als Basis für alle die Objekte, die in einen schreibgeschützten Zustand (read-only) gesetzt werden können, der auch als fixed bezeichnet wird. Fixierte Freezable-Objekte gelten, im Gegensatz zu DispatcherObject-Objekten, als threadsicher. Vertreter dieser Gruppe sind Pen, Brush oder auch Transform.

Visual Die Klasse Visual dient als elementare Basis für alle die Objekte. Sie unterstützt das Rendering von Controls und ist damit verantwortlich für die Darstellung.

ContentElement Diese Klasse ähnelt der Klasse UIElement, kann aber selbst keine eigene Darstellung haben. Objekte, die auf ContentElement zurückzu-führen sind, werden meist von Objekten gehostet, die von UIElement abgeleitet sind.

UIElement Die Klasse Visual dient als Basis für alle visuellen Objekte, die Routed Events unterstützen. Außerdem wird auch ein großer Teil des allgemei-nen Eingabe- und Fokusverhaltens für Elemente hier definiert.

FrameworkElement In dieser Klasse wird die Unterstützung von Styles, Datenbindung, Res-sourcen und weiterer allgemeiner Techniken eingeführt (z. B. Tooltips und Kontextmenüs).

Control Die Klasse Control ist die Basisklasse aller Steuerelemente und fügt der Vererbungshierarchie weitere Eigenschaften hinzu (z. B. Back-ground, Foreground). Außerdem stellt diese Klasse die Unterstützung von Templates bereit, mit denen die Darstellung der Steuerelemente individuell geändert werden kann.

FrameworkContentElement Entspricht der Beschreibung der Klasse FrameworkElement, gilt aller-dings für ContentElement-Objekte.

Tabelle 19.1 Beschreibung der wichtigsten Klassen


869

Steuerelemente positionieren 19.2

19.2 Steuerelemente positionieren

19.2.1 Die Eigenschaften »Top«, »Bottom«, »Right« und »Left«

Da in den meisten Layoutcontainern automatisch positioniert wird, erübrigen sich dieEigenschaften Top und Left. Diese beschreiben bekanntlich die Position eines Controls ineinem Container. Anders verhält es sich beim Canvas. Wie Sie wissen, können Sie in diesemLayoutcontainer die Komponenten frei positionieren. Das Canvas gibt die EigenschaftenTop und Left als sogenannte angehängte Eigenschaften (Attached Properties) weiter, diesich auf das übergeordnete Control beziehen.

19.2.2 Außenrand mit der Eigenschaft »Margin« festlegen

Die Eigenschaft Margin legt den Abstand zum Rand eines umgebenden Layoutcontainersfest. Demnach wird der Abstand zwischen dem Außenrand einer Komponente und demLayoutcontainer mit ihr festgelegt. Sie können Margin auf drei verschiedene Weisen einset-zen:

� Mit Margin="10" wird ein Rand von zehn Pixeln nach allen vier Seiten gewährleistet.

� Geben Sie zwei Werte an, z. B. Margin="10, 20", legt der erste Wert den linken und denrechten Rand fest, während der zweite Wert den oberen und den unteren Randbestimmt.

� Wenn Sie Margin vier Werte mitteilen, beispielsweise Margin="10, 20, 5, 25", gilt diefolgende Reihenfolge für die Randabstände: links, oben, rechts, unten.

Abbildung 19.2 Festlegung des Außenrandes

<Canvas> <Button Canvas.Left="100" Canvas.Top="40">Button1</Button></Canvas>

<StackPanel> <Button Margin="10, 30, 40, 5" Height="50">Button1</Button></StackPanel>


870


19.2.3 Innenrand mit der Eigenschaft »Padding« festlegen

Den Abstand des Außenrands einer Komponente zu dem Container, der sie umgibt, legenSie mit der Eigenschaft Margin fest. Mit Padding wird auch ein Randabstand beschrieben,allerdings der Abstand einer Komponente zu ihrem eigenen Inhalt. Gewissermaßen schafftPadding einen inneren Rahmen. Der Abstand kann durch einen Wert beschrieben werden,der rundum gilt. Legen Sie vier Werte fest, gelten diese der Reihenfolge nach für den lin-ken, oberen, rechten und unteren Randabstand.

Im folgenden Beispiel wird in einem Button ein Image dargestellt. Dabei hat der Buttoneinen Abstand von fünf Pixeln zu seinem Container, und das Bildchen in der Schaltflächehat rundum einen Abstand von zehn Pixeln.

19.3 Allgemeine Eigenschaften der WPF-Komponenten

Der weiter oben gezeigte Vererbungsbaum hat zur Folge, dass viele Eigenschaften undMethoden in allen Steuerelementen identisch sind. Um im weiteren Verlauf dieses Kapitelsnicht zu jedem Steuerelement immer wieder die gemeinsamen Eigenschaften aufzuführen,sollen die wichtigsten an dieser Stelle genannt werden.

19.3.1 Die Eigenschaft »Content«

Sehr viele Steuerelemente, zu denen auch Button zu rechnen ist, sind auf die BasisklasseContentControl zurückzuführen, die ihrerseits selbst direkt aus Control abgeleitet ist.Damit erben die Schaltflächen die Eigenschaft Content, die vom Typ Object ist und genauein Element enthalten kann. Content gehört zu den herausragenden Merkmalen der WPF-Komponenten und kann entweder ein Text oder auch ein beliebiges anderes Element sein.Geben Sie Eigenschaft Content ein anderes Element an, beispielsweise ein Grid oder einStackPanel, kann dieses selbst wieder Container praktisch unzähliger Unterelemente sein.Den Gestaltungsmöglichkeiten werden damit keine Grenzen gesetzt.

Betrachten wir daher an dieser Stelle exemplarisch eine Schaltfläche vom Typ Button. DieEigenschaft Content der Schaltfläche beschreibt den Text, mit dem ein Button beschriftetwird. Sie können die Eigenschaft als Attribut angeben, also:

<StackPanel> <Button Padding="10,10,10,10" Margin="5, 5, 5, 5" Height="200"> <Image Source="Egypt.jpg" Height="200" Width="300"> </Image> </Button></StackPanel>


871

Allgemeine Eigenschaften der WPF-Komponenten 19.3

Eine weitere Möglichkeit, den Inhalt des Buttons zu definieren, besteht darin, innerhalbdes öffnenden und schließenden XAML-Tags den Text anzugeben:

Das Ergebnis ist bei beiden Schreibweisen identisch, der Button wird mit der Zeichenfolge»OK« beschriftet.

Da aber der durch Content beschriebene Inhalt vom Typ Object ist, eröffnen sich noch wei-terreichende Möglichkeiten. Im folgenden Beispielcode wird ein Bild anstelle eines Textesverwendet:

Die Einschränkung, dass nur ein Element innerhalb einer Schaltfläche definiert werdenkann, lässt sich sehr einfach umgehen, indem Sie ein einfach ein Element einfügen, das sei-nerseits wieder selbst über mehrere Unterelemente verfügt.

Damit sind den Gestaltungsmöglichkeiten keine Grenzen gesetzt.

Es stellt sich nun die Frage, woher XAML weiß, dass der Inhalt zwischen dem ein- und aus-leitendem Element der Eigenschaft Content zugeordnet werden soll. Die Antwort auf dieseFrage ist in der Definition der Klasse ContentControl zu finden. In dieser wird mit demAttribut ContentPropertyAttribute die Eigenschaft Content als diejenige festgelegt, dieden Inhalt zwischen den Tags aufnehmen soll.

Sie können nicht davon ausgehen, dass der Inhalt zwischen dem ein- und ausleitenden Tagimmer einer Eigenschaft Content zugeordnet wird. Es kann sich auch um eine beliebige,

<Button Content="OK"></Button>

<Button> OK</Button>

<Button> <Image ... ></Image></Button>

<Button> <StackPanel> <TextBox Width="100" Text=""></TextBox> <Image.ImageFailed..></Image> </StackPanel></Button>

[ContentPropertyAttribute("Content")]public class ContentControl : Control, IAddChild{ ...}


872


andere Eigenschaft handeln. Als typisches Beispiel sei an dieser Stelle die Klasse TextBoxangeführt, die als Content-Eigenschaft die eigene Property Text festlegt.

19.3.2 Größe einer Komponente

Ehe wir uns den Eigenschaften zur Festlegung der Komponentengröße widmen, ein paarallgemeine Worte. Meistens ist es nicht notwendig, die Abmessungen der Steuerelementeexplizit festzulegen, ebenso wenig deren Position. Sie nehmen damit einer WPF-Anwen-dung ihre angestammte Anpassungsfähigkeit, selbst die optimale Größe und Lage einesControls zu finden. Die Auswirkungen zeigen sich, wenn sich beispielsweise die Zeichen-ketten ändern, etwa bei der Lokalisierung einer Anwendung.

Um einige Größen- oder auch Positionsangaben werden Sie nicht herumkommen, bei-spielsweise um die Startgröße eines Fensters oder die durch die Eigenschaften Padding undMargin beschriebenen Abstände (mehr dazu weiter unten).

Auch die Maßeinheit für die Größen- und Positionsangaben sollten an dieser Stelle erwähntwerden. Für alle Angaben gelten sogenannte device-independent pixel, zu Deutsch geräteun-abhängige Pixel. Diese Pixel sind mit einer Größe von 1/96 Zoll definiert. Arbeitet einAnwender mit einer Darstellung von 96 DPI, entspricht das WPF-Pixel tatsächlich einemPixel auf dem Monitor. Das gilt auch für die Einstellung der Schriftgröße in einer WPF-Anwendung.

Anzumerken ist neben dem neuen Einheitensystem, dass gegenüber der traditionellen Ent-wicklung einer Windows-Anwendung mit der WinForm-API die Maßangaben vom TypDouble sind.

Mit der Einführung der WPF ist es erstmals möglich, Steuerelemente beliebig zu skalieren.Das hat zur Folge, dass ein Button, der eine Länge von einem Zoll auf einem kleinen Bild-schirm hat, auch in der Länge von einem Zoll auf einem großen Bildschirm angezeigt wird– vorausgesetzt, die DPI-Einstellungen sind bei beiden Systemen identisch.

Sie können die Skalierung einer WPF-Oberfläche sehr gut im Designer von Visual Studiotesten. Dazu müssen Sie nur den Zoom-Regler links oben im Designer verstellen. Hierbeigilt: Ein höherer DPI-Wert wird durch eine Zoom-Einstellung größer 100 % simuliert.

[ContentPropertyAttribute("Text")]public class TextBox : TextBoxBase, IAddChild{ ...}

Anmerkung

Die Maßeinheit DPI steht für dots per inch. Sie gibt an, wie viele Pixel pro Zoll auf dem Monitorangezeigt werden. Die tatsächliche Einstellung hängt von der Konfiguration ab.


873


Kommen wir nach diesem Ausflug in die Grundlagen zurück zum eigentlichen Thema, derGröße der Steuerelemente, und betrachten wir hierzu einen Button. Wie alle anderen Steu-erelemente hat der Button die Eigenschaften Width und Height. Stellen Sie diese nicht expli-zit ein, nimmt der Button automatisch die Größe an, die erforderlich ist, um seinen Inhalt(Content) darzustellen.

Betrachten wir nun eine Schaltfläche innerhalb einer Panel-Komponente oder einer Zelledes Grid-Steuerelements. Hier wird der Button die komplette Breite und Höhe des Contai-ners ausfüllen. Zurückzuführen ist dieses Verhalten auf die Eigenschaften Horizontal-Alignment und VerticalAlignment, deren Vorgabeeinstellung Stretch ist. Wie die Schalt-fläche letztendlich dargestellt wird, ist vom übergeordneten Layoutcontainer abhängig. Ineinem StackPanel beispielsweise wird der Button die komplette Breite des Stackpanels ein-nehmen. Hier wird HorizontalAlignment ausgewertet, während die Höhe des Buttons sichaus der Höhe seines Inhalts bestimmt. In einer Grid-Zelle hingegen werden beide Eigen-schaften bewertet, sodass die Schaltfläche die Zelle komplett ausfüllt.

Grenzfälle der Größenfestlegung gibt es natürlich auch. Stellen Sie sich nur eine TextBox-Komponente vor, die mit der Benutzereingabe in ihrer Breite wächst. Gleichermaßen kannes sein, dass Steuerelemente sich auf eine Breite von 0 reduzieren. Um diesen Extremenvorzubeugen, können Sie mit den Eigenschaften MinWidth, MaxWidth, MinHeight undMaxHeight die minimalen und maximalen Ausdehnungen eines Steuerelements begrenzen.

19.3.3 Ausrichtung einer Komponente

Zur Ausrichtung einer Komponente in ihrem umgebenden Container dienen die beidenEigenschaften HorizontalAlignment und VerticalAlignment. HorizontalAlignment kanndie Werte Left, Right, Center und Stretch einnehmen, VerticalAlignment die Werte Top,Bottom, Center und Stretch. Verzichten Sie auf die explizite Angabe der beiden Eigenschaf-ten, gilt die Einstellung Stretch. Eine solche Komponente würde, wäre sie innerhalb einerGrid-Zelle platziert, die Zelle komplett ausfüllen. In Abbildung 19.3 sind die Auswirkungender verschiedenen Einstellungen zu sehen. Der Abbildung liegt der folgende XAML-Codezugrunde:

<Grid ShowGridLines="True"> <Grid.RowDefinitions> <RowDefinition /><RowDefinition /><RowDefinition /><RowDefinition /> </Grid.RowDefinitions> <Grid.ColumnDefinitions> <ColumnDefinition /><ColumnDefinition /> </Grid.ColumnDefinitions> <Button Grid.Row="0" VerticalAlignment="Top">Button1</Button> <Button Grid.Row="1" VerticalAlignment="Bottom">Button2</Button> <Button Grid.Row="2" VerticalAlignment="Center">Button3</Button>


874


Abbildung 19.3 Ausrichtung mit HorizontalAlignment und VerticalAlignment

Wenn wir uns allgemein über die Ausrichtung unterhalten, müssen wir auch die Ausrich-tung des Inhalts innerhalb eines Steuerelements berücksichtigen. Dieser wird durch diebeiden Eigenschaften

� HorizontalContentAlignment

� VerticalContentAlignment

beschrieben. Beide ermöglichen Einstellungen, die den Werten entsprechen, die weiteroben schon beschrieben worden sind.

19.3.4 Die Eigenschaften »Padding« und »Margin«

Fügen Sie eine Schaltfläche in ein StackPanel ein, wird die Schaltfläche die gesamte vomStackPanel zur Verfügung gestellte Breite in Anspruch nehmen. Der Button erstreckt sichalso vom linken bis zum rechten Rand des StackPanels. Die Höhe der Schaltfläche wie-

<Button Grid.Row="3">Button4</Button> <Button Grid.Row="0" Grid.Column="1" HorizontalAlignment="Left">Button5</Button> <Button Grid.Row="1" Grid.Column="1" HorizontalAlignment="Right">Button6</Button> <Button Grid.Row="2" Grid.Column="1" HorizontalAlignment="Center">Button7</Button> <Button Grid.Row="3" Grid.Column="1" >Button8</Button></Grid>


875


derum wird genau so sein, dass der Inhalt der Schaltfläche dargestellt werden kann (siehedazu Abbildung 19.4).

Abbildung 19.4 Standardanordnung zweier Schaltflächen im Stackpanel

Diese doch sehr eingezwängt anmutende Darstellung kann mit den beiden sich sehr ähnli-chen Eigenschaften Margin und Padding beeinflusst werden, die zusätzlichen Freiraum zurVerfügung stellen. Der Unterschied zwischen Margin und Padding ist der, dass Margin denFreiraum außerhalb eines Steuerelements beeinflusst und Padding den Freiraum innerhalbdes Elements.

Abbildung 19.5 verdeutlicht die Unterschiede zwischen Padding und Margin. Der Abbil-dung liegt der folgende XAML-Code zugrunde. Beachten Sie, dass für Button1 nur Margin(Außenrand), und für Button2 nur Padding (Innenrand) eingestellt ist.

Abbildung 19.5 Die Eigenschaften »Padding« und »Margin«

Im Beispiel wirken sich die Angaben für Margin und Padding auf alle vier Ränder gleicher-maßen aus. Sie können aber auch zwei andere Varianten benutzen, um die Randabständeunterschiedlich festzulegen. Mit

<StackPanel> <Button Margin="10">Button1</Button> <Button Padding="20">Button2</Button></StackPanel>

Margin="10 30"


876


wird der linke und rechte Außenrand mit 10 Einheiten festgelegt, mit dem Wert 30 derAußenrand oben und unten. Wenn Sie vier Werte angeben, z. B.

dann wird der linke Randabstand mit 10 Einheiten festgelegt, danach folgt der obereRandabstand mit 20 Einheiten, der rechte mit 30 und letztendlich der untere mit 40.

Padding und Margin sind vom Typ System.Windows.Thickness und haben den DatentypDouble. Thickness hat nur zwei Konstruktoren: einen einfach und einen vierfach paramet-risierten, der wie folgt aufgerufen wird:

19.3.5 Sichtbarkeit eines Steuerelements

Die Eigenschaft Visibility gibt an, ob ein Steuerelement sichtbar ist oder nicht. Normaler-weise würde man dahinter einen booleschen Datentyp vermuten, der mit true und falsedie Sichtbarkeit steuert. In WPF ist das nicht der Fall, denn Visibility erlaubt Einstellun-gen, die in der Enumeration Visibility definiert sind.

Der Unterschied zwischen den Werten Hidden und Collapsed zeigt das folgende Listing.Button1 ist Hidden, behält aber seine Größe und Position bei. Button3 hingegen istCollapsed. Die darunter liegende Schaltfläche Button4 rutscht nach oben und nimmt diePosition von Button3 ein (siehe auch Abbildung 19.6).

Margin="10 20 30 40"

Button1.Margin = new Thickness(12, 20, 30, 40);

Wert BeschreibungVisible Das Steuerelement ist sichtbar.

Hidden Das Steuerelement ist unsichtbar, beansprucht aber weiterhin den ihm ange-stammten Platz.

Collapsed Das Steuerelement ist unsichtbar und hat die Größe 0. Andere Steuerelemente können den freigegebenen Platz nutzen.

Tabelle 19.2 Die Werte der Enumeration »Visibility«

<StackPanel> <Button Padding="10" Visibility="Hidden">Button1</Button> <Button Padding="10">Button2</Button> <Button Padding="10" Visibility="Collapsed">Button3</Button> <Button Padding="10">Button4</Button></StackPanel>


877


Abbildung 19.6 Auswirkungen der Einstellung der Eigenschaft »Visibility«

19.3.6 Farbeinstellungen

Die Vorder- und Hintergrundfarbe wird bei den Steuerelementen mit den EigenschaftenForeground und Background eingestellt. Beide Eigenschaften sind vom Typ Brush. BeiBrush handelt es sich um eine abstrakte Klasse, folglich kommt als konkrete Angabe nureine der Ableitungen infrage. Hierbei handelt es sich um die in Tabelle 19.3 aufgeführtensechs Klassen.

Auf eine weitere Beschreibung dieser Klassen soll an dieser Stelle verzichtet werden. Wirwerden das in Kapitel 22, »2D-Grafik«, noch nachholen.

19.3.7 Schriften

Lassen Sie uns an dieser Stelle auch noch über die Festlegung der Schrift sprechen.Zunächst einmal ist festzuhalten, dass alle Steuerelemente die Einstellungen der Schrift von

Klasse BeschreibungSolidColorBrush Beschreibt eine einheitliche Farbe.

ImageBrush Zeichnet ein Bild in den entsprechenden Bereich. Das Bild kann entweder skaliert oder mehrfach gezeichnet werden.

DrawingBrush Entspricht ImageBrush mit dem Unterschied, dass anstelle einer Bitmap eine Vektorgrafik gezeichnet wird.

LinearGradientBrush Beschreibt einen linearen Farbverlauf zwischen zwei oder noch mehr Farben.

RadialGradientBrush Zeichnet einen kreisförmigen Übergang zwischen zwei oder mehr Farben.

VisualBrush Zeichnet ein Visual-Objekt in den angegeben Bereich.

Tabelle 19.3 Die abgeleiteten Klassen von »Brush«


878


ihrem übergeordneten Container übernehmen. Ändern Sie beispielsweise die Schriftart inWindow, werden alle Steuerelemente des Fensters automatisch den Fonttyp übernehmen, essei denn, Sie legen die Schriftart für ein Steuerelement anders fest.

Die Schrift kann über insgesamt fünf Eigenschaften manipuliert werden.

19.4 Buttons

Schaltflächen sind ein wesentlicher Bestandteil jeder Windows-Anwendung und relativeinfach aufgebaut. Wir wollen uns daher zuerst dieser Familie zuwenden. Grundsätzlichwerden zu den Schaltflächen fünf verschiedene Steuerelemente gerechnet:

� Button

� ToggleButton

� RepeatButton

� RadioButton

� CheckBox

In der Toolbox werden Sie die Steuerelemente ToggleButton und RepeatButton nicht fin-den, da diese beiden Typen ausschließlich anderen Steuerelementen als Basisklasse die-nen. Alle genannten Typen sind aber auf die gemeinsame Basisklasse ButtonBase zurück-zuführen.

19.4.1 Die Basisklasse »ButtonBase«

Das grundlegende Verhalten aller Schaltflächen-Steuerelemente ist bereits in der Basis-klasse ButtonBase festgelegt. Das auffälligste Merkmal dürfte sein, dass sie angeklickt wer-

Eigenschaft BeschreibungFontFamily FontFamily gibt die Schriftart an. Dabei handelt es sich ausschließlich um

TrueType-Schriften. Die Vorgabe ist Segoe UI.

FontSize Mit FontSize wird die Schriftgröße in WPF-Pixeln angegeben.

FontStretch FontStretch gibt an, ob eine Schrift zusammengedrückt oder gestreckt ange-zeigt werden soll. Die Eigenschaft lässt mehrere Einstellungen zu, wird aber nicht von jeder Schriftart unterstützt.

FontStyle FontStyle gibt an, ob eine Schrift normal oder kursiv dargestellt wird.

FontWeight Die Eigenschaft beschreibt, wie fett die Schrift dargestellt werden soll. Im Gegensatz zu den Einstellungen unter WinForms (true oder false), sind unter WPF sehr viele Grade einstellbar, die aber nicht von allen Schriftarten gleicher-maßen unterstützt werden.

Tabelle 19.4 Eigenschaften eines Fonts


879

Buttons 19.4

den können. Die Eigenschaft IsPressed liefert die Information, ob der Button aktuellgedrückt ist oder nicht.

Interessant dabei ist, dass festgelegt werden kann, wann das Click-Ereignis ausgelöst wird.Unter Windows Forms war das nicht möglich, hier wurde das Ereignis grundsätzlich immerbeim Loslassen der Maustaste ausgelöst. Das ist in WPF zwar auch die Vorgabe, kann aberdurch entsprechendes Setzen der Eigenschaft ClickMode geändert werden. ClickModegestattet drei verschiedene Einstellungen: Release, Press und Hover, deren BeschreibungSie Tabelle 19.5 entnehmen können.

19.4.2 Das Steuerelement »Button«

Schaltflächen vom Typ Button sind vielleicht die am häufigsten anzutreffenden Steuerele-mente. Ihr Einsatz ist denkbar einfach. Ziehen Sie das Element aus der Toolbox in dasWindow, oder schreiben Sie direkt den XAML-Code. Nach der Festlegung der Eigenschaftenhinsichtlich Größe und Position legen Sie noch die Eigenschaft Content fest.

Button-Objekte weisen aber auch noch eine besondere Eigenschaft auf. Sie können ineinem Fenster je einen Button mit IsDefault = True bzw. IsCancel = true kennzeichnen.Diese Schaltflächen reagieren auf die (¢)- bzw. die (ESC)-Taste. Wurde das entsprechendeFenster zuvor mit der Methode ShowDialog geöffnet, bewirken diese Schaltflächen auch dasSchließen des Fensters. Dabei wird an ShowDialog der Wert True oder False übergeben.

Buttons können mit einer Tastenkombination (Alt)+(Buchstabe) aktiviert werden. ImXAML-Code kennzeichnen Sie den sogenannten Mnemonics-Buchstaben durch das Voran-stellen eines Unterstrichs. Der Unterstrich ist nur im laufenden Programm zu sehen, wenn

Member BeschreibungRelease Das Ereignis wird ausgelöst, wenn auf eine Schaltfläche geklickt und die Maustaste

losgelassen wird. Dies ist die Standardvorgabe.

Press Das Ereignis wird ausgelöst, wenn auf eine Schaltfläche geklickt wird, sie aber noch nicht losgelassen wird.

Hover Das Ereignis wird ausgelöst, wenn der Mauszeiger über ein Steuerelement bewegt wird.

Tabelle 19.5 Die Enumeration »ClickMode«

Hinweis

Leicht zu verwechseln sind die beiden Eigenschaften IsDefault und IsDefaulted. Letztgenanntegehört zu einer langen Liste weiterer Eigenschaften, die über spezifische Zustände Auskunft geben.IsDefaulted gibt an, ob ein Button die Schaltfläche ist, die beim Drücken der Eingabetaste betätigtwurde. Diese Eigenschaft ist auch schreibgeschützt.


880


der Benutzer die (Alt)-Taste drückt. Natürlich geht diese Fähigkeit verloren, wenn Sieanstatt einer Zeichenfolge der Content-Eigenschaft ein anderes Steuerelement übergeben.

Hinsichtlich der Ereignisse gibt es nicht viel zu erzählen. In der Regel werden Sie nur dasEreignis Click programmieren.

19.4.3 Das Steuerelement »ToggleButton«

Ein Button-Objekt wird nach dem Anklicken wieder seinen ursprünglichen Zustand ein-nehmen. In dieser Hinsicht verhält sich ein ToggleButton anders, obwohl er im erstenMoment optisch einem Button-Control entspricht. Ein ToggleButton behält nach dem Kli-cken seinen Zustand bei. Wird er angeklickt, behält er so lange seine Position bei, bis dernächste Klick erfolgt.

Der aktuelle Zustand kann mit der Eigenschaft IsChecked ausgewertet werden. Normaler-weise wird das Steuerelement true (aktiviert) oder false (deaktiviert) zurückliefern. EinToggleButton kann aber auch drei Zustände beschreiben: true, false und null. Mit demdritten Zustand wird ein undefinierter Zustand beschrieben. Diesen Zustand kann einToggleButton-Objekt nur annehmen, wenn die Eigenschaft IsThreeState = true gesetzt ist.

Hinsichtlich der Ereignisse ist erwähnenswert, dass mit Checked, Unchecked und Inter-mediate Ereignisse ausgelöst werden, wenn der entsprechende Zustand erreicht wird.

Das Steuerelement ToggleButton, das zum Namespace System.Windows.Controls.Primitivesgehört, werden Sie in der Toolbox vergeblich suchen, weil es normalerweise nur imZusammenhang mit komplexeren Steuerelementen verwendet wird (beispielsweise derSymbolleiste). Sie können das Steuerelement aber dennoch problemlos im XAML-Codebenutzen.

Ein kleines Codebeispiel soll am Schluss den Einsatz zeigen:

In der Code-Behind-Datei können Sie die Ereignishandler programmieren, beispielsweise:

<ToggleButton Checked="toggleButton1_Checked" Unchecked="toggleButton1_Unchecked" IsEnabled="True">ToggleButton ...</ToggleButton>

private void toggleButton1_Checked(object sender, RoutedEventArgs e) { MessageBox.Show("Aktueller Zustand: Checked");}private void toggleButton1_Unchecked(object sender, RoutedEventArgs e) { MessageBox.Show("Aktueller Zustand: Unchecked");}


881

Buttons 19.4

Alternativ zu Checked und Unchecked kann der Zustand auch über das Click-Ereignis ermit-telt werden:

19.4.4 Das Steuerelement »RepeatButton«

Ähnlich wie der zuvor besprochene Button agiert auch ein RepeatButton. Der Unterschiedist, dass dieser Schaltflächentyp kontinuierlich Click-Ereignisse auslöst, solange der Maus-zeiger bei gedrückter Maustaste auf das Steuerelement weist. Die Häufigkeit, mit der Click-Ereignisse auftreten, hängt von den Einstellungen der Eigenschaften Delay und Intervalab. Die Zeitspanne vom Drücken bis zur ersten Click-Auslösung wird von Delay beschrie-ben und ist eine Angabe in Millisekunden. Die Zeitspanne zwischen den sich wiederholen-den Ereignissen beschreibt Interval (ebenfalls in Millisekunden).

Ähnlich wie ein ToggleButton gehört auch dieses Steuerelement zum Namespace System.Windows.Controls.Primitives und wird nicht in der Toolbox angeboten. Meistens findetes Verwendung im Zusammenhang mit anderen, komplexeren Steuerelementen.

Sinnvoll ist dieses Steuerelement, wenn es darum geht, Werte kontinuierlich zu erhöhenoder zu verringern. Sie können dieses Steuerelement dazu verwenden, um beispielsweiseein »Up-Down«-Control zu entwickeln, wie es im folgenden Beispiel gezeigt wird.

private void toggleButton1_Click(object sender, RoutedEventArgs e) { if((bool)toggleButton1.IsChecked) MessageBox.Show("Zustand: Checked"); else MessageBox.Show("Zustand: Unchecked");}

// ------------------------------------------------------------------// Beispiel: ...\Kapitel 19\RepeatButtonSample // ------------------------------------------------------------------<Window ...><StackPanel> <Border Margin="5" HorizontalAlignment="Left" BorderThickness="1" BorderBrush="Black"> <Grid> <Grid.RowDefinitions> <RowDefinition></RowDefinition> <RowDefinition></RowDefinition> </Grid.RowDefinitions> <Grid.ColumnDefinitions> <ColumnDefinition></ColumnDefinition> <ColumnDefinition></ColumnDefinition> </Grid.ColumnDefinitions> <Label Name="lblNumber" Grid.RowSpan="2" Content="0"


882


Zu diesem XAML-Code gehört der folgende C#-Code, der keiner weiteren Erläuterungbedarf:

Abbildung 19.7 Ausgabe des Beispiels »RepeatButtonSample«

19.4.5 Das Steuerelement »Checkbox«

Die CheckBox ähnelt vom Verhalten her einem ToggleButton, hat aber eine andere Darstel-lung. Der Zustand wird durch ein Zustandshäkchen angezeigt.

19.4.6 Das Steuerelement »RadioButton«

Auch ein RadioButton ist ein ToggleButton, allerdings mit einem etwas anderen Verhaltenin der Hinsicht, dass mehrere RadioButtons eine Gruppe bilden und immer nur einer aus-gewählt sein kann. Die anderen RadioButton-Elemente der Gruppe sind dann deaktiviert.

VerticalAlignment="Center" MinWidth="40" /> <RepeatButton Name="btnUp" Grid.Column="1" Click="btnUp_Click"> <Polygon Margin="4,0" Points="3,0 6,6 0,6 3,0" Stroke="Black" Fill="Black"/> </RepeatButton> <RepeatButton Name="btnDown" Grid.Row="1" Grid.Column="1" Click="btnDown_Click"> <Polygon Margin="4,0" Points="3,6 6,0 0,0 3,6" Stroke="Black" Fill="Black"/> </RepeatButton> </Grid> </Border></StackPanel></Window>

private void btnUp_Click(object sender, RoutedEventArgs e) { lblNumber.Content = Convert.ToInt32(lblNumber.Content.ToString()) + 1;}private void btnDown_Click(object sender, RoutedEventArgs e) { lblNumber.Content = Convert.ToInt32(lblNumber.Content.ToString()) - 1;}


883

Buttons 19.4

Befinden sich mehrere RadioButtons in einem übergeordneten Panel, bilden diese automa-tisch eine Gruppe. Sollen mehrere verschiedene Gruppen in einem Panel gebildet werden,stellen Sie einfach die Eigenschaft GroupName ein. Alle RadioButton-Elemente mit demsel-ben GroupName-Bezeichner gehören einer gemeinsamen Gruppe an. Eine andere Möglich-keit ist, für alle zu gruppierenden Steuerelemente ein separates Panel bereitzustellen. Dabeikann es sich um Layoutcontainer handeln, aber auch um Steuerelemente wie Panel oderGroupBox.

Im folgenden Beispielcode sind zwei Gruppen von RadioButton-Steuerelementen definiert,die sich im gleichen Container befinden. Die Gruppenzugehörigkeit wird durch GroupNamebeschrieben. Innerhalb jeder Gruppe ist jeweils ein RadioButton durch Angabe der Eigen-schaft IsSelected vorselektiert.

Abbildung 19.8 Gruppierte RadioButtons

<Window ... > <StackPanel Margin="10">  <RadioButton Content="Schornsteinfeger" GroupName="Gruppe1" Margin="5,0,5,5" /> <RadioButton Content="Bäckermeister" GroupName="Gruppe1" Margin="5,0,5,5" IsChecked="True" /> <RadioButton Content="Dachdecker" GroupName="Gruppe1" Margin="5,0,5,20" />  <RadioButton Content="Mann" GroupName="Gruppe2" Margin="5,0,5,5" /> <RadioButton Content="Frau" GroupName="Gruppe2" Margin="5,0,5,5" IsChecked="True" /> </StackPanel></Window>

884


19.5 Einfache Eingabesteuerelemente

19.5.1 Das Steuerelement »Label«

Ein Label dient in einem Window dazu, Text anzuzeigen. Es gehört zu den sogenannten Con-tent-Steuerelementen, hat also eine Eigenschaft Content. Die Größe eines Labels ergibt sichaus dem Inhalt. Sie sollten daher die Größe nicht ausdrücklich angeben, da der anzuzei-gende Text ansonsten unter Umständen abgeschnitten wird.

Eine Besonderheit dieses Steuerelements ist die mögliche Definition eines Hotkeys. Wirddie (Alt)-Taste zusammen mit dem Hotkey gedrückt, erhält ein anderes Steuerelement denTastaturfokus. Das Tastenkürzel wird im Text des Label-Steuerelements durch einen Unter-strich ausgedrückt.

Die Zuordnung des Steuerelements, das den Tastaturfokus erhalten soll, erfolgt mit derTarget-Eigenschaft. So könnten Sie beispielsweise festlegen, dass beim Drücken von (Alt)+ (W) die TextBox mit dem Bezeichner txtWohnort den Fokus erhält. Das entsprechendeCodefragment dazu sieht wie folgt aus:

Zur Laufzeit wird der Access-Key allerdings erst dann sichtbar, wenn die Taste (Alt) ge-drückt wird. Wollen Sie innerhalb der Zeichenfolge einen Unterstrich schreiben, müssenSie zwei angeben.

Ein Label unterstützt von Haus aus keine Zeilenumbrüche. Aber es gibt zwei Möglichkei-ten, dennoch Zeilenumbrüche zu erzwingen:

� TextBlock

� AccessText

TextBlock ist ein Steuerelement, das wir später noch behandeln werden. Das Zusammen-spiel zwischen der Content-Eigenschaft des Labels mit einem TextBlock-Objekt gestattetes, Zeilenumbrüche darzustellen.

Nachteilig ist der Einsatz eines TextBlock-Elements, wenn Sie einen Hotkey bereitstellenwollen. Der TextBlock wird den Unterstrich auch als solchen darstellen. Für eine Kombina-tion aus Zeilenumbruch und Hotkey eignet sich das AccessText-Element.

<Label Target="{Binding ElementName=txtWohnort}" Height="28" Name="label1" Width="80">_Wohnort:</Label><TextBox Height="25" Name="txtWohnort" Width="120" />

<Label> <TextBlock TextWrapping="Wrap"> Hier wird ein Zeilenumbruch gezeigt. </TextBlock></Label>


885

Einfache Eingabesteuerelemente 19.5

19.5.2 Das Steuerelement »TextBox«

Die TextBox dient dazu, die Texteingabe eines Benutzers entgegenzunehmen oder einfachnur Text anzuzeigen. Dabei kann es sich um ein- oder mehrzeiligen unformatierten Texthandeln. Von Haus aus ist die TextBox bereits mit vielen Fähigkeiten ausgestattet. Beispiels-weise beherrscht sie den Datenaustausch über die Zwischenablage, hat eine eingebauteRechtschreibkorrektur und darüber hinaus auch noch eine mehrstufige Undo-Funktion.Alle angeführten Verhaltensweisen können genutzt werden, ohne dass Sie eine Zeile Codeschreiben müssen.

Größe des Steuerelements

Die Größe einer TextBox ergibt sich aus ihrem Inhalt. Je nachdem, in welchem Panel dieTextBox platziert ist, kann ihre Größe auf unvertretbares Maß schrumpfen. Es ist daherempfehlenswert, eine TextBox in einem Panel unterzubringen, das zumindest die Breite desInhalts vorgibt. Das wäre beispielsweise in einem StackPanel oder einer Grid-Zelle mit derEinstellung Width=*. Sie können zwar auch die Eigenschaft MinWidth einstellen, aber damitgeht unter anderem auch die Anpassungsfähigkeit an andere Schriftgrößen verloren.

Berücksichtigen sollten Sie auch die Höhe einer TextBox, die mehrere Zeilen anzeigenkann. Anstatt MinHeight und MaxHeight festzulegen, sollten Sie besser die EigenschaftenMinLines und MaxLines verwenden. Diese beiden Eigenschaften limitieren die Zeilen undberücksichtigen dabei die aktuelle Schriftart und -größe.

Texteingabe

Per Vorgabe ist die Eingabe in einer TextBox immer einzeilig. Mit der Einstellung Accepts-Return=True geben Sie an, dass beim Drücken der Eingabetaste eine neue Zeile eingefügtwerden kann. Der Benutzer kann dann auch mehrzeilige Texte eingeben. Behalten Sie dieVorgabe AcceptsReturn=False bei, wird beim Drücken der Eingabetaste der Standard-But-ton betätigt. Ähnliches gilt für die Eigenschaft AcceptsTab. Stellen Sie die Eigenschaft aufTrue ein, wird ein Tabulator in die TextBox eingefügt. Mit False wird zum nächsten Steuer-element in der Aktivierungsreihenfolge geschaltet.

Bei umfangreichen Texten sollten Sie berücksichtigen, Schiebebalken zu aktivieren. Dasgeschieht mit den Eigenschaften VerticalScrollBarVisibility und HorizontalScroll-BarVisibility, die Sie auf Auto stellen sollten. Beide Eigenschaften sind vom Typ der Enu-meration ScrollBarVisibility, deren Werte Sie Tabelle 19.6 entnehmen können.

<Label Target="{Binding TextBox1}"> <AccessText TextWrapping="Wrap"> Hier wird ein _Zeilenumbruch mit Hotkey gezeigt. </AccessText></Label>


886


Überschreitet die Benutzereingabe die Breite der TextBox, wird über den rechten Rand hin-aus geschrieben. Sie können mit der Eigenschaft TextWrapping=Wrap erzwingen, dass dieEingabezeile umbrochen wird, sobald das Ende der TextBox erreicht ist (die Standardvor-gabe ist TextWrapping=NoWrap). Dabei sollten Sie aber Vorsicht walten lassen. Handelt essich dabei um ein sehr langes Wort, wird es mittendrin umbrochen. Könnte ein solcher Fallauftreten, sollten Sie sich besser für die dritte Einstellmöglichkeit, WrapWithOverFlow, ent-scheiden. Diese umbricht das Wort zwar nicht mittendrin, hat aber zur Folge, dass die Zeilelänger wird, als von der angegebenen Größe der TextBox vorgesehen ist.

Textanzeige

Der Inhalt der TextBox wird durch die Eigenschaft Text beschrieben. Sie können dieseEigenschaft auch mit Code festlegen oder auswerten. Die Ausrichtung des Textes erfolgtmit der Eigenschaft TextAlignment. Zulässige Werte sind vom Typ der EnumerationTextAlignment. Sie sind Tabelle 19.7 zu entnehmen.

Mit der Eigenschaft TextDecoration lässt sich der Text »verzieren«. Genauer gesagt, kön-nen Sie die Dekorationen Overline, Underline, Baseline und Strikethrough einstellen.

Einstellung BeschreibungAuto Falls notwendig, wird ein Rollbalken automatisch angezeigt.

Disabled Der Rollbalken wird nur im Bedarfsfall angezeigt.

Hidden Ein Rollbalken wird auch dann nicht angezeigt, wenn es erforderlich wäre.

Visible Der Rollbalken wird immer angezeigt.

Tabelle 19.6 Werte der Enumeration »ScrollBarVisibility«

Wert BeschreibungCenter Der Text wird in der TextBox zentriert ausgerichtet.

Left Der Text wird in der TextBox links ausgerichtet.

Right Der Text wird in der TextBox rechts ausgerichtet.

Justify Der Text wird in der TextBox so ausgerichtet, dass alle Zeilen die gleiche Länge haben.

Tabelle 19.7 Textausrichtung mit der Enumeration »TextAlignment«

<TextBox FontSize="36"> <TextBox.TextDecorations> <TextDecoration Location="Underline"/> </TextBox.TextDecorations> Testtext</TextBox>


887


Dekorationen können in vielerlei Hinsicht gestylt werden. So können Sie gestrichelte Deko-rationen, aber auch Dekorationen mit Farbverlauf realisieren.

Markierter Text

Den vom Anwender markierten Text liefert die Eigenschaft SelectedText. Die Länge desselektierten Textes kann mit SelectionLength abgefragt werden. Die dritte Eigenschaft,SelectionStart, gibt an, bei welchem Buchstaben die Auswahl beginnt. Dabei wird vonTextbeginn an gezählt, wobei der erste Buchstabe in der TextBox den Wert 0 hat. Ist in demText »Aachen« beispielsweise die Teilzeichenfolge »chen« selektiert, liefert SelectionStartden Wert 2.

Methoden zur Bearbeitung von Text

Zum Kopieren, Ausschneiden und Einfügen stehen die Methoden Copy, Cut und Paste zurVerfügung. Mit der Methode SelectAll wird der komplette Inhalt der TextBox markiert.Undo macht die letzte Aktion rückgängig, und Redo macht den letzten Rückgängig-Befehlrückgängig.

Die Anzahl der Undo- und Redo-Aktionen ist theoretisch unbegrenzt, das heißt, die Gren-zen werden nur durch den zur Verfügung stehenden Speicher gesetzt. So ist zumindest dieVoreinstellung. Ein sinnvoller Grenzwert kann mit der Eigenschaft UndoLimit festgelegtwerden. Möchten Sie die Undo- und Redo-Aktionen generell ausschalten, stellen Sie dieEigenschaften CanUndo und CanRedo auf false ein.

Interessant ist in diesem Zusammenhang auch, mehrere Bearbeitungsschritte mit denMethoden BeginChange und EndChange zusammenzufassen. Diese Aktionen werden dannals ein einziger Undo-Schritt gewertet. Allerdings geht das natürlich nur im Programmcode.

Rechtschreibprüfung

Wie bereits am Anfang erwähnt wurde, unterstützt die WPF-TextBox auch die Recht-schreibprüfung. Dieses Verhalten muss allerdings erst mit SpellCheck.IsEnabled = trueaktiviert werden. Es kommt dann automatisch die in den Systemeinstellungen ausgewählteSprache zur Anwendung. Wünschen Sie eine andere Sprache, geben Sie diese der Eigen-schaft Language als Sprachcode an (z. B. Language = en-us). Sie können sogar zwischen deralten und der neuen Rechtschreibung auswählen. Auch dafür dient die EigenschaftSpellCheck, die neben IsEnabled auch noch SpellingReform anbietet.

Hinweis

Fette oder kursive Schrift wird nicht über TextDecorations eingestellt, sondern über die Eigen-schaft der eingestellten Schriftart.


888


Abbildung 19.9 Rechtschreibprüfung einer »TextBox«

Einen Haken hat die Rechtschreibprüfung aber immer noch. Auch in der aktuellen Versiondes .NET Framewoks sucht man immer noch vergeblich nach einer ausreichenden Doku-mentation. Sie war und ist weiterhin verbesserungswürdig. Zudem gibt es auch keine Mög-lichkeit, die Rechtschreibkontrolle durch eigene Wörterbücher zu verbessern.

19.5.3 Das Steuerelement »PasswordBox«

Das Steuerelement PasswordBox dient zur Eingabe eines Passworts. Dieses Control ist deut-lich einfacher in der Handhabung als eine TextBox, da viele Eigenschaften und Methodeneiner TextBox nicht angeboten werden.

Das vom Benutzer eingegebene Passwort wird nicht als Text angezeigt, da die einzelnenBuchstaben durch ein Maskierungszeichen ersetzt werden. Per Vorgabe handelt es sichdabei um einen fetten Punkt. Sie können mit der Eigenschaft PasswordChar aber auch einanderes Zeichen festlegen. Die eingegebene Zeichenfolge kann über die EigenschaftPassword ausgewertet werden.

Erwähnenswert ist ein Ereignis dieses Steuerelements: PasswordChanged. Das Ereignis trittauf, wenn sich die Eigenschaft Password ändert. Damit wäre es Ihnen möglich, die Anzahlder Fehlversuche zu protokollieren und gegebenenfalls weitere Eingabeversuche zu unter-binden.


889


19.5.4 Das Steuerelement »TextBlock«

Das TextBox-Steuerelement ist nur zur Anzeige unformatierter Texte geeignet. StilistischeÄnderungen innerhalb des angezeigten Textes sind nicht möglich. Eine TextBlock-Kompo-nente ist in dieser Hinsicht etwas attraktiver. Allerdings kann der Inhalt nicht verändertwerden. Sehen wir uns an, welche Möglichkeiten in einem TextBlock stecken. Dabei sollnur ein kleiner Auszug aus den zur Verfügung stehenden Möglichkeiten gezeigt werden.

Silbentrennung

Mit der Eigenschaft IsHyphenationEnabled = true legen Sie fest, dass die automatische Sil-bentrennung von Wörtern aktiviert ist. Anzumerken ist dabei, dass die Silbentrennungnicht immer einwandfrei funktioniert, obwohl laut Dokumentation die Standardregeln derGrammatik zugrunde liegen.

Zeilenumbruch (manuell)

Mit dem Element <LineBreak /> können Sie einen manuellen Zeilenumbruch in den ange-zeigten Text einfügen.

Zeilenumbruch (automatisch)

Geben Sie in einem TextBlock einen sehr langen Text ein, wird dieser standardmäßig amEnde abgeschnitten. Die Einstellung TextWrapping = Wrap bewirkt einen automatischenZeilenumbruch, allerdings auch mitten im Wort. Mit TextWrapping = WrapWithOverflowwird ein Umbruch möglich, aber nicht mitten im Wort. Mit der Einstellung NoWrap wirdkein Zeilenumbruch ausgeführt.

Textbeschneidungen

Wird ein Text innerhalb einer dargestellten Zeile zu lang, wird er normalerweise abge-schnitten oder umbrochen. Eine dritte Variante besteht darin, Fortsetzungszeichen in Formvon drei Punkten anzuzeigen. Für dieses Verhalten ist die Eigenschaft TextTrimming verant-wortlich. TextTrimming kennt drei Werte, die Sie Tabelle 19.8 entnehmen können.

Wert BeschreibungNone Der Text wird nicht abgeschnitten.

CharacterEllipsis Der Text wird an einer Zeichengrenze abgeschnitten, und drei Punkte werden als Auslassungszeichen dargestellt.

WordEllipsis Der Text wird an einer Wortgrenze abgeschnitten, und drei Punkte werden als Auslassungszeichen dargestellt.

Tabelle 19.8 Die Werte der »TextTrimming«- Enumeration


890


Abbildung 19.10 Einstellungen der Eigenschaften »TextWrapping« und »TextTrimming«

Allgemeine Textdarstellung

Mit den Elementen <Bold> und <Italic> lassen sich einzelne Wörter fett oder kursiv anzei-gen. Tatsächlich können Sie auch mit dem von HTML bekannten <Span>-Element beson-dere Textdarstellungen erreichen, beispielsweise um den vom <Span>-Element eingegrenz-ten Textbereich farblich anders zu gestalten oder eine andere Schriftart zu verwenden. Imfolgenden Beispielcode werden einige der zuvor aufgeführten Elemente innerhalb einesTextBlock-Elements gezeigt.

<TextBlock TextWrapping="Wrap" TextTrimming="CharacterEllipsis"> DasIstWortEins DasIstWortzwei DasIstWortDrei</TextBlock>

<TextBlock TextWrapping="NoWrap" TextTrimming="CharacterEllipsis"> DasIstWortEins DasIstWortzwei DasIstWortDrei</TextBlock>

<TextBlock TextWrapping="NoWrap" TextTrimming="WordEllipsis"> DasIstWortEins DasIstWortzwei DasIstWortDrei</TextBlock>

<TextBlock TextWrapping="WrapWithOverflow" TextTrimming="CharacterEllipsis"> DasIstWortEins DasIstWortzwei DasIstWortDrei</TextBlock>

<Grid> <Border Padding="10"> <TextBlock FontSize="18" TextWrapping="Wrap" IsHyphenationEnabled="True"> Das ist ein <Italic>sehr</Italic> langer <Bold>Text</Bold> in einem TextBlock-Element. <LineBreak /><LineBreak /> Bitte schauen Sie sich an, wie einzelne Textabschnitte innerhalb dies Textes unterschiedlich formiert werden können. <LineBreak />


891


Abbildung 19.11 Textformatierungen im »TextBlock«

Texteffekte

Unter Zuhilfenahme von Transformationen können Sie die gesamte TextBlock-Kompo-nente manipulieren. Mit der Eigenschaft TextEffects geht das sogar mit einzelnen Buch-staben. TextEffects verwaltet dazu eine Collection von TextEffect-Objekten. Jedes Text-Effect-Objekt wird durch eine Reihe von Eigenschaften beschrieben, wobei die wichtigs-ten PositionStart, PositionCount und Transform sind. PositionStart legt dabei denBuchstaben fest, ab dem der Effekt beginnen soll, PositionCount die Anzahl der Buch-staben. Transform schließlich beschreibt den Effekt.

Das folgende Beispiel soll Ihnen zumindest ansatzweise zeigen, welche Möglichkeiten sichhinter TextEffects verbergen. Hier werden jeweils die Anfangsbuchstaben zweier Wörtergekippt:

Naürlich kann auch die <Span FontFamily="Courier New"> Schriftart</Span>, die <Span Foreground="Red" FontWeight="Bold"> Schriftfarbe</Span> oder der <Span Background="Red">Hintergrund</Span> angepasst werden. </TextBlock> </Border></Grid>

<StackPanel> <TextBlock FontSize="30"> Hallo Aachen <TextBlock.TextEffects> <TextEffect PositionStart="0" PositionCount="1"> <TextEffect.Transform> <RotateTransform Angle="-45" CenterX="10" CenterY="15" /> </TextEffect.Transform> </TextEffect> <TextEffect PositionStart="6" PositionCount="1"> <TextEffect.Transform>


892


Abbildung 19.12 Texteffekte

19.5.5 Das Steuerelement »Tooltip«

In Windows-Anwendungen werden Zusatzinformationen über kleine Rechtecke bereitge-stellt, die als Tooltipps bezeichnet werden. Angezeigt werden Tooltipps immer dann, wenndie Maus sich über einem Steuerelement oder einer Komponente befindet und eine Weilenicht bewegt wird. Jeder Komponente kann ein eigener Tooltipp zugeordnet werden. Dazudient die Eigenschaft ToolTip der Komponenten. Im einfachsten Fall kann ein ToolTip-Element wie im folgenden Listing gezeigt festgelegt werden:

Sie können aber die Fähigkeiten der WPF nutzen und den Inhalt der ToolTip-Eigenschaftfrei definieren. Im folgenden Listing wird dazu ein StackPanel verwendet, das seinerseitsein Label- und ein TextBlock-Element enthält.

<RotateTransform Angle="40" CenterX="90" CenterY="25" /> </TextEffect.Transform> </TextEffect> </TextBlock.TextEffects> </TextBlock></StackPanel>

<StackPanel> <Button Height="40" Width="150"> Beenden <Button.ToolTip> Hiermit schließen Sie das Fenster </Button.ToolTip> </Button></StackPanel>

<StackPanel> <Button Height="40" Width="150"> Beenden <Button.ToolTip> <StackPanel> <Label FontSize="14" HorizontalAlignment="Center" Foreground="Red" FontWeight="Bold">Achtung!</Label> <TextBlock MaxWidth="250" TextWrapping="Wrap">Durch Klicken dieser Schaltfläche wird das Fenster geschlossen und alle Änderungen gehen verloren.


893

FlowDocuments 19.6

Abbildung 19.13 Ein ToolTip-Steuerelement

Sie können die Anzeige des ToolTips nach eigenem Ermessen konfigurieren. Dazu verwen-den Sie die Klasse ToolTipService. Mit deren Hilfe können Sie beispielsweise mit derEigenschaft ShowDuration die Anzeigedauer bestimmen und mit InitialShowDelay dieVerzögerung festlegen, bis ein Tooltipp angezeigt wird. Die Zeitangaben erfolgen in Milli-sekunden. Standardmäßig erfolgt die Anzeige des ToolTips beim Mauszeiger, sie kann abermit den Eigenschaften HorizontalOffset, VerticalOffset, PlacementTarget und Place-mentRectangle auch nach eigenen Vorstellungen eingestellt werden. Auch diese Eigen-schaften stellen Sie mit ToolTipService direkt im betreffenden Element ein.

19.6 FlowDocuments

19.6.1 Allgemeine Beschreibung

Mit den Steuerelementen Label und TextBlock haben Sie auf den letzten Seiten zwei Steuer-elemente kennengelernt, die zur Laufzeit keine Textänderungen zulassen. Mit einerTextBox-Komponente ermöglichen Sie dem Anwender auf der einen Seite, eigene Einträgevorzunehmen. Der eingegebene Text ist allerdings unformatiert, das bedeutet, in einerTextBox kann der Inhalt nur in einer Schriftart dargestellt werden, er ist entweder komplettfett oder kursiv, lässt auch keine anderen optischen Hervorhebungen (beispielsweise durch

</TextBlock> </StackPanel> </Button.ToolTip> </Button></StackPanel>

<Button Height="40" Width="150" ToolTipService.ShowDuration="3000" ToolTipService.InitialShowDelay="500"> Beenden ...</Button>


1275

Index

-- (Operator) 95 97, 102, 105, 669, 670, 685! (Operator) 98!= (Operator) 97#define 455#elif 455#else 455#endif 455, 456#if 455#undef 456% (Operator) 95%= (Operator) 104& (Operator) 98, 101&& (Operator) 98&= (Operator) 104() (Operator) 106* (Operator) 95*= (Operator) 104+ (Operator) 95++ (Operator) 95+= (Operator) 104. (Operator) 105.NET

Eigenschaften 36Einführung 29Sprachenkonzept 37

.snippet 700/ (Operator) 95/= (Operator) 104<– (Operator) 97<< (Operator) 102<<– (Operator) 105-= (Operator) 104= (Operator) 104= = (Operator) 97> (Operator) 97>– (Operator) 97->-(Operator) 381>= (Operator) 97>> (Operator) 102>>= (Operator) 105?: (Operator) 106, 123[] (Operator) 106^ (Operator) 98, 102^= (Operator) 105| (Operator) 98, 101

|= (Operator) 104|| (Operator) 98~ (Operator) 1012D-Grafik 1021

A

Abfrageasynchrone 1082parametrisierte 1079

Abgeleitete Klasse 211Abhängige Eigenschaften 816Ablaufverfolgung 446Abort (Thread) 504abstract 224Abstrakte Klasse 225Abstrakte Methoden 224, 233

überschreiben 226AcceptChanges 1130, 1136AcceptRejectRule (Eigenschaft) 1136Achse (XPath) 752ActiveX Data Objects 1041Add 399AddDays 630AddHours 630AddMonths 630AddSeconds (DateTime) 630AddWithValue (Methode) 1080ADO.NET 1041

Command-Objekt 1065SqlDataAdapter 1093verbindungsorientierte Objekte 1041

Aggregatfunktion 1070Aggregation 247Aktionsabfrage 1068Aktivierbare Menüelemente 926Aktualisierung

manuell gesteuert 1156mit dem CommandBuilder 1149

Aktualisierungsstatement 1151All 490AllKeys 678AllowDBNull (Eigenschaft) 1116AllowMultiple (Attribut) 364, 366Angehängte Eigenschaften 818AnnotationService 979


1276

Index

Anonyme Methoden 282Anonyme Typen 359Anweisungsblock 60Anweisungstrennzeichen 59Anwendung weitergeben 1231Anwendungskonfigurationsdatei 664

Struktur 667Anwendungsmanifest 1268Any 490App.config 671App.xaml 802App.xaml.cs 802AppDataFolder 1240Append (StringBuilder) 623, 624AppendAllText 552AppendFormat 623AppendLine 623AppendText 552, 559

File 552FileInfo 559

ApplicationCommands 979, 984ApplicationSettingsBase 672AppSettings 674ArgumentException 425, 434, 1117ArgumentNullException 425ArgumentOutOfRangeException 436Arithmetischer Operator 94Array 107

Deklaration 107Elementanzahl 116Elementzugriff 108Größe 114Initialisierung 107Initialisierung in for-Schleife 134mehrdimensional 112Obergrenze 115sortieren 397Speicherabbild 110verzweigt 116

ArrayList (Klasse) 384, 386Datenaustausch mit Array 390sortieren 390

as-Operator 231Assembly 45, 641, 646

gemeinsame 648globale 648, 653private 648signieren 658Struktur 648

AssemblyInfo.cs 371

Association-Attribut 1203AsyncCallback 525, 527

Delegate 525Asynchrone Abfragen 1082Asynchroner Methodenaufruf 524, 525AsyncState 528Attached Properties 816, 818Attribut 361, 364

auswerten 368benutzerdefiniert 364GetCustomAttribute 370setzen 363XML 708

Attribute (Klasse) 364Attributes (FileInfo) 558AttributeTargets 364AttributeTargets (Attribut) 364AttributeTargets (Aufzählung) 365AttributeUsageAttribute 364, 365Auflistungen

binden 997Überblick 407

Auflistungsklassen 383generische 407

Aufzählung 307Ausdruck 94Ausgabeformatierung 633Ausnahme 420, 422, 423

benutzerdefinierte 437Hierarchie 434weiterleiten 428

Außenrand 869Authentifizierung 1046Auto

Debugging 462Fenster 462

AutoFlushStreamWriter 582TextWriterTraceListener 448

AutoIncrement (Eigenschaft) 1124AutoIncrementSeed (Eigenschaft) 1124AutoIncrementStep (Eigenschaft) 1124Autoinkrementspalten 1124Autoinkrementwert

neuen abrufen 1168AutoResetEvent 513AvailableFreeSpace 565Average 488


1277

Index

B

BandIndex (WPF) 930BannerBitmap 1251base 218, 219, 220Baseline 886Base-Stream 567, 579BaseStream (StreamWriter) 582Basisklasse 211Batch-Abfrage 1075

gemischte 1076Bedingte Kompilierung 455Bedingter Haltepunkt 458Bedingungsausdruck 131Befehlsfenster 460BeginEdit (Methode) 1121BeginInvoke 525, 533BeginRead (FileStream) 524, 532BeginStoryBoard 967BeginWrite (FileStream) 524, 532Benannter Parameter 367Benutzerdefinierte Konvertierung 339Benutzeroberflächen-Editor 1237, 1250Bereitstellungsmanifest 1268Bezeichner umbenennen 698Binäre Datenströme 584Binäre Ressourcen 941Binary IFormatter (Serialize) 594BinaryFormatter (Klasse) 594, 595BinaryReader 584

Klasse 584Methoden 584

BinaryWriter 584Klasse 584Methoden 584

Bindendynamisches 374statisches 233

Binding (Klasse) 985, 987Binding Markup Extension 988Bindung

an einfache Objekte 996mit Code erzeugen 988Richtung 989

Bindungsarten 989BitArray (Klasse) 407Bitweise Operatoren 101BlockUIContainer 896bool 74Boolean 74

BooleanSwitch 452Boolesche Operatoren 97Border 938Bottom 869break 128, 139, 144Brush-Objekt 1029Bubbling-Events 824BufferedStream (Klasse) 570ButtonBase 878Buttons (WPF) 878Byte (.NET) 74byte (C#) 74

C

C# Sprachgrundlagen 55CAB-Projekte 1232Call by Reference 181Call by Value 179CancelEdit (Methode) 1121CancelEventArgs 674CancellationTokenSource 546CanExecute 982CanRead (Stream) 568CanSeek (Stream) 568Canvas 848CanWrite (Stream) 568Capacity (StringBuilder) 622case 127catch 423, 435CDATA 711ChangeConflictException 1217ChangeConflicts 1219ChangePassword (Methode) 1047ChangeSet 1214Char (.NET) 74char (C#) 74CharacterEllipsis 889Chars 609, 623

String 609StringBuilder 623

Checkbox 882checked 90Class Designer 690class-Schlüsselwort 154ClickMode 879ClickOnce-Anwendung 1267

erstellen 1269installieren 1273

Clone 605


1278

Index

Close (StreamWriter) 581Closed (Methode) 1050CLR 42, 650CLR-Namespaces 813

zusammenfassen 814Code Snippets 699Codeausschnitte 699Codeeditor 49Collapsed 876Collect (Klasse GC) 267Collections 331, 383

Initialisierer 387CollectionsUtil (Klasse) 407Column-Attribut 1202ColumnDefinitions 858Columns 856COM 646Combine 280CombinedGeometry 1027ComboBox 917CommandBinding 982CommandBuilder 1149Command-Objekt 1065Commands 979

an Ereignisse binden 982programmieren 983vordefinierte 979

CommandTimeout (Eigenschaft) 1068Common Language Runtime 42, 650Common Language Specification (CLS) 39Common Type System 40CommonAppDataFolder 1240CommonFilesFolder 1240Compare 394, 610, 611CompareOrdinal 611CompareOrdinal (String) 609, 611CompareTo 390, 610, 611ComponentCommands 979Concat (String) 618Conditional (Attribute) 456Configuration 674ConfigurationManager 674ConfigurationSaveMode 678ConflictMode 1218ConflictOption 1155Connect Timeout 1051ConnectionState 1050ConnectionStrings 674, 1047Console (Klasse) 68ConsoleTraceListener 446, 447

const (Schlüsselwort) 201ConstraintCollection 1115Constraints 1093

Generic 323ContainsValue 402Content (WPF) 870ContentPresenter 971ContextMenu (WPF) 926, 927continue 140, 144ContinueUpdateOnError 1161Convert 87

Klasse 87Methoden 88

Copy 552File 552, 553

CopyrightWarning 1251CopyTo 623

FileInfo 559StringBuilder 559

Count 485Create 552, 559


CreateCommand (Methode) 1067CreateDirectory (Directory) 560CreateText 552, 559


CreationTime (FileInfo) 558CryptoStream 570CTS 40CultureInfo 634Custom Control 800

D

DataAdapter (Klasse) 1093Konstruktoren 1095

DataColumn 1108DataColumnCollection 1108DataColumnMappingCollection 1104DataContext 986, 1211, 1226DataGrid, Bindung 1013DataLoadOptions 1209DataRelation 1133DataRow 1109

editieren 1121DataRowCollection 1109DataRowState 1127DataRowVersion 1128


1279

Index

DataSet 1102, 1107Gültigkeitsprüfung 1112Objekt erzeugen 1108typisiertes 1171zugreifen auf Tabelle 1109

DataTable 1099, 1108ändern 1121filtern 1139manuell erzeugen 1182Spalten hinzufügen 1182Spaltenzuordnung 1104suchen in 1139

DataTemplates festlegen 999DataTrigger 967, 1001DataView 1141

erzeugen 1142zugreifen auf 1143

Dateikopieren 553löschen 554öffnen 554verschieben 554

Dateistartkondition 1263Dateisystem-Editor 1237, 1238Dateityp-Editor 1237, 1247Daten

im lokalen Speicher 1107konvertieren 1003

Daten binär speichern 584Datenbank

aktualisieren 1149Verbindung herstellen 1043

Datenbankabfrage 1065Datenbindung 985

einfache 987Datenfeld 107Datenkapselung 162Datenprovider 1042, 1043Datenquelle ändern 991Datensatz

ändern 1070einlesen 1071hinzufügen 1068löschen 1069

Datentrigger 962, 967Datentypen 65, 74

einfache 74elementare 74ganzzahlige 77generische 319zeichenbasierte 82

Datentypkonvertierung 86Datenzeile

ausgeben 1176bearbeiten 1180hinzufügen 1123, 1179löschen 1123suchen 1180

DateTime 626AddSeconds 630Day 628DayOfWeek 629Eigenschaften 628Hour 628Methoden 629MilliSecond 628Minute 628Month 628Second 628Ticks 626Today 629ToFileTime 630ToLongDateString 629ToLongTimeString 629ToShortDateString 629ToShortTimeString 629UtcNow 629Year 628

DateTimeFormatInfo 634, 636Day (DateTime) 628DayOfWeek (DateTime) 629DBConcurrencyException 1161, 1165DCOM 646Deadlock 500, 519Debug (Klasse) 441

Assert 444Methoden 443Write 443WriteIf 443WriteLine 442WriteLineIf 443

Debug (Schalter) 445Debugging 419, 441

mit Visual Studio 2010 457Debug-Konfiguration 445Decimal (.NET) 74decimal (C#) 74default (Generic) 323default (switch-Anweisung) 127DefaultIfEmpty 495DefaultTraceListener 446, 447#define 455


1280

Index

Delegate 273Multicast- 278vereinfachter Aufruf 277

Delegate (Klasse)Combine 280generisches 330GetInvocationList 280Remove 281

delegate (Schlüsselwort) 276Delete 552, 559, 560

File 552Delete (Directory) 560Delete (FileInfo) 559Delete (Methode) 1123DeleteCommand 1150, 1157DeleteOnSubmit 1216DelimitedListTraceListener 446, 447Dependency Properties 816DependencyObject 817Dequeue 406Deserialisierung 596Deserialize (Methode) 594, 597DesktopFolder 1240Desktop-Icon 1243Destruktor 200Dezimalzahlen 77Dictionary 331DictionaryEntry 401DiffHours 631DiffSeconds 631Directory 558, 559

CreateDirectory 560Delete 560Exists 560FileInfo 558GetCreationTime 560GetDirectories 560GetFiles 560GetFileSystemEntries 560GetParent 560Klasse 560Move 560SetCreationTime 560

DirectoryInfo (Klasse) 559, 560DirectoryName (FileInfo) 558DirectoryNotFoundException 425, 553Direkte Events 824Direktfenster 460Dispose 269Distinct 484

DLL 646DockPanel (WPF) 853, 924Document Object Model 764Document Type Definition 705DocumentViewer

XPS-Elemente 907DOM 764do-Schleife 142, 145Double (.NET) 74double (C#) 74DPI 872DrawingBrush 877, 1029, 1039DriveFormat 565DriveInfo 565DriveType 565, 566DTD 705dynamic 375Dynamic Link Library 646Dynamische Objekte 376Dynamische Ressourcen 946

zuweisen 952Dynamisches Binden 374

E

EditingCommands 979Editor

für benutzerdefinierte Aktionen 1261für Startbedingungen 1237, 1262

Eigenschaften 149get-Accessor 166lesegeschützt 165readonly 202schreibgeschützt 165set-Accessor 166

Eigenschaftsfenster 52Eigenschaftstrigger 962, 963Eingabesteuerelemente, einfache 884Eingebettete Namespaces 317Einzelschritt 458ElementAt 495Elementbaum 818

logischer 819visueller 819

ElementOrDefault 495#elif 455Ellipse-Element 1022#else 455else 119, 122Encoding (StreamWriter) 582


1281

Index

EndEdit (Methode) 1121#endif 455, 456EndInvoke 525, 529, 533EndRead (FileStream) 525, 532EndsWith (String) 612EndWrite (FileStream) 525, 532Enqueue 406EnsureCapacity 623Enter 516

Monitor 516Entitäten verknüpfen 1203Entitätsklassen 1229

Tools 1210EntityRef 1205EntitySet 1206Enum

GetValues 309enum 307, 308Enumeration 307Equals 603, 604Ereignis 283, 284

in der WPF 822Ereignisempfänger 284Ereignishandler 287

im .NET Framework 292Ereignisquelle 284Ereignistrigger 962, 965Erweiterungsmethoden 351

generische 354Richtlinien 354

Escape-Zeichen 72Event 284event (Schlüsselwort) 285EventLog 451EventLogTraceListener 446, 447, 450EventSetter 960Except 485Exception 421, 422, 423

allgemein 420behandeln 422benutzerdefinierte 437HelpLink 437Hierarchie 434InnerException 437Klasse 434, 437Source 437StackTrace 437TargetSite 437weiterleiten 428

Exceptionhandler 422Executed 982

ExecuteNonQuery (Methode) 1068ExecuteReader (Methode) 1068Exists 552, 554, 559, 560

Directory 560File 552, 554FileInfo 557, 559

Exit 516Monitor 516

Expander 936Explicit 994explicit 340Explizite Implementierung (Interface) 257Explizite Konvertierung 87Explizite Typumwandlung 230Expression Blend 974Extensible Markup Language 703Extension 558Extension (FileInfo) 558

F

Farbeinstellung (WPF) 877FavoritesFolder 1240Fehlerbehandlung 419Feld 150

Eigenschaft 160einkapseln 699öffentliches 160

Figure 899File

AppendText 552Copy 552Create 552CreateText 552Delete 552Exists 552GetAttributes 552GetCreationTime 552GetLastWriteTime 552Klasse 552Methoden 552Move 552Open 552OpenRead 552, 554OpenText 552, 554OpenWrite 552, 554SetAttributes 553SetCreationTime 553SetLastAccessTime 553SetLastWriteTime 553

FileAccess (Aufzählung) 555


1282

Index

FileInfo 557AppendText 559Attributes 558CopyTo 559Create 559CreateText 559CreationTime 558Delete 559Directory 558DirectoryName 558Exists 557, 559Extension 558FullName 558Klasse 557LastAccessTime 558LastWriteTime 558Length 558MoveTo 559Name 558Open 559OpenRead 559OpenText 559OpenWrite 559

FileLoadException 683FileMode (Aufzählung) 555FileNotFoundException 424, 425FileShare (Aufzählung) 556FileStream 524, 532, 570, 571

BeginRead 524BeginWrite 524EndRead 525EndWrite 525Klasse 571

Fill (Methode) 1096, 1191FillError (Ereignis) 1105FillSchema (Methode) 1114, 1118Finalize 603finally 427Find (DataView) 1143FindRows (DataView) 1143First 493First-in-wins 1153FirstOrDefault 493fixed 379Flags (Attribut) 361float 74Floater 900FlowDirection 852

FlowDocument 893Blöcke 895laden 905speichern 905

FlowDocumentPageViewer 894, 906FlowDocumentReader 894, 907FlowDocumentScrollViewer 894, 905FlowDocumentViewer 905Flush 448Flush (StreamWriter) 581FontFamily 878FontSize 878FontStretch 878FontStyle 878FontWeight 878For (Paralle) 540ForEach (Parallel) 542foreach-Schleife 141, 187, 309ForeignKeyConstraint 1115Format (String) 633, 636Formatangaben 71Formatausdruck 69

Konsolenausgabe 70Formatausgabe, Tabelle 71Formatierung

Datum und Zeit 639Zahlen und Zeichenformate 638

for-Schleife 115, 130Friend Assembly 643from 472, 473FullName (FileInfo) 558Func 467Fußgesteuerte Schleife 145

G

GAC 648, 653, 659gacutil.exe 658, 659Garbage Collector 265Garbage Collector (Thread) 500GC (Collect) 267Gemeinsame Assemblys 648Generics 319

Constraints 323definieren 321konvertieren 329Typparameter 321

Generische Auflistungsklassen 407


1283

Index

Generische Erweiterungsmethoden 354Generische Klassen 330

verschachtelte 413Generische Methoden 326Generischer Typparameter 322Generisches Delegate 330GeometryGroup 1026Gespeicherte Prozeduren 1086

aufrufen 1090komplexe 1091

get-Accessor 166GetAttributes 552

File 552GetChangeSet 1214GetChildRows 1136GetCreationTime 552, 560

File 552GetCreationTime (Directory) 560GetCustomAttribute 370GetData (Methode) 1192GetDirectories (Directory) 560GetDirectoryName (Path) 564GetEnumerator 415GetEventLogs 451GetExtension (Path) 564GetFileName (Path) 564GetFileNameWithoutExtension (Path) 564GetFiles (Directory) 560GetFileSystemEntries (Directory) 560GetFullPath (Path) 564GetHashCode 603GetInvocationList 280GetLastAccessTime (File) 552GetLastWriteTime (File) 552GetLength 115GetMaxThreads 513GetName (Methode) 1078GetOrdinal (Methode) 1077GetParent (Directory) 560GetParentRow 1136GetPathRoot (Path) 564GetSchemaTable (Methode) 1077GetSection 675GetTable 1212GetTempFileName (Path) 565GetTempPath (Path) 565GetType 603, 604GetValues (Klasse Enum) 309Gleichheitsoperator überladen 334

Gliederungsblock 60Global Assembly Cache 648, 653Globale Assembly 648, 653

installieren 658Globaler Namespace 314goto-Anweisung 128Gradientenachse 1031GradientStop 1032Grid 857GridSplitter 862GridView 918Groß- und Kleinschreibung 62GroupBox 933GroupBy 479GroupJoin 482Gültigkeit (XML) 718GZipStream 571

H

Haltemodus 457, 458Haltepunkt

bedingter 458verwalten 460

HasErrors (Eigenschaft) 1162Hashtable 384, 399

auf Listenelemente zugreifen 401Schlüssel 400Werte 400Zugehörigkeit von Element prüfen 402

Hashtable (Klasse) 398, 399Hat-ein(e)-Beziehung 243Hat-eine-Beziehung 244HeaderedItemControls 914Heap 160HelpLink 437Herausgeberrichtliniendatei 664, 683Hidden 876Hierarchisches DataSet 1181Hintergrundthread 511Hive 1245HKEY_CLASSES_ROOT 1245HKEY_CURRENT_USER 1245HKEY_LOCAL_MACHINE 1245HorizontalAlignment 873Hour 628HybridDictionary 407HyperLink (WPF) 839


1284

Index

I

IAsyncResult 525, 530ICloneable 605ICollection 385IComparable 331IComparer 331, 393IDictionary 385

Keys 399Remove 398Values 399

IDisposable 268IDL 650IEnumerable 331, 385, 415, 468#if 455if-Anweisung 118IFormatable 633IFormatProvider 634ildasm.exe 650IL-Disassembler 650IList 331, 386Image (WPF) 939ImageBrush 877, 1029, 1036Implementierung, explizite 257implicit 339Implizite Konvertierung 85Implizite Typumwandlung 228, 260Indent (Debug) 444IndentLevel (Debug) 444IndentSize (Debug) 444Indexer 343

überladen 346IndexOf (String) 612InfoMessage (Ereignis) 1057Inherited (Attribut) 364, 366Initialisierung 66, 156

literale 108Initialisierungsausdruck 131Inline-Elemente 899InlineUIContainer 900Innenrand 870Innere Klasse 249InnerException 437INotifyCollectionChanged 997in-Parameter 181InputGestureText (WPF) 926Insert (String) 615, 616, 624Insert (StringBuilder) 625InsertCommand 1150, 1157

Instanz 149Instanziierung 168int 74Int16 74Int32 74Int64 74Interface 253interface (Schlüsselwort) 254Interface Definition Language 650Intermediate Language 650internal 156, 170

Klasse 155internal-Konstruktoren 199InternalsVisibleTo 644Intersect 485InvalidCastException 320InvalidOperationException 1049Invoke (Parallel) 537IOException 425, 551is (Operator) 106IsAlive 506

Thread 506IsBackground 511IsCompleted 528IsEditable (WPF) 917is-Operator 230IsReady 565Ist-ein(e)-Beziehung 213ItemArray (Eigenschaft) 1122ItemControls 914

J

JIT 38Join 481

Thread 507, 508JOIN-Abfrage 1131Justify 886

K

Keys (IDictionary) 399Klassen 149

abgeleitete 211ableiten 212anlegen 152Definition 152Design 149generische 330


1285

Index

hinzufügen 152innere 249Instanz 149statische 207verschachtelte 249Zugriffsmodifizierer 155

Klassenbibliothek 641einbinden 644

Klassendesigner 690Klassendetails 693Klassendiagramm 690

als Bild exportieren 695Klasseninitialisierer, statischer 206Knoten ändern 776Kommentar 61

XML 709Kompilierung, bedingte 455Konfigurationsdateien 452, 664

Aufrufreihenfolge 666Konfliktanalyse 1161Konflikte behandeln 1216Konfliktsteuerung in Mehrbenutzerumgebung

1152Konfliktverhalten steuern 1217Konsolenanwendung 55, 56

Main-Prozedur 64Struktur 63

Konstanten 201Konstruktoren 195

Aufrufreihenfolge 207bereitstellen 196in abgeleiteten Klassen 214internal 199private 199Standard- 196statischer 206Verkettung 199, 216

Kontextknoten (XPath) 752Kontextmenüs (WPF) 926Kontrollstrukturen 118Konvertierung 228

explizite 87implizite 85mit der Klasse Convert 87Typ 85

Konvertierungsoperator 87Kopfgesteuerte Schleife 142Kundeninformationen (Dialog) 1254

L

Label 884Laden

sofort 1208verzögert 1206

Lambda-Ausdruck 356Language Integrated Query 465Last 494LastAccessTime (FileInfo) 558LastChildFill 854LastIndexOf (String) 612Last-in-wins 1153LastOrDefault 494LastWriteTime (FileInfo) 558Laufzeitfehler 420, 423

behandeln 419Layoutcontainer 846

verschachtelte 863Left 869LeftToRight 852Length (Array) 116Length (FileInfo) 558Length (Stream) 568Length (String) 609Lesegeschützte Eigenschaften 165Lesen aus einem FileStream 573Level (TraceSwitch) 453LinearGradientBrush 877, 1029, 1031LineBreak 899Line-Elemente 1022Liniendarstellung (WPF) 1023LINQ 465

Abfrageoperatoren 472Erweiterungsmethoden 466

LINQ to Objects 465, 469LINQ to SQL 1019, 1199LINQ to XML 785

Klassenhierarchie 785List 331, 896, 897ListBox 914, 1010ListDictionary 407Listener 446

mehrere verwalten 449Listeners (Eigenschaft) 447Listenfeld, mehrspaltiges 919ListView 918Literale Initialisierung 108


1286

Index

Lizenzvertrag (Dialog) 1257LoadWith 1209lock (Thread) 517lock-Anweisung 517Log (Eigenschaft) 1213Logische Operatoren 98Logische Ressourcen (WPF) 941

definieren 943Logischer Elementbaum 819Lokal

Debugging 462Fenster 462

Lokale Variable 177long 74LongCount 485LostFocus 994

M

machine.config 664Main (Klasse Console) 136Main-Prozedur 64, 136MainWindow.xaml 800MainWindow.xaml.cs 802Manifest 47, 647, 650Mapping 1202Margin 869, 874Markup Extensions 810Markup-Erweiterung

mit C#-Code 811MARS 1074Maschinenkonfigurationsdatei 664Max 488MaxCapacity (StringBuilder) 623MaxLength (Eigenschaft) 1116MediaCommands 979Mehrbenutzerumgebung

Konfliktsteuerung 1152Mehrdimensionale Arrays 112Mehrfachbindung 1006Mehrfachvererbung 212Mehrspaltiges Listenfeld 919Member 1222MemberChangedConflict 1222MemberConflicts 1220MemberwiseClone 603, 605MemoryStream (Klasse) 570, 571Menu (WPF) 923MenuItem (WPF) 923Menüleiste 923

Merge-Modulprojekt 1232Merge-Modulprojekte 1232Message 434, 437MessageBox (Klasse) 830, 831MessageBox.Show (Methode) 831MessageBoxButtons 831MessageBoxImage 832MessageBoxResult 832Metadaten 46Methoden 150, 169

abstrakte 224, 233anonyme 282Aufruf 171extrahieren 696klassenspezifische 205mit Rückgabewert 169ohne Rückgabewert 172Parameterliste 173partielle 372Referenzparameter 178Überladung 175versiegelte 238Virtuelle 226virtuelle 234Wertparameter 178

Methodenaufruf, asynchroner 524, 525MethodImplAttribute 524Millisecond 628Min 488Minute 628MissingMappingAction (Eigenschaft) 1104MissingMappingAction (Enumeration) 1105MissingSchemaAction (Eigenschaft) 1114MissingSchemaAction (Enumeration) 1119Monitor (Klasse) 516

Enter 516Exit 516Threadsynchronisation 515Wait 518

Month 628Move (Directory) 560Move (File) 552, 554MoveNext 415MoveTo (FileInfo) 559mscorlib.dll 653MSIL-Code 38MS-Installer 1231MultiBinding 1007Multicast-Delegate 278

Methoden 280


1287

Index

MulticastDelegate (Klasse) 280Multiple Active Resultsets 1074Multithreading 498MultiTrigger 965Mutex 522MyPicturesFolder 1240

N

Nachrichtenfenster 830Name (FileInfo) 558Namensbereiche 311Namensräume (XML) 711Namespace 44, 311, 812

CLR 813Ein- und Ausgabe 550eingebetteter 317festlegen 316globaler 314XAML 812XML 711zugreifen auf 312

NameValueCollection 407, 677NavigationCommands 979NavigationWindow 829, 837.NET

Eigenschaften 36Einführung 29Sprachenkonzept 37

NetworkStream (Stream) 571new (Generic) 325new (Instanziierung) 155new (Modifizierer) 222, 236new (Operator) 106new (Schlüsselwort) 150NewRow (Methode) 1123newVersion (Attribut) 683NextResult (Methode) 1075NonSerialized (Attribut) 600Now (DateTime) 626, 628Nullable 360Nullable Typen 359, 360NULL-Werte

behandeln 1073im typisierten DataSet 1180

NumberFormatInfo 634

O

O/R-Designer 1222Object 212, 603

Equals 603GetHashCode 603GetType 603Methoden 603ReferenceEquals 603ToString 237, 603

Object (.NET) 74object (C#) 74Object Relational Mapping 1199ObjectChangeConflict 1220, 1222ObjectDataProvider 1008Objekte 149

dynamische 376freigeben 158Methoden 169Übergabe 183

Objektinitialisierer 168Objektorientierte Programmierung 151

Vorteile 151Objektorientierung 149Objektreferenz 154Objektvariable 154Objektzuordnung mit Entitätsklassen 1200ObservableCollection 997Odbc-Provider 1042oldVersion (Attribut) 683OleDbCommand 1065OleDb-Provider 1042OneTime 989OneWay 989OneWayToSource 989OOP 151Open (File) 552Open (FileInfo) 559Open (Methode) 1049OpenExeConfiguration 675OpenMachineConfiguration 675OpenRead (File) 552, 554OpenRead (FileInfo) 559OpenText (File) 552, 554OpenText (FileInfo) 559OpenWrite (File) 552, 554OpenWrite (FileInfo) 559Operand 94operator 332


1288

Index

Operatoren 94arithmetischer 94bitweise 101Boolsche 97logische 98Vergleichs- 97Vorrangregeln 106Zuweisungs- 104

Operatorüberladung 331, 333Einschränkungen 333

Optionale Parameter 189Oracle-Provider 1042OrderBy 478OrderByDescending 478Orientation 851ORM 1199out (Schlüsselwort) 182out-Parameter 182OverflowMode (WPF) 929Overline 886override 237

P

Pad 613Padding 870, 874PadLeft (String) 615PadRight (String) 615Page 838Paragraph 895Parallel (Klasse) 536Parallele Programmierung 536ParallelLoopResult 542Parameter

benannter 367positionaler 367

ParameterDirection (Enumeration) 1092ParameterizedThreadStart 503Parameters-Auflistung 1080Parametrisierte Abfrage 1079params (Schlüsselwort) 187partial (Schlüsselwort) 156Partielle Methoden 372, 1227Pass-Through-Stream 567Password (WPF) 888PasswordBox (WPF) 888PasswordChar (WPF) 888Path (Klasse) 563

GetDirectoryName 564GetExtension 564

GetFileName 564GetFileNameWithoutExtension 564GetFullPath 564GetPathRoot 564GetTempFileName 565GetTempPath 565

Path-Element 1025PathGeometry 1028PenLineCap 1024Pinsel (WPF) 1029Plattformunabhängigkeit 36Polling 1082

Verfahren 1083Polygon-Element 1023Polyline-Element 1023Polymorphie 232Pop 405Position (Stream) 568Positionaler Parameter 367Postfixinkrementoperation 95Prädikat 358Präfixinkrementoperation 95PrimaryKey (Eigenschaft) 1116Priority, Thread 509private 170, 216Private Assemblys 648private-Konstruktoren 199ProgramFilesFolder 1240Programmschleifen 129ProgressBar 932Projektion 358Projektmappe 642

mehrere Projekte verwalten 642Projektmappen-Explorer 52PropertyChanged 994, 1229PropertyChanging 1229protected 170, 215protected internal 170Prozedur, gespeicherte 1086Prozedurschritt 458Prüfen auf Initialisierung 156public 170

Klasse 155Publisherrichtliniendatei 665Pulse 517

Monitor 517PulseAll (Monitor) 518Punktnotation 69Push 405


1289

Index

Q

Queue (Klasse) 331, 384, 404, 406QueueUserWorkItem 512

R

RadialGradientBrush 877, 1029, 1033RadioButton 882RadiusX 1033RadiusY 1033Range 489Read (Console) 68, 69, 73Read (Stream) 568Read (StreamReader) 582ReadAllBytes 552ReadAllLines 552ReadAllText 553ReadByte (Stream) 569, 570ReadKey 57ReadLine (Console) 57, 68, 69, 73ReadOnly (Eigenschaft) 1116readonly (Schlüsselwort) 202ReadToEnd (StreamReader) 582Rechtschreibprüfung 887Rectangle-Element 1022ref (Schlüsselwort) 180Refactoring 695ReferenceEquals 603, 604Referenz 154Referenzparameter 178Referenztypen 76, 159

konvertieren 341Referenzübergabe 181Reflection

MethodInfo 281Target 281

ref-Parameter 180RefreshMode 1219RefreshSection 675Registrierungs-Editor 1237, 1245Registrierungsstartkondition 1263Reinitialisierungsausdruck 131RejectChanges 1130, 1136Release (Schalter) 445Release-Konfiguration 445Remove (Delegate) 281Remove (IDictionary) 398, 399Remove (String) 615Remove (StringBuilder) 624, 625

Repeat 489RepeatButton 881Replace (String) 615, 616Replace (StringBuilder) 624, 625Reservierte Zeichen (XML) 710Reset 415ResetAbort (Thread) 506ResourceDictionary 948Ressourcen (WPF) 941

binäre 941dynamische 946logische 941statische 946suchen 950

Ressourcendateien 948Ressourcenwörterbücher, mehrere 950return 147, 171Reverse 479RichTextBox 909Right 869RightToLeft 852RootDirectory 565Routed Events 823RoutedUICommand 979RowChanged (Ereignis) 1122RowChanging (Ereignis) 1122RowDefinitions 858RowFilter (DataView) 1144Rows 856RowState (Eigenschaft) 1126RowStateFilter 1144RowUpdated 1163RowUpdating 1163Rückrufmethode bereitstellen 1084Rule (Enumeration) 1136

S

SByte (.NET) 74sbyte (C#) 74Schema-Informationen 1112SchemaType (Enumeration) 1118Schleifen 129

do 142, 145for 130foreach 141fußgesteuerte 145kopfgesteuerte 142verschachtelte 137vorzeitig beenden 139while 142


1290

Index

Schlüsseldatei 657Schnittstellen 253

Definition 254Implementierung 254

Schreiben in einen FileStream 572Schreibgeschützte Eigenschaften 165Schriften (WPF) 877ScrollBarVisibility 886ScrollViewer 935sealed 214, 238Second 628Section 896Seek (FileStream) 574Seek (Stream) 569SeekOrigin (Aufzählung) 569Select 477select 472SelectCommand (Eigenschaft) 1096SelectedIndex (WPF) 916SelectedItem (WPF) 916SelectedItems (WPF) 916SelectionMode (WPF) 914SelectMany 477SendPropertyChanged 1230SendPropertyChanging 1230SendToFolder 1240Separator 923Serialisierung 593

binäre 593in abgeleiteten Klassen 601mehrerer Objekte 597XML 780

Serializable (Attribut) 368, 595, 600SerializationException 595Serialize (Methode) 594, 597Server-Explorer 54set-Accessor 166SetAdded (Methode) 1131SetAllValues 1156SetAttributes (File) 553SetCreationTime (Directory) 560SetCreationTime (File) 553SetLastAccessTime (File) 553SetLastWriteTime (File) 553SetModified (Methode) 1131Settings 672SettingsChanging 673SettingsSaving 673Setup-Assistent 1233Setup-Projekt 659, 1232

Shapes 1021short 74Show (MessageBox) 831ShowProgressBar 1251Silbentrennung 889Single 74, 494, 1214SingleOrDefault 494, 1214Skip 492SkipWhile 492Slider 933SLN-Datei 643sn.exe 657Snippets 699SoapFormatter 594Sofortiges Laden 1208SolidColorBrush 877, 1030Sort 390, 394

DataView 1143SortedDictionary 331SortedList 384, 407Source (EventLog) 451Source (Exception) 437SourceColumn (Eigenschaft) 1158SourceUpdated 995SourceVersion (Eigenschaft) 1158Spalte

auswerten 1072Bezeichner ermitteln 1078Datentyp ermitteln 1079Index ermitteln 1078mit typspezifischen Methoden abrufen 1073

Span 900SpecialDirectories 566Speicherverwaltung 37Splash-Fenster 1253Split (String) 615, 617Sprachunabhängigkeit 37SQL Server 1041

Verbindung herstellen 1045SqlClient-Datenprovider 1079SqlClient-Provider 1042SqlCommand-Objekt 1065

ausführen 1067erzeugen 1066

SqlConnection 1043SqlConnectionStringBuilder 1048SqlDataAdapter 1065, 1093, 1096

Schema-Informationen abrufen 1118SqlDataReader 1065, 1070SqlException 1080


1291

Index

SQLMetal 1210SqlParameter 1080, 1081SqlRowUpdatedEventArgs 1163Stack (Klasse) 331, 384, 404StackPanel 849StackTrace 437Stammelement (XML) 708Standardkonstruktor 196Start (Thread) 502Startbedingung 1264

.NET Framework 1267Windows Installer 1267

Startmenü-Eintrag 1243StartMenuFolder 1240StartNew 543Startprojekt festlegen 643StartsWith 611StartsWith (String) 612State (Eigenschaft) 1049StateChange (Ereignis) 1058static 203, 204StaticResource 946Statische Klassen 207Statische Ressourcen 946

zuweisen 951Statischer Klasseninitialisierer 206Statischer Konstruktor 206Statisches Binden 233StatusBar (WPF) 931Statusleiste (WPF) 931Steuerelement 867

Sichtbarkeit 876Stildefinition überschreiben 959Stile

einfache 954typisierte 957

StopStoryBoard 967Stored Procedures 1086

aufrufen 1090komplexe 1091

Stream 549, 567CanRead 568CanSeek 568CanWrite 568Close 569Length 568Position 568Read 568ReadByte 569, 570Seek 569

Write 568WriteByte 569, 570

StreamReader 421, 582Read 421, 582ReadLine 421ReadToEnd 421, 582

StreamWriter (Klasse) 578AutoFlush 582BaseStream 582Close 581Encoding 582Flush 581

Stretch (WPF) 873Strikethrough 886String 608

Chars 609CompareOrdinal 609EndsWith 612erzeugen 608IndexOf 612Insert 616LastIndexOf 612Length 609Methoden 620PadLeft 615PadRight 615Replace 616Split 617StartsWith 612Substring 613ToCharArray 619ToLower 616ToUpper 616Vergleichsmethoden 611

String (.NET) 74string (C#) 74String.Format 634StringBuilder 608, 621

Append 624Capacity 622Chars 623Eigenschaften 623MaxCapacity 623Methoden 623Replace 625

StringCollection (Klasse) 384, 407StringDictionary (Klasse) 407String-Manipulationen 615Stringvergleich 609Stringverkettung 105


1292

Index

Stroke 1023struct 301, 302Strukturen

initialisieren 302verschachtelte 304

Styles 954Subklasse 211SubmitChanges 1214Substring (String) 613Suchen in Zeichenketten 611Sum 486SUO-Datei 643SuppressFinalize 269switch-Statement 124Symbolleisten (WPF) 928Synchronisation, Thread 513System

Enum 307Read 73ReadLine 73Write 68WriteLine 68

System.Collections 384System.DateTime 626System.Diagnostics 442System.IO 549System.IO.Directory 560System.IO.DirectoryInfo 560System.IO.File 551System.IO.Path 563System.IO.Stream 567System.Object 603System.Text 621System.Threading 501System.Threading.ThreadPriority 509SystemColors 952SystemException 434SystemFolder 1240SystemFonts 952SystemParameters 952Systemressourcen

abrufen 952anpassen 953

T

TabControl 922Table 896, 898, 1211TableAdapter 1185

erzeugen 1185mit mehreren Abfragen 1193

Table-Attribut 1202TableMappings (Klasse) 1100TableMappingsCollection 1099Tables 1109Take 491TakeWhile 491Target 281TargetSite 437TargetUpdated 995Task (Klasse) 537, 542Task <> 545Task Parallel Library 497, 536Teilstring 616TempFolder 1240TemplateBinding 971TemplateFolder 1240Templates 968Temporäre Verzeichnisse 565TextAlignment 886TextBlock 889TextBox 885Textdatei mit FileStream lesen 576Texteffekt 891TextReader (Klasse) 577, 578TextTrimming 889TextWrapping 889TextWriter (Klasse) 577, 578TextWriterTraceListener 446, 447ThenBy 478ThenByDescending 478this (Operator) 191, 344this (Schlüsselwort) 218Thread

Abort 504allgemein 498anhalten 504beenden 504bereiter 499IsAlive 506Join 508Klasse 501, 503laufender 499Priority 509ResetAbort 506starten 502Synchronisation 513unsynchronisiert 514wartender 499Zusammenspiel 500Zustand 498

ThreadAbortException 504


1293

Index

Threadausführung anhalten 504Threadpool 511Threadpriorität 499, 509

allgemein 498ThreadPriority (Aufzählung) 509ThreadStart 501

Delegate 501throw (Exception) 432Tick 626Ticks (DateTime) 626TicksPerDay 631TicksPerHour 631TileBrush 1034TimeSpan 631, 632

TicksPerDay 631TicksPerHour 631

ToCharArray (String) 619Today (DateTime) 629ToFileTime (DateTime) 630ToggleButton 880ToLongDateString (DateTime) 629ToLongTimeString (DateTime) 629ToLower (String) 616ToolBar (WPF) 928, 929ToolBarTray (WPF) 930Toolbox 53Tooltip 892Top 869ToShortDateString (DateTime) 629ToShortTimeString (DateTime) 629ToString 237, 603, 604, 637TotalFreeSpace 565TotalSize 565ToUpper (String) 616TPL 497, 536Trace (Klasse) 445TraceLevel 453TraceListener 446TraceListenerCollection 447TraceSwitch 453TreeView 921Trigger 962, 1001Trim 613TrimEnd 614TrimStart 614try 423Tunneling 824Tunneling-Events 824TwoWay 989

Typenanonyme 359nullable 359

typeof (Operator) 106, 310Typfeststellung 230Typinferenz 355Typisierte Stile 957Typisiertes DataSet 1171

Anatomie 1175erzeugen 1171NULL-Werte 1180

Typkonvertierung 85, 809Typkonvertierungsoperator 87Typmetadaten 649, 650Typparameter, generischer 322Typsuffix 78Typumwandlung 228

explizite 230implizite 228

U

ÜberwachenDebugging 463Fenster 463

uint 74UInt16 74UInt32 74UInt64 74ulong 74unchecked 90#undef 456Underline 886Unicode-Zeichen 82UniformGrid 856Unindent (Debug) 444Union 484Unique (Eigenschaft) 1116UniqueConstraint 1115Unmanaged Code 377unsafe 378Unsicherer Programmcode 377Unsynchronisierte Threads 514Update (Methode) 1096, 1192UpdateCheck 1217UpdateCommand 1150, 1157UpdateSourceTrigger 994UpdateStatus (Enumeration) 1164UpdateText 1251


1294

Index

User Control 800ushort 74using

Anweisung 270Objektzerstörung 270

using-Direktive 314UtcNow (DateTime) 629UTF-8-Zeichensatz 580

V

value-Parameter (Eigenschaft) 164Values (IDictionary) 399var 355Variablen 65

Bezeichner 67Deklaration 65initialisieren 66lokale 177Objekt- 154

Variableninitialisierung 76Verbindung

öffnen 1049schließen 1050

Verbindungsaufbau, Dauer 1051Verbindungspooling 1052

deaktivieren 1055Verbindungszeichenfolge 1044Vererbung 211Vergleichsoperatoren 97Verkettung

Strings 105Zeichenfolgen 105

Verschachtelte Klassen 249Verschachtelte Layoutcontainer 863Verschachtelte Schleifen 137Verschachtelte Strukturen 304Versiegelte Methode 238Versionierung 647, 655

Assemblys 655Versionsumleitung 678VerticalAlignment 873Verweis hinzufügen 644Verzögertes Laden 1206Verzweigte Arrays 116Virtuelle Methoden 226, 234Visibility 876Visual Tree 819

ermitteln 974

VisualBrush 877, 1030, 1037Visueller Elementbaum 819void 172Voll qualifizierender Name 314VolumeLabel 565Vordefinierte Commands 979Vordergrundthread 511

W

Wahrheitstabelle 99Wait 517

Monitor 517, 518Wait (Task) 544WaitCallback 512WaitOne 513, 523Warteschlange 498Wartungsaufwand 151Websetup-Projekt 1232Weitergabe 37Weitergabeeditor 1236Weitergabeprojekt kompilieren 1235WelcomeText 1251Wertebereich elementarer Datentypen 74Wertetypen 75, 159Wertparameter 178, 181Wertübergabe 179Where 468where (Generic) 324where (LINQ to Objects) 475while-Schleife 142Wiederverwendbarkeit 151Win32-API 421Window 829

Klasse 833Windows Installer 1233Windows Presentation Foundation 797WindowsFolder 1240Wohlgeformtheit (XML) 704WordEllipsis 889WPF 797

Anwendung 797, 799Anwendungstypen 799Benutzersteuerelementbibliothek 800Browseranwendung 800Buttons 878Containerelemente 829Farbeinstellung 877Fenster 829


1295

Index

Listenelemente 914Schriften 877Steuerelementbibliothek 800Steuerelemente 867

WPF-KomponenteAusrichtung 873Größe 872

WPF-Steuerelemente 867positionieren 869

WrapPanel 852Write (Console) 68Write (Debug) 443Write (Stream) 568WriteAllBytes 553WriteAllLines 553WriteAllText 553WriteByte (Stream) 569, 570WriteIf (Debug) 443WriteLine (Console) 68WriteLine (Debug) 443WriteLineIf (Debug) 443WriteXmlSchema (Methode) 1120Wurzelelement (XML) 708

X

XAML 803Elemente 805

XAML-Namespace 812XAML-Spracherweiterungen 815XDR 705XML 703

Attribute 708Dokumentationsdatei 688Dokumente 703Elemente 707gültiges 704Kommentar 709Kommentar-Tags 687Navigation 746Processing Instruction 710Reservierte Zeichen 710Serialisierung 780wohlgeformtes 704Wurzelelement 708

XML Data Reduced 705XML Schema 719XML Schema Definition 705

XmlArray 782XmlArrayItem 782XmlAttribute 782XML-Dokumentation 684XmlElement 782XmlIgnore 782XmlReader (Klasse) 729

Eigenschaften 739Methoden 739

XmlRoot 782XmlSerializer 594, 780XmlWriter (Klasse) 741

Methoden 746XPath 746

Achse 752Ausdruck 751auswerten 760kompilieren 759Kontextknoten 752Namespaces 762

XPathNavigator (Klasse) 746XPS-Dokumente 907XSD 705xsd.exe 1174

Y

Year 628yield 415yield return 417

Z

Zeicheneinfügen 624ersetzen 625

Zeichenfolge 608Zeichenfolgenverkettung 105Zeigerarithmetik 381Zeigerdeklaration 378Zeilenumbruch

automatisch 889manuell 889

Zugriffsmodifizierereiner Klasse 155internal 643public 643

Zuweisungsoperatoren 104
