lehrerbibliothek.deDatenschutzerklärung
Inside C# Objektorientiertes Programmieren mit C# und dem .NET Framework
Inside C#
Objektorientiertes Programmieren mit C# und dem .NET Framework




Tom Archer, Andrew Whitechapel

Microsoft Press
EAN: 9783860636695 (ISBN: 3-86063-669-3)
550 Seiten, paperback, 19 x 24cm, September, 2002, mit CD-ROM

EUR 49,90
alle Angaben ohne Gewähr

Umschlagtext
Microsofts neueste objektorientierte Sprache im Detail

Der umfassende Einstieg in die .NET-Programmierung mit C#



Wenn Sie zu den Programmierern gehören, die von einem C#-Buch nicht nur die Beschreibung der Syntax eines Sprachkonstrukts zusammen mit ein paar Implementierungsbeispielen erwarten, sondern gleichzeitig die größeren Zusammenhänge und die Interna verstehen wollen, ist dieses Buch genau das Richtige für Sie! Tom Archer und Andrew Whitechapel beschreiben in dieser 2., komplett überarbeiteten und auf den doppelten Umfang angewachsenen, Ausgabe von Inside C# diese Sprache unter den verschiedensten Gesichtspunkten. Warum und wie sollte man bestimmten Code verwenden? Der Code wird in der Regel auch auf der Ebene der MSIL (Intermediate Language) erklärt, sodass Sie einen Blick hinter die Kulissen der Implementierung der Features erhalten. Die Beispiele sind so weit wie möglich praxisnah und wieder verwertbar gehalten. Somit richtet sich das Buch an den in der Programmierung bereits erfahrenen Einsteiger in C#, bietet aber auch fundiertes Wissen für die bereits mit C# programmierenden Entwickler.



Lesen Sie:

- Grundlagen der C#-Klassen

- Das .NET-Typsystem

- Klassen und Strukturen

- Methoden, Propertys, Arrays und Indexer

- Attribute und Schnittstellen Codeentwicklung

- Ausdrücke und Operatoren

- Steuerung des Programmablaufs

- Stringbearbeitung und reguläre Ausdrücke

- Datei-E/A mit Streams

- Fehlerbehandlung mit Ausnahmen

- Operatorüberladung und benutzerdefinierte Konvertierungen

- Delegaten und Ereignishandler

- Dokumentation mit XML

- C# für Fortgeschrittene

- Numerische Rechenvorgänge und die Math-Klasse

- Auflistungen und die Objektenumeration

- Multithreading und asynchrone Programmierung

- Abfragen der Metadaten per Reflektion

- Fixierung und Speicherverwaltung

- Der Einsatz von COM in C#-Anwendungen

- Der Einsatz von .NET-Komponenten in unverwaltetem Code

- Sicherheit



Auf Begleit-CD:

- Beispielcode

- Deutsche und englische Version des Buches als Ebook

- .NET Framework SDK + Service Pack 1



Tom Archer kann auf 18 Jahre als Programmierer zurückblicken. Zur Zeit arbeitet er als Consultant für Firmen wie IBM, AT&T und Peachtree und hält Vorträge zu C# und .NET an Universitäten und in Firmen. Als Buchautor ist er durch vier Titel zu C++ und Webentwicklung bekannt. Andrew Whitechapel ist seit über 20 Jahren in der Software-Industrie tätig und arbeitet heute als Trainer und Consultant. Seit der Betaphase ist er in C#- und .NET-Projekten involviert.
Inhaltsverzeichnis
Vorwort XIX
Sicherung der Investitionen XX
Schrittweise Verbesserung XX
Durchdachte Innovation XXI

»Inside C#« XXII

Einführung XXIII
Warum ich dieses Buch geschrieben habe XXIII
Was ist in dieser Ausgabe neu? XXIII
Für wen ist dieses Buch gedacht? XXV
Aufbau des Buchs XXV
Teil I: Grundlagen der C#-Klassen XXV
Teil II: Codeentwicklung XXVI
Teil III: C# für Fortgeschrittene XXVII
Anhang: MSIL-Befehlstabelle XXVIII
Konventionen XXVIII
Kompilierung der Beispielprogramme XXIX
Die Begleit-CD XXX
Beispielcode im Web XXX
Anforderungen an das System XXX
Rückmeldungen und Kommentare XXXI
Support XXXI

Danksagungen XXXIII

Teil I
Grundlagen der C#-Klassen 1

1 Erstellung von C#-Anwendungen und Bibliotheken 3

»Hello, World« - die Befehlszeilenversion 4
Die Befehlszeilenversion des Compilers 4
»Hello, World« - der Code 7
Ganzheitliche Programmierung 7
Namespaces 7
Klassen und ihre Bestandteile (Member) 9
DieJMethode Main 10
Die Methode System.Console.WriteLine 10
Namespaces und die usmg-Direktive 10
Das Codegerüst 12,
Mehrdeutige Klassenangaben 1/2
»Hello, World« - die Visual Studio .NET-Version 13
Kompilierung und Ausführung von .NET-Anwendungen 16
»Hello, World« intern 18
Assemblys und Module 21
Assemblys - ein Überblick 21
Das Manifest 21
Vorteile von Assemblys 22
Assemblys als Verpackungseinheit 22
Verteilung und Installation 23
Versionierung der Assemblys 23
Erstellung von Assemblys 23
Erstellung von Assemblys mit mehreren Modulen 25
Erstellung von gemeinsam genutzten Assemblys 27
Der globale Assemblycache 29
Untersuchung des Caches 29
Zusammenfassung 31

2 Das .NET-Typsystem 33
Alles ist ein Objekt 34
Die Wurzel aller Typen: System.Object 35
Werttypen und Verweistypen 36
Werttypen 37
Verweistypen 37
Schachteln (Boxing) und Entschachteln (Unboxing) 38
Umwandlung von Werttypen in Verweistypen 38
Umwandlung von Verweistypen in Werttypen 39
Weitere Schachtelungsbeispiele 41
Typen und Aliase 45
Typkonvertierungen 46
Die Vorteile des CTS 48
Zusammenarbeit verschiedenster Sprachen 48
Objekthierarchie mit einer einzigen Wurzel 49
Typsicherheit 49
Zusammenfassung 50

3 Klassen und Strukturen 51
Die Definition von Klassen 52
Die Member einer Klasse 52
Zugriffsmodifizierer 54
Die Methode Main 55
Befehlszeilenargumente 55
Rückgabe von Werten aus Main 57
Mehrere Mam-Methoden 58
Konstruktoren 59
Statische Member und Instanzmember 61
Konstruktorinitialisierer 63
Angabe von Laufzeitinformationen in einem Konstruktorinitialisierer 67
Konstanten versus schreibgeschützte Felder 70
Konstanten 70
Schreibgeschützte Felder 72
Vererbung 75
Mehrere Schnittstellen 77
Versiegelte Klassen 78
Die Definition von Structs in C# 79
Der Umgang mit Structs 79
Richtlinien für den Umgang mit Structs 82
Zusammenfassung 84

4 Methoden 85
Wert- und Verweisparameter 86
ref-Methodenparameter 87
out-Methodenparameter 90
Wert- und Verweisparameter (noch einmal) 93
Die Überladung von Methoden 97
Überladung von Konstruktoren 99
Vererbung und Überladung 102
Variable Parameterlisten 103
Virtuelle Methoden 105
Überschreibung von Methoden 106
Polymorphie 107
new virtual-Methoden 113
Der Aufruf virtueller Methoden in Konstruktoren 115
Statische Methoden 117
Zugriff auf Klassenmember 118
Statische Konstruktoren 119
Zusammenfassung 121

5 Propertys, Arrays und Indexer 123
Propertys als »schlaue Felder« 124
Definition und Einsatz von Propertys 125
Propertys intern 127
Vererbung von Propertys 131
Überschreibung geerbter Propertys 131
Vorgabe der Propertyimplementierung durch abstrakte Propertys 132
Propertys für Fortgeschrittene 135
Arrays 136
Die Deklaration von Arrays 136
Ein eindimensionales Beispiel 137
Mehrdimensionale Arrays 138
Abfrage des Rangs 140
Verzweigte (unregelmäßige) Arrays 141
Indexer 143
Die Definition von Indexern 144
Ein Indexer-Beispiel 145
Indexer intern 147
Hinweise für die Anwendung von Indexern 148
Zusammenfassung 149

6 Attribute 151
Was sind Attribute? 152
Definition von Attributen 153
Die Abfrage von Attributen 156
Klassenattribute 157
Methodenattribute 159
Feldattribute 161
Attributparameter 162
Positionelle Parameter und benannte Parameter 162
Häufige Fehler mit benannten Parametern 164
Zulässige Typen für Attributparameter 165
Das Attribut AttributeUsage 165
Definition des Attributziels 166
Einfache und mehrfache Angabe von Attributen 167
Die Angabe von Vererbungsregeln für Attribute 168
Attributidentifizierer 170
Vordefinierte Attribute 172
Das Attribut Conditional 173
Das Attribut Obsolete 175
Das Attribut CLSCompliant 176
Die Attribute Dlllmport und StructLayout 177
Assemblyattribute 179
Kontextattribute 180
Zusammenfassung 186

7 Schnittstellen 187
Wofür braucht man Schnittstellen? 188
Die Deklaration von Schnittstellen 189
Die Implementierung von Schnittstellen 190
Die Abfrage der Implementierung mit is 192
Die Abfrage der Implementierung mit äs 195
Schnittstellen und die Alternativen 198
Vollständige Namensangabe 200
Verbergen der Namen durch Schnittstellen 200
Vermeidung von Mehrdeutigkeiten 202
Schnittstellen und Vererbung 207
Zusammenfassung von Schnittstellen 210
Zusammenfassung 211

Teil II
Codeentwicklung 213

8 Ausdrücke und Operatoren 215

Was sind Operatoren? 215
Vorrangregelung für Operatoren 216
Die Rangordnung der Operatoren 217
Links- und Rechtsassoziativität 217
Praktische Anwendung 218
C#-Operatoren 219
Primäre Ausdrücke 219
typeof 219
sizeof 221
checked und unchecked 223
Mathematische Operatoren 223
Unäre Operatoren 224
Zusammengesetzte Zuweisungsoperatoren 226
Inkrement- und Dekrementoperatoren 231
Numerische Konvertierungen 233
checked- und unchecked-Kontexte 235
Bitoperatoren 236
Relationale Operatoren 239
Vergleichsoperatoren 239
Einfache Zuweisungsoperatoren 241
Der Bedingungsoperator 244
Zusammenfassung 246

9 Steuerung des Programmablaufs 247
Auswahlanweisungen 247
Die if-Anweisung 248
Mehrfache else-Klauseln 249
So sorgt C# für die Einhaltung der if-Regeln 250
Die switch-Anweisung 253
Zusammenfassung mehrerer case-Marken 256
Kein Durchfallen in switch-Anweisungen 258
Wiederholungsanweisungen 260
Die while-Anweisung 260
Die do/while-Anweisung 261
Die for-Anweisung 263
Verschachtelte Schleifen 264
Der Kommaoperator 265
Die foreach-Anweisung 267
Sprunganweisungen 270
Die break-Anweisung 270
Der Abbruch unendlicher Schleifen 271
Die confinue-Anweisung 272
Das berühmt-berüchtigte goto 274
Eine (sehr) kurze Historie 274
Anwendung der goto-Anweisung 275
Die return-Anweisung 279
Zusammenfassung 280

10 Stringbearbeitung und reguläre Ausdrücke 281
Strings 281
Stringformatierung 284
Formatbezeichner 286
Objekte und ToString 288
Die Umwandlung von Text in Zahlen 289
Strings und DateTime 291
Zeichenkodierung von Strings 293
Die Klasse StringBuilder 295
Aufteilung von Strings 295
Erweiterung der Sfrmg-Klasse 297
String-Interning 298
Reguläre Ausdrücke 300
Match und MatchCollection 304
Gruppen und Aufzeichnungen 307
Ausdrücke, die Zeichenfolgen ändern 309
Optionen für reguläre Ausdrücke 312
Die Kompilierung regulärer Ausdrücke 313
Zusammenfassung 315

11 Datei-E/A mit Streams 317
Streamklassen 317
FileStream 319
StreamReader und StreamWriter 322
MemoryStream und BufferedStream 323
StringReader und StringWriter 326
BinaryReader und BinaryWriter 328
Dateisystemklassen 330
Directory und Directoryinfo 331
File und Fileinfo 333
Pfade analysieren 334
Weitere Anwendungsbereiche für Streams 335
Windows OpenFileDialog 335
Einlesen von Webseiten 337
Serialisierung 338
Serialisierung mit Binary'Formatter 339
Serialisierung mit SoapFormatter 342
Serialisierung mit XmlSerializer 343
Implementierung der Schnittstelle ISerializable 345
Zusammenfassung 348

12 Fehlerbehandlung mit Ausnahmen 349
Ein Überblick über die Ausnahmebehandlung 350
Die Syntax zur Bearbeitung von Ausnahmen 351
Eine Ausnahme auslösen 351
Abfangen einer Ausnahme 352
Weiterleitung (re-throw) einer Ausnahme 354
Aufräumen mit finally 356
Vom catch-Block in den try-Block? 359
Vergleich der Ausnahmebehandlungsmethoden 361
Vorteile von Ausnahmen gegenüber Rückgabewerten 361
Die Behandlung von Fehlern im richtigen Kontext 363
Verbesserte Lesbarkeit des Codes 364
Auslösen von Ausnahmen in Konstruktoren 365
Die Klasse System.Exception 366
Konstruktion eines Exception-Objekts 366
Die Property StackTrace 369
Bearbeitung mehrerer verschiedener Ausnahmearten 370
Ableitung eigener Exception-Klassen 371
Entwurf des Codes mit Ausnahmebehandlung 372
Anmerkungen zum try-ßlock 373
Anmerkungen zum catch-Block 376
Zusammenfassung 378

13 Operatorüberladung und benutzerdefinierte Konvertierungen 379
Überladung von Operatoren 379
Die Syntax für die Operatorenüberladung 380
Regeln und Beschränkungen 381
Beispiele 382
Beispiel Invoice-Aggregation 382
RGB-Farbinkrementierung 384
Entwurfsrichtlinien 388
Wann soll man Operatoren überladen? 388
Kombination verschiedener Programmiersprachen 389
Benutzerdefinierte Konvertierungen 390
Die Syntax 390
Regeln und Beschränkungen 391
Beispiele 391
Entwicklung einer Komponente mit drei Zuständen 395
Explizite Konvertierungen für die Tristate-Komponente 400
Zusammenfassung 401

14 Delegaten und Ereignishandler 403
Delegaten als Rückrufmethoden 403
Delegaten intern 406
Delegaten als statische Member definieren 409
Erstellung der Delegaten nur bei Bedarf 412
Multicast-Delegaten 414
Warum gibt es Multicast-Delegaten? 418
Definition von Ereignissen mit Delegaten 420
Zusammenfassung 424

15 Dokumentation mit XML 425
Der Einstieg 425
Aufnahme neuer Elemente 428
Zulässige Codekonstrukte 428
Vom Compiler generierte Element-IDs 429
Felder, Propertys, Ereignisse und Indexer 429
Methoden 431
Wohlgeformtes XML 435
Kommentarwebseiten 437
Elementtags und Attribute 438
Das Tag und das Attribut cref 439
Die Tags , und 439
Das Tag 441
Das Tag 443
Benutzerdefinierte Formatierung 443
XML und Daten 446
Zusammenfassung 448

Teil III
C# für Fortgeschrittene 449

16 Numerische Rechenvorgänge und die Math-Klasse 451

Zahlen in C# und .NET 451
Ist der Decimal-Typ ein Grundtyp? 452
Suffixe für numerische Literale 454
Ein numerischer Typ, wenn er auch anders heißt 454
Mehr über numerische Literale 455
Wertebereich und Überlauf 458
Der Typ Decimal 462
Die Klasse System.Math 462
System.Math-Konstanten 462
Zahlen und Vorzeichen 463
Minimum- und Maximumwerte 463
Rundung 464
Zusammenfassung 464

17 Auflistungen und die Objektenumeration 465
Die Schnittstelle lEnumerable 465
Benutzung eines Enumeratorobjekts 469
Die Aufzählung von Auflistungen mit der foreach-Anweisung 470
Zwei Schnittstellen zum Preis von einer 472
Erstellung des Enumeratorobjekts 472
Enumeratoren mit Versionsnummern 473
Kombination von IEnumerable und IEnumerator 476
Schutz der Daten bei der Aufzählung 478
Werttypen 480
Leistungsprobleme 481
Änderung von Werttypen in Auflistungen 488
Zusammenfassung 491

18 Multithreading und asynchrone Programmierung 493
Der Einstieg in Threads 493
Die Klasse Thread 495
Erstellung von Threads und Thread-Ob]ekten 495
Verwaltung der Threadlebensdauer 495
Entsorgung von Threads 496
Prioritätszuweisung an Threads 499
Übergabe von Daten an einen Thread 503
Threadsicherheit und Synchronisation 505
Schutz von Codeblöcken mit der Klasse Monitor 505
Die lock-Anweisung von C# 510
Synchronisation mit der Mutex-Klasse 512
Asynchrone Methodenaufrufe mit Delegaten 513
Threadsicherheit und die .NET-Klassen 518
Richtlinien für den Einsatz von Threads 518
Wann sind Threads von Nutzen? 518
Mehrere Vorgänge sollen parallel ablaufen 518
Vereinfachtes Design 519
Bessere Nutzung der CPU-Zeit 519
Wann schaden Threads? 519
Die Kosten überwiegen die Vorteile 519
Sie haben nicht beide Alternativen überprüft 519
Es gibt einfach keinen guten Grund 520
Zusammenfassung 520

19 Abfrage der Metadaten per Reflektion 521
Die Hierarchie der Reflektions-API 521
Die Klasse Type 522
Beschaffung eines Type-Verweises 522
Beschaffung des Type-Objekts anhand einer Instanz 523
Beschaffung des Type-Objekts anhand des Typnamens 523
Abfrage der Typen 524
Die Untersuchung von Assemblys und Modulen 526
Untersuchung der Typen einer Assembly 526
Auflistung der Module einer Assembly 531
Späte Bindung mit Reflektion 532
Implementierung einer abstrakten Factory 534
Dynamische Codeerzeugung 536
Zusammenfassung 539

20 Fixierung und Speicherverwaltung 541
Garbage Collection 542
Überschreibung von Finalize 543
Überschreibung von Finalize in abgeleiteten Klassen 546
Explizite Garbage Collection 548
Das Dispose-Muster 550
Andere Features der GC-Klasse 552
Die IDisposable-Schnittstelle 553
Abgeleitete Klassen mit IDisposable-Implementierung 555
Schutz vor doppelten Dispose-Aufrufen 556
Die Sprachunterstützung für Dispose 558
Garbage Collector-Generationen 559
Schwache Verweise 560
Unsicherer Code 562
Zeiger in C# 563
Fixierung 566
Fixierung von Arrayelementen 568
Memberdereferenzierung 571
stackalloc 572
Zusammenfassung 574

21 Der Einsatz von COM in C#-Anwendungen 575
COM und die .NET-Welt 576
COM-Komponenten in C# 577
Erstellung der ATL-Komponente 577
Einbindung einer COM-Komponente in eine .NET-Anwendung 578
Bindung und Aufruf der COM-Komponente 580
Dynamische Typermittlung in COM-Komponenten 582
Späte Bindung an COM-Objekte 583
Bearbeitung von Ereignissen 584
So funktionieren COM-Verbindungspunkte 585
Erstellung einer ATL-COM-Komponente, die Ereignisse meldet 586
Ereignisbehandlung mit Delegaten 588
COM-Ereignismeldungen in .NET-Anwendungen 590
COM-Auflistungen 593
Erstellung einer COM-Auflistungskomponente mit ATL 593
Der Einsatz von COM-Auflistungen in einer .NET-Anwendung 597
Enumeration der Elemente aus einer .NET-Auflistung 599
Wiederverwendung von COM-Komponenten in verwaltetem Code 600
Containment 601
Aggregation 601
Wiederverwendung durch Vererbung (Mischmodus) 602
Wiederverwendung durch Containment (Mischmodus) 605
COM-Threadmodelle und Apartments aus .NET-Sicht 606
Die Abbildung von Methodenschlüsselwörtern auf IDL-Attribute 607
Zusammenfassung 608

22 Der Einsatz von .NET-Komponenten in unverwaltetem Code 611
Erstellung und Einsatz von .NET-Objekten über COM 611
Ableitung der Typbibliothek aus der Assembly und Registrierung der Assembly 613
Konsum der Komponente in einem Visual Basic 6-Client 613
Die Tiefen der COM-Interop-Schicht 615
Untersuchung der generierten Typbibliothek 616
Weitere Attribute 622
Wahl der Schnittstellenart 622
Änderung der GUID und der ProgID 624
Öffentliche Typen vor COM verbergen 625
Änderung des Marshaling-Verhaltens von Typen 626
Ausnahmebehandlung: .NET versus COM 626
Die Behandlung von .NET-Ereignismeldungen in unverwaltetem Code 628
Erstellung einer .NET-Komponente, die Ereignisse meldet 629
Ereignisbehandlung in einem Visual Basic-Client 631
Threadaffinität in .NET-Komponenten 632
Threadneutrales Verhalten bei Zugriffen durch unverwaltete COM-Clients 633
Zusammenfassung 636

23 Sicherheit 637
.NET-Sicherheit 637
Gefahren für die Sicherheit 638
Überprüfbare Typsicherheit 640
Codesignatur 644
Private Assemblys 644
Assemblys mit starken Namen 646
Der globale Assemblycache 651
Assemblys mit verzögerter Signatur 653
Kryptographiedienste 654
Codezugriffssicherheit 657
Beweise 657
Sicherheitsrichtlinien 658
Konfiguration der Sicherheit 662
CASpol 670
Imperative und deklarative CAS 672
Identitätsrechte 673
Anforderung von Assemblyrechten 675
Sicherheit auf Rollenbasis 677
PrincipalPermission-Anforderungen 678
Identitätswechsel 679
Isolierter Speicher 680
Zusammenfassung 681

Anhang A: Tabelle der MSIL-Befehle 683

Stichwortverzeichnis 695

Die Autoren 717