C# 6.0 - kurz & gut (eBook)

eBook Download: PDF | EPUB
2016 | 4. Auflage
232 Seiten
O'Reilly Verlag
978-3-96010-046-1 (ISBN)

Lese- und Medienproben

C# 6.0 - kurz & gut -  Joseph Albahari,  Ben Albahari
Systemvoraussetzungen
Systemvoraussetzungen
14,90 inkl. MwSt
  • Download sofort lieferbar
  • Zahlungsarten anzeigen
Dieses Buch ist für vielbeschäftigte Programmierer gedacht, die eine knappe, aber dennoch gut verständliche Beschreibung von C# 6.0 suchen. C# 6.0 - kurz & gut informiert Sie über genau das, was Sie wissen müssen, um schnell durchstarten zu können. Behandelt werden: - alle Aspekte der C#-Syntax, vordefinierte Typen, Ausdrücke und Operatoren - das Erstellen von Klassen, Structs, Delegates und Events, Enums, Generics und Constraints, Exception Handling und Iteratoren - die Feinheiten des Boxing, das Überladen von Operatoren, Lambda-Ausdrücke, die Delegate-Kovarianz oder das Auflösen von Erweiterungsmethoden - dynamische Bindung und asynchrone Funktionen - LINQ - von den Standard-Abfrageoperatoren bis zu einer vollständigen Referenz der Query-Syntax Trotz seines erstaunlich kompakten Formats bietet dieses Buch eine Fülle von Details. Es unterstützt Sie optimal, die konzeptionellen Herausforderungen beim Lernen von C# 6.0 schnell zu meistern. Wenn Sie bereits mit Java, C++ oder einer älteren Version von C# vertraut sind, ist C# 6.0 - kurz & gut die ideale Wahl.

Joseph Albahari entwirft Enterprise-Anwendungen auf .NET und auf anderen Plattformen und hat in der Telekommunikation sowie im Gesundheits- und im Bildungswesen gearbeitet. Neben einer Reihe von O'Reilly-Büchern hat er auch LINQPad, das beliebten Query-Tool für LINQ, geschrieben. Ben Albahari war Programm-Manager bei Microsoft und ist der Gründer von takeonit.com. Er ist auch Mitbegründer der Firma Genamics, einem Tools-Anbieter für C#- und J++-Programmierer, der Software für DNA- und Proteinsequenz-Analysen entwickelt.

Joseph Albahari entwirft Enterprise-Anwendungen auf .NET und auf anderen Plattformen und hat in der Telekommunikation sowie im Gesundheits- und im Bildungswesen gearbeitet. Neben einer Reihe von O'Reilly-Büchern hat er auch LINQPad, das beliebten Query-Tool für LINQ, geschrieben. Ben Albahari war Programm-Manager bei Microsoft und ist der Gründer von takeonit.com. Er ist auch Mitbegründer der Firma Genamics, einem Tools-Anbieter für C#- und J++-Programmierer, der Software für DNA- und Proteinsequenz-Analysen entwickelt.

Inhalt 4
C# 6.0 – kurz & gut
Ein erstes C#-Programm 7
Kompilation 9
Syntax 10
Bezeichner und Schlüsselwörter 11
Konflikte vermeiden 12
Kontextuelle Schlüsselwörter 12
Literale, Satzzeichen und Operatoren 13
Kommentare 13
Typgrundlagen 14
Vordefinierte Typen 14
Benutzerdefinierte Typen 15
Member eines Typs 16
Symmetrie vordefinierter und benutzerdefinierter Typen 16
Konstruktoren und Instanziierung 17
Instanz-Member versus statische Member 17
Das Schlüsselwort public 18
Umwandlungen 18
Werttypen vs. Referenztypen 19
Werttypen 19
Referenztypen 20
Null 22
Die Einteilung der vordefinierten Typen 23
Numerische Typen 24
Numerische Literale 25
Typableitung bei numerischen Literalen 25
Numerische Suffixe 25
Numerische Umwandlung 26
Ganzzahlige Umwandlungen 26
Reelle Umwandlungen 26
Reelle Typen in ganzzahlige Typen umwandeln 26
Arithmetische Operatoren 27
Inkrement- und Dekrementoperatoren 27
Besondere integrale Operationen 27
Ganzzahlige Division 27
Ganzzahlüberlauf 28
Die Operatoren checked und unchecked 28
Bitoperatoren 29
8- und 16-Bit-Ganzzahlwerte 29
Spezielle Float- und Double-Werte 29
double vs. decimal 30
Rundungsfehler bei reellen Zahlen 31
Der Typ bool und die booleschen Operatoren 31
Gleichheits- und Vergleichsoperatoren 32
Bedingungsoperatoren 32
Strings und Zeichen 33
String-Typ 34
String-Verkettung 35
String-Interpolation (C# 6) 36
String-Vergleiche 36
In Strings suchen 37
Strings verändern 37
Arrays 37
Standard-Elementinitialisierung 39
Mehrdimensionale Arrays 39
Rechteckige Arrays 40
Ungleichförmige Arrays 40
Vereinfachter Array-Initialisierungsausdruck 41
Variablen und Parameter 42
Der Stack und der Heap 42
Stack 42
Heap 42
Sichere Zuweisung 43
Vorgabewerte 44
Parameter 44
Argumente als Wert übergeben 45
Der Modifikator ref 46
Der Modifikator out 46
Der Modifikator params 47
Optionale Parameter 47
Benannte Argumente 48
var & ndash
Ausdrücke und Operatoren 50
Zuweisungsausdrücke 51
Priorität und Assoziativität von Operatoren 51
Priorität 51
Linksassoziative Operatoren 52
Rechtsassoziative Operatoren 52
Operatorentabelle 52
Null-Operatoren 55
Null-Verbindungsoperator 56
Null-Bedingungsoperator (C# 6) 56
Anweisungen 57
Deklarationsanweisungen 58
Variablen mit lokaler Geltung 58
Ausdrucksanweisungen 58
Auswahlanweisungen 59
Die if-Anweisung 59
Die else-Klausel 59
Änderung des Programmflusses durch geschweifte Klammern 59
Die switch-Anweisung 60
Iterationsanweisungen 62
while- und do-while-Schleifen 62
for-Schleifen 63
foreach-Schleifen 63
Sprunganweisungen 64
Die break-Anweisung 64
Die continue-Anweisung 64
Die goto-Anweisung 65
Die return-Anweisung 65
Namensräume 65
Die using-Direktive 67
using static (C# 6) 67
Regeln in einem Namensraum 68
Geltung von Namen 68
Namen verdecken 69
Wiederholte Namensräume 69
Der Qualifizierer global:: 69
Aliase für Typen und Namensräume 69
Klassen 70
Felder 70
Methoden 71
Expression-bodied Methoden (C# 6) 71
Methoden überladen 72
Instanzkonstruktoren 72
Implizite parameterlose Konstruktoren 73
Nicht öffentliche Konstruktoren 73
Objektinitialisierer 73
Die Referenz this 74
Eigenschaften 75
Expression-bodied Eigenschaften (C# 6) 76
Automatische Eigenschaften 76
Eigenschaftsinitialisierer (C# 6) 77
Sichtbarkeit von get und set 77
Indexer 78
Implementieren eines Indexers 78
Konstanten 79
Statische Konstruktoren 80
Statische Klassen 80
Finalizer 81
Partielle Typen und Methoden 81
Partielle Methoden 82
Der Operator nameof (C# 6) 82
Vererbung 83
Polymorphie 84
Casting und Referenzumwandlungen 84
Upcasting 85
Downcasting 85
Der as-Operator 86
Der is-Operator 86
Virtuelle Funktions-Member 87
Abstrakte Klassen und abstrakte Member 88
Verbergen geerbter Member 88
Funktionen und Klassen versiegeln 89
Das Schlüsselwort base 89
Konstruktoren und Vererbung 90
Reihenfolge von Konstruktor- und Feld-Initialisierung 91
Auflösen beim Überladen 91
Der Typ object 92
Boxing und Unboxing 93
Statische und Laufzeit-Typprüfung 94
Die GetType-Methode und der typeof-Operator 94
Die Member von object 95
Equals, ReferenceEquals und GetHashCode 95
Die ToString-Methode 96
Structs 96
Semantik beim Erzeugen eines Struct 97
Zugriffsmodifikatoren 97
Friend Assemblies 98
Beschneiden der Sichtbarkeit 99
Interfaces 99
Erweitern eines Interface 100
Explizite Implementierung eines Interface 100
Virtuelles Implementieren von Interface-Membern 101
Reimplementieren eines Interface in einer Subklasse 102
Enums 103
Enum-Konvertierungen 103
Flag-Enums 104
Enum-Operatoren 105
Eingebettete Typen 105
Generics 106
Generische Typen 106
Generische Methoden 108
Deklarieren generischer Parameter 109
typeof und ungebundene generische Typen 109
Der generische Wert default 110
Generische Constraints 110
Erstellen abgeleiteter Klassen von generischen Typen 111
Selbstreferenzielle generische Deklarationen 112
Statische Daten 112
Kovarianz 113
Kontravarianz 115
Delegates 115
Schreiben von Plug-in-Methoden mit Delegates 116
Multicast-Delegates 117
Instanzmethoden versus statische Methoden als Ziele 118
Generische Delegate-Typen 118
Die Func- und Action-Delegates 119
Delegate-Kompatibilität 119
Rückgabetypvarianz 120
Parametervarianz 120
Typparametervarianz bei generischen Delegates 121
Events 122
Standard-Event-Muster 124
Event-Accessors 127
Lambda-Ausdrücke 128
Äußere Variablen übernehmen 130
Iterationsvariablen übernehmen 131
Anonyme Methoden 132
try-Anweisungen und Exceptions 133
Die catch-Klausel 135
Exception-Filter (C# 6) 136
Der finally-Block 137
Die using-Anweisung 138
Werfen von Exceptions 138
Eine Exception weiterwerfen 139
Wichtige Eigenschaften von System.Exception 140
Die wichtigsten Exception-Typen 140
Enumeration und Iteratoren 141
Enumeration 141
Collection-Initialisierer 142
Iteratoren 143
Iteratorsemantik 145
Mehrere yield-Anweisungen 145
yield break 146
Sequenzen kombinieren 146
Nullbare Typen 147
Das Struct Nullable 148
Nullbare Konvertierungen 148
Boxing/Unboxing nullbarer Werte 149
Übernommene Operatoren 149
Gleichheitsoperatoren (==, !=) 150
Relationale Operatoren (=, > )
Alle anderen Operatoren (+, & ndash
Mischen von nullbaren und nicht nullbaren Typen 151
bool? mit den Operatoren & amp
Nullbare Typen und Null-Operatoren 152
Überladen von Operatoren 152
Operatorfunktion 153
Überladen von Gleichheits- und Vergleichsoperatoren 154
Eigene implizite und explizite Konvertierungen 155
Erweiterungsmethoden 156
Verketten von Erweiterungsmethoden 156
Mehrdeutigkeit und Auflösung 157
Namensräume 157
Erweiterungsmethoden vs. Instanzmethoden 157
Erweiterungsmethoden vs. Erweiterungsmethoden 157
Anonyme Typen 158
LINQ 158
Grundlagen von LINQ 159
Eine einfache Abfrage 160
Projizieren 161
Take und Skip 161
Elementoperatoren 162
Aggregationsoperatoren 162
Quantifizierer 163
Mengenoperatoren 163
Verzögerte Ausführung 163
Standard-Abfrageoperatoren 165
Abfrageoperatoren verketten 169
Abfrageausdrücke 170
Abfrageausdrücke vs. fließende Syntax 172
Das Schlüsselwort let 173
Abfragefortsetzungen 174
Mehrere Generatoren 175
Verknüpfen 176
GroupJoin 178
Zip 179
Ordnen 180
Gruppieren 181
OfType und Cast 183
Die dynamische Bindung 183
Statische Bindung vs. dynamische Bindung 184
Benutzerdefinierte Bindung 185
Sprachbindung 186
RuntimeBinderException 188
Laufzeitdarstellung von dynamic 188
Dynamische Konvertierungen 189
var vs. dynamic 189
Dynamische Ausdrücke 190
Die dynamische Auflösung überladener Member 190
Nicht aufrufbare Funktionen 192
Attribute 193
Attributklassen 193
Benannte und positionelle Attributparameter 194
Attributziele 194
Angeben mehrerer Attribute 194
Schreiben eigener Attribute 195
Auslesen von Attributen zur Laufzeit 196
Aufrufer-Info-Attribute 197
Asynchrone Funktionen 198
Die Schlüsselwörter await und async 200
Lokale Zustände einfangen 203
Asynchrone Funktionen schreiben 203
Task zurückliefern 204
Parallelität 206
Asynchrone Lambda-Ausdrücke 207
Unsicherer Code und Zeiger 208
Zeigergrundlagen 208
Unsicherer Code 208
Die Anweisung fixed 209
Der Zeiger-auf-Member-Operator 210
Arrays 210
Das Schlüsselwort stackalloc keyword 210
Puffer fester Größe 211
void* 211
Präprozessordirektiven 212
Warnungen 214
XML-Dokumentation 215
Standard-XML-Dokumentations-Tags 216
Index 220
www.oreilly.de 0

Generics


C# verfügt über zwei separate Mechanismen, um Code zu schreiben, der mit verschiedenen Typen verwendbar ist: Vererbung und Generics. Während bei der Vererbung die Wiederverwendbarkeit durch einen Basistyp ausgedrückt wird, geschieht dies bei Generics durch ein »Template«, das Typen als »Platzhalter« enthält. Generics können im Vergleich zur Vererbung die Typsicherheit erhöhen und für weniger Casting und Boxing sorgen.

Generische Typen

Ein generischer Typ deklariert Typparameter – Platzhaltertypen, die vom Anwender des generischen Typs gefüllt werden, indem er die Typargumente bereitstellt. Hier wurde ein generischer Typ Stack<T> entworfen, der Instanzen vom Typ T auf einem Stack verwalten soll. Stack<T> deklariert einen einzelnen Typparameter T:

public class Stack<T>
{
  int position;
  T[] data = new T[100];
  public void Push (T obj) => data[position++] = obj;
  public T Pop()           => data[--position];
}

Wir können Stack<T> so nutzen:

var stack = new Stack<int>();
stack.Push(5);
stack.Push(10);
int x = stack.Pop();        // x ist 10
int y = stack.Pop();        // y ist 5

Beachten Sie, dass in den beiden letzten Zeilen keine Downcasts erforderlich sind, was das Risiko eines Laufzeitfehlers und den Overhead der Boxing/Unboxing-Operationen vermeidet. Das macht unseren generischen Stack einem nichtgenerischen Stack überlegen, der object anstelle von T nutzt (ein Beispiel finden Sie unter »Der Typ object« auf Seite 87).

Stack<int> gibt für den Typparameter T das Typargument int vor, wodurch implizit ein Typ erstellt wird (die Synthese geschieht zur Laufzeit). Stack<int> hat im Endeffekt folgende Definition (die Ersetzungen sind hervorgehoben und der Klassenname wurde durch ### ersetzt, um Verwirrung zu vermeiden):

public class ###
{
  int position;
  int[] data;
  public void Push (int obj) => data[position++] = obj;
  public int Pop()           => data[--position];
}

Technisch ausgedrückt, ist Stack<T> ein offener Typ, Stack<int> dagegen ein geschlossener Typ. Zur Laufzeit sind alle Instanzen generischer Typen geschlossen – ihre Typplatzhalter sind gefüllt.

Generische Methoden

Eine generische Methode deklariert Typparameter innerhalb ihrer Signatur. Mit generischen Methoden können viele grundlegende Algorithmen sehr allgemein implementiert werden. Hier sehen Sie eine generische Methode, die zwei Werte eines beliebigen Typs T vertauscht:

static void Swap<T> (ref T a, ref T b)
{
  T temp = a; a = b; b = temp;
}

Swap<T> kann wie folgt verwendet werden:

int x = 5, y = 10;
Swap (ref x, ref y);

Im Allgemeinen ist es nicht notwendig, Typargumente an eine generische Methode zu übergeben, da der Compiler den Typ implizit ermitteln kann. Würde das zu einer Mehrdeutigkeit führen, können generische Methoden mit dem Typargument aufgerufen werden:

Swap<int> (ref x, ref y);

Innerhalb eines generischen Typs ist eine Methode so lange nichtgenerisch, wie sie nicht selbst Typparameter einführt (mit den spitzen Klammern). In unserem generischen Stack nutzt die Methode Pop nur den schon im Typ bestehenden Typparameter T und ist daher nicht als generische Methode klassifiziert.

Methoden und Typen sind die einzigen Konstrukte, die Typparameter einführen können. Eigenschaften, Indexer, Events, Felder, Operatoren und so weiter können keine Typparameter deklarieren, auch wenn sie die Typparameter verwenden können, die vom umhüllenden Typ deklariert wurden. In unserem Beispiel mit dem generischen Stack könnten wir zum Beispiel einen Indexer schreiben, der ein generisches Element zurückgibt:

public T this [int index] { get { return data[index]; } }

Auch Konstruktoren können nur die vorhandenen Typparameter nutzt, aber nicht selbst welche einführen.

Deklarieren generischer Parameter

Typparameter können bei der Deklaration von Klassen, Structs, Interfaces, Delegates (siehe »Delegates« auf Seite 110) und Methoden eingeführt werden. Ein generischer Typ bzw. eine generische Methode kann mehrere Typparameter haben:

class Dictionary<TKey, TValue> {...}

Die Instanziierung erfolgt folgendermaßen:

var myDic = new Dictionary<int,string>();

Generische Typnamen und Methodennamen können überladen werden, solange sich die Anzahl der Typparameter unterscheidet. So kommen zum Beispiel die folgenden drei Typnamen nicht miteinander in Konflikt:

class A {}
class A<T> {}
class A<T1,T2> {}

Es ist üblich, bei generischen Typen und Methoden mit einem einzelnen Typparameter diesen Parameter T zu nennen, solange der Sinn des Parameters klar ist. Bei mehreren Typparametern beginnt jeder Parameter mit T, hat aber einen stärker beschreibenden Namen.

typeof und ungebundene generische Typen

Zur Laufzeit gibt es keine offenen generischen Typen: Offene generische Typen werden bei der Kompilation geschlossen. Aber es kann zur Laufzeit ungebundene generische Typen geben – nur als Type-Objekt. Einen ungebundenen generischen Typ können Sie in C# nur mit dem typeof-Operator angeben:

class A<T> {}
class A<T1,T2> {}
...

Type a1 = typeof (A<>);   // Ungebundener Typ
Type a2 = typeof (A<,>);  // Zeigt 2 Typargumente an
Console.Write (a2.GetGenericArguments().Count());  // 2

Sie können den typeof-Operator nutzen, um einen geschlossenen Typ anzugeben

Type a3 = typeof (A<int,int>);

oder einen offenen Typ (der zur Laufzeit geschlossen ist):

class B<T> { void X() { Type t = typeof (T); } }

Der generische Wert default

Das Schlüsselwort default kann genutzt werden, um den Standardwert für einen angegebenen generischen Typparameter zu erhalten. Der Standardwert für einen Referenztyp ist null, der für Werttypen ist das Ergebnis eines bitweisen Löschens der Felder des Typs:

static void Zap<T> (T[] array)
{
  for (int i = 0; i < array.Length; i++)
    array[i] = default(T);
}

Generische Constraints

Standardmäßig kann ein Typparameter durch jeden beliebigen Typ ersetzt werden. Constraints können auf einen Typparameter angewandt werden, um spezifischere Typargumente zu verlangen. Es gibt sechs Arten von Constraints:

where T : Basisklasse   // Basisklassen-Constraint
where T : Interface     // Interface-Constraint
where T : class         // Referenztyp-Constraint
where T : struct        // Werttyp-Constraint
where T : new()         // Parameterloser Konstruktor
                        // Constraint
where U : T             // Typ-Constraint

Im folgenden Beispiel verlangt GenericClass<T,U>, dass T von SomeClass abgeleitet ist (oder der Klasse selbst entspricht) und Interface1 implementiert, und verlangt außerdem, dass U einen parameterlosen Konstruktor anbietet:

class     SomeClass {}
interface Interface1 {}

class GenericClass<T,U> where T : SomeClass, Interface1
                        where U : new()
{ ... }

Constraints können überall dort angewendet werden, wo generische Parameter definiert sind, sowohl in Methoden als auch in Typdefinitionen.

Ein Basisklassen-Constraint verlangt, dass der Typparameter eine Subklasse einer bestimmten Klasse sein muss (oder die Klasse selbst); ein Interface-Constraint fordert, dass der Typparameter dieses Interface implementieren muss. Diese Constraints gestatten es, dass Instanzen des Typparameters implizit in diese Klasse oder dieses Interface umgewandelt werden.

Der class-Constraint und der struct-Constraint erfordern, dass T ein Referenztyp beziehungsweise ein (nicht nullbarer) Werttyp ist. Der parameterlose Konstruktor-Constraint erfordert, dass T einen...

Erscheint lt. Verlag 7.7.2016
Reihe/Serie O'Reilly`s kurz & gut
Übersetzer Thomas Demmig
Verlagsort Heidelberg
Sprache deutsch
Themenwelt Informatik Programmiersprachen / -werkzeuge C#
Schlagworte C# • C# 6.0 • C Sharp • CSharp • LINQ • LINQPad • .NET • .NET Framework • NET Framework 4.6 • Programmiersprache • Programmierung • Visual Studio
ISBN-10 3-96010-046-9 / 3960100469
ISBN-13 978-3-96010-046-1 / 9783960100461
Haben Sie eine Frage zum Produkt?
PDFPDF (Wasserzeichen)
Größe: 1,1 MB

DRM: Digitales Wasserzeichen
Dieses eBook enthält ein digitales Wasser­zeichen und ist damit für Sie persona­lisiert. Bei einer missbräuch­lichen Weiter­gabe des eBooks an Dritte ist eine Rück­ver­folgung an die Quelle möglich.

Dateiformat: PDF (Portable Document Format)
Mit einem festen Seiten­layout eignet sich die PDF besonders für Fach­bücher mit Spalten, Tabellen und Abbild­ungen. Eine PDF kann auf fast allen Geräten ange­zeigt werden, ist aber für kleine Displays (Smart­phone, eReader) nur einge­schränkt geeignet.

Systemvoraussetzungen:
PC/Mac: Mit einem PC oder Mac können Sie dieses eBook lesen. Sie benötigen dafür einen PDF-Viewer - z.B. den Adobe Reader oder Adobe Digital Editions.
eReader: Dieses eBook kann mit (fast) allen eBook-Readern gelesen werden. Mit dem amazon-Kindle ist es aber nicht kompatibel.
Smartphone/Tablet: Egal ob Apple oder Android, dieses eBook können Sie lesen. Sie benötigen dafür einen PDF-Viewer - z.B. die kostenlose Adobe Digital Editions-App.

Zusätzliches Feature: Online Lesen
Dieses eBook können Sie zusätzlich zum Download auch online im Webbrowser lesen.

Buying eBooks from abroad
For tax law reasons we can sell eBooks just within Germany and Switzerland. Regrettably we cannot fulfill eBook-orders from other countries.

EPUBEPUB (Wasserzeichen)
Größe: 1,6 MB

DRM: Digitales Wasserzeichen
Dieses eBook enthält ein digitales Wasser­zeichen und ist damit für Sie persona­lisiert. Bei einer missbräuch­lichen Weiter­gabe des eBooks an Dritte ist eine Rück­ver­folgung an die Quelle möglich.

Dateiformat: EPUB (Electronic Publication)
EPUB ist ein offener Standard für eBooks und eignet sich besonders zur Darstellung von Belle­tristik und Sach­büchern. Der Fließ­text wird dynamisch an die Display- und Schrift­größe ange­passt. Auch für mobile Lese­geräte ist EPUB daher gut geeignet.

Systemvoraussetzungen:
PC/Mac: Mit einem PC oder Mac können Sie dieses eBook lesen. Sie benötigen dafür die kostenlose Software Adobe Digital Editions.
eReader: Dieses eBook kann mit (fast) allen eBook-Readern gelesen werden. Mit dem amazon-Kindle ist es aber nicht kompatibel.
Smartphone/Tablet: Egal ob Apple oder Android, dieses eBook können Sie lesen. Sie benötigen dafür eine kostenlose App.
Geräteliste und zusätzliche Hinweise

Zusätzliches Feature: Online Lesen
Dieses eBook können Sie zusätzlich zum Download auch online im Webbrowser lesen.

Buying eBooks from abroad
For tax law reasons we can sell eBooks just within Germany and Switzerland. Regrettably we cannot fulfill eBook-orders from other countries.

Mehr entdecken
aus dem Bereich