3. Die Grundlagen der Sprache C#
3.1. Einführung
Wir beginnen damit, C# als traditionelle Programmiersprache zu behandeln. Klassen behandeln wir im nächsten Kapitel. In einem Programm gibt es zwei Hauptbestandteile:
- Daten;
- die Anweisungen, die sie verarbeiten.
Im Allgemeinen versucht man, Daten und Anweisungen voneinander zu trennen:

Alle Beispiele in diesem Kapitel sind Einzeldatei-Anwendungen: eine einzige Datei [.cs] ohne Projektdatei ([.csproj]), die mit dem Befehl [dotnet run basics-01.cs] ausgeführt wird. Dieses mit .NET 10 eingeführte Feature wurde im vorigen Kapitel behandelt. Die Beispiele befinden sich im Ordner [03-basics] des Kurscodes. Sie laufen mit der französischen Ländereinstellung (fr-FR), wie auf einem französischen Windows-Rechner: Reelle Zahlen werden mit Dezimalkomma angezeigt.
3.2. Das minimale Programm
3.2.1. Top-Level-Anweisungen
Das Programm [basics-01.cs] sieht so aus:
Ergebnisse:
Kommentare:
- Das Programm enthält weder Klassen noch Methoden: Die Anweisungen stehen direkt in der Datei. Man spricht von Top-Level-Anweisungen (C# 9, 2020). Eine einzige Programmdatei kann sie enthalten;
- Zeile 3: Die Methode [WriteLine] der Klasse [Console] gibt eine Zeile auf dem Bildschirm aus;
- Zeile 5: Die Klasse [Console] gehört zum Namespace [System]. Ihr vollständiger Name lautet [System.Console]. Ein Namespace fasst zusammengehörige Typen zusammen, so wie ein Ordner Dateien zusammenfasst;
- Zeile 5: Das Programm besitzt ein Array [args] mit den Befehlszeilenargumenten. Darauf kommen wir im Abschnitt „Argumente des Hauptprogramms“ zurück. Die Anzahl der Elemente des Arrays ist [args.Length]. Der Operator + verkettet hier eine Zeichenfolge und eine Zahl: Die Zahl wird zuvor in eine Zeichenfolge umgewandelt.
Mit zwei Befehlszeilenargumenten (alles nach [--] wird an das Programm übergeben):
3.2.2. Die klassische Form mit einer Main-Methode
Der Kurs von 2008 (C# 3.0) behandelte keine Top-Level-Anweisungen. Dasselbe Programm wurde so geschrieben: [basics-02.cs]:
Ergebnisse:
Kommentare:
- Zeile 2: Die Direktive [using] importiert den Namespace [System]. Man kann dann [Console] statt [System.Console] schreiben;
- Zeile 4: Die Klasse befindet sich im Namespace [Basics]. Ab C# 10 kann man [namespace Basics;] schreiben (Namespace im Dateibereich): Die gesamte Datei gehört dann zu diesem Namespace, ohne geschweifte Klammern und ohne zusätzliche Einrückung. Diese Form verwenden wir von nun an;
- Zeile 6: In C# gehört aller Code zu einer Klasse. Die Klasse heißt hier [Program];
- Zeile 9: Die statische Methode [Main] ist der Einstiegspunkt des Programms: Es ist die Methode, die das System beim Start ausführt. Ihr Parameter [args], erhält die Befehlszeilenargumente.
Die beiden Programme sind gleichwertig. Wenn der Compiler Top-Level-Anweisungen vorfindet, erzeugt er eine Klasse und eine Methode namens [Main] , die diese Anweisungen sowie den Parameter [string[] args] enthalten. Top-Level-Anweisungen sind also lediglich eine Kurzform der Standardsyntax. Sie eignen sich gut für die kleinen Programme dieses Kapitels; die Standardsyntax bleibt nützlich, wenn man die Klasse untersuchen möchte, die [Main] enthält.
3.2.3. Implizite using-Anweisungen
Das Programm [basics-01.cs] verwendet die Klasse [Console] ohne die Direktive [using System;]. Das ist möglich, weil das .NET SDK jedem Konsolenprogramm automatisch eine generierte Datei mit [global using]-Direktiven (C# 10) hinzufügt, die für alle Dateien des Programms gelten. Für [basics-01.cs] enthält diese Datei:
Das sind die impliziten using-Anweisungen: Die am häufigsten verwendeten Namespaces werden automatisch importiert. Ein nicht in dieser Liste enthaltener Namespace, etwa [System.Globalization], muss stets mit einer [using]-Direktive am Anfang der Datei importiert werden. Im Programm [basics-02.cs] ist die Direktive [using System;] also überflüssig: Wir haben sie belassen, um das Format von 2008 zu zeigen.
3.3. C#-Daten
C# verwendet die folgenden Datentypen:
- Ganzzahlen;
- reelle Zahlen;
- Dezimalzahlen;
- Zeichen und Zeichenfolgen;
- boolesche Werte;
- Objekte.
3.3.1. Vordefinierte Datentypen
C#-Typ | .NET-Typ | Dargestellte Daten | Literalsuffix | Kodierung | Wertebereich |
[char] | [Char] (S) | Zeichen | 2 Bytes | Unicode-Zeichen (UTF-16) | |
[string] | [String] (K) | Zeichenfolge | Referenz auf eine Unicode-Zeichenfolge | ||
[int] | [Int32] (S) | Ganzzahl | 4 Bytes | [-2³¹, 2³¹-1] oder [-2147483648, 2147483647] | |
[uint] | [UInt32] (S) | vorzeichenlose Ganzzahl | U | 4 Bytes | [0, 2³²-1] oder [0, 4294967295] |
[long] | [Int64] (S) | Ganzzahl | L | 8 Bytes | [-2⁶³, 2⁶³-1] oder [-9223372036854775808, 9223372036854775807] |
[ulong] | [UInt64] (S) | vorzeichenlose Ganzzahl | UL | 8 Bytes | [0, 2⁶⁴-1] oder [0, 18446744073709551615] |
[sbyte] | [SByte] (S) | Ganzzahl | 1 Byte | [-2⁷, 2⁷-1] oder [-128, 127] | |
[byte] | [Byte] (S) | vorzeichenlose Ganzzahl | 1 Byte | [0, 2⁸-1] oder [0, 255] | |
[short] | [Int16] (S) | Ganzzahl | 2 Bytes | [-2¹⁵, 2¹⁵-1] oder [-32768, 32767] | |
[ushort] | [UInt16] (S) | vorzeichenlose Ganzzahl | 2 Bytes | [0, 2¹⁶-1] oder [0, 65535] | |
[float] | [Single] (S) | reelle Zahl | F | 4 Bytes | [1,5 10⁻⁴⁵, 3,4 10³⁸] im Absolutwert, 7 signifikante Stellen |
[double] | [Double] (S) | reelle Zahl | D | 8 Bytes | [5,0 10⁻³²⁴, 1,7 10³⁰⁸] im Absolutwert, 15 bis 16 signifikante Stellen |
[decimal] | [Decimal] (S) | Dezimalzahl | M | 16 Bytes | [1,0 10⁻²⁸, 7,9 10²⁸] im Absolutwert, 28 bis 29 signifikante Stellen |
[bool] | [Boolean] (S) | boolescher Wert | 1 Byte | [true], [false] | |
[object] | [Object] (K) | Objektreferenz | Referenz auf ein Objekt beliebigen Typs |
Oben haben wir für jeden C#-Typ den entsprechenden .NET-Typ aufgeführt, mit (S) gekennzeichnet, wenn der Typ eine Struktur ist, und mit (K), wenn er eine Klasse ist. Wir sehen, dass es für eine 32-Bit-Ganzzahl zwei mögliche Namen gibt: [int] und [Int32]. Der Typ [int] ist ein C#-Schlüsselwort. [Int32] ist eine Struktur, die zum Namespace [System] gehört: Ihr vollständiger Name lautet [System.Int32]. Der Typ [int] ist ein C#-Alias , der auf die .NET-Struktur [System.Int32] verweist. Ebenso ist der C#-Typ [string] ein Alias für den .NET-Typ [System.String]. [System.String] ist eine Klasse, keine Struktur. Die beiden Konzepte sind ähnlich, unterscheiden sich aber in folgendem grundlegenden Punkt:
- Eine Variable vom Typ einer Struktur enthält ihren Wert direkt: Man spricht von einem Werttyp;
- Eine Variable eines Klassentyps enthält die Adresse des Objekts (seine Referenz); man spricht von einem Referenztyp.
Außerdem gibt es zwei weniger gebräuchliche Typen:
- [nint] und [nuint] (C# 9) sind vorzeichenbehaftete und vorzeichenlose Ganzzahlen, deren Größe der einer Speicheradresse entspricht: 4 Bytes auf einem 32-Bit-System, 8 Bytes auf einem 64-Bit-System. Sie dienen vor allem der Interaktion mit nativem Code;
- [System.Half] (.NET 5) ist eine 2 Byte große Gleitkommazahl mit geringer Genauigkeit, die in der Grafikberechnung und im maschinellen Lernen verwendet wird. Es ist kein vordefinierter Typ der Sprache: Es hat kein C#-Schlüsselwort.
Eine Struktur ist wie eine Klasse ein komplexer Typ mit Eigenschaften und Methoden. So können wir schreiben:
Das Literal 3 ist standardmäßig vom C#-Typ [int] und damit vom .NET-Typ [System.Int32]. Diese Struktur hat eine Methode [GetType()] , die ein Objekt zurückgibt, das den Datentyp beschreibt. Zu den Eigenschaften dieses Objekts gehört [FullName] , der vollständige Name des Typs. Das Literal 3 ist also ein komplexeres Objekt, als es auf den ersten Blick scheint. Das Fragezeichen in [string?] wird etwas später erklärt.
Das Programm [basics-03.cs] veranschaulicht diese verschiedenen Punkte:
Ergebnisse:
Kommentare:
- Zeile 2: Deklaration einer Ganzzahl [integer] , initialisiert mit 2;
- Zeile 16: Die Anweisung [Console.WriteLine("... {0} ... {1} ...", param0, param1, ...)] zeigt den als ersten Parameter angegebenen Text (das Format) auf dem Bildschirm an und ersetzt dabei jedes {i} durch den Wert des i-ten auf das Format folgenden Parameters. Die Parameter werden ab 0 nummeriert;
- Zeile 17: Der Typ einer Variablen [v] erhält man über [v.GetType().FullName]. Die Größe eines vordefinierten Werttyps [T] in Bytes erhält man über [sizeof(T)];
- Zeile 20: Da der Typ [string] auf eine Klasse und nicht auf eine Struktur verweist, kann der Operator [sizeof] nicht verwendet werden;
- Zeile 33: [sizeof(nint)] ist in normalem Code nicht erlaubt, weil die Größe von [nint] erst zur Laufzeit bekannt ist. Die Eigenschaft [nint.Size] gibt an, dass sie auf dem verwendeten 64-Bit-Rechner 8 Bytes beträgt;
- Zeile 35: Man kann nicht [Half h = 1.5;] schreiben: Es gibt keine implizite Konvertierung von [double] nach [Half]. Die Schreibweise [(Half)] ist eine explizite Konvertierung (auf Englisch „Cast“ genannt), die wir später untersuchen werden;
- Zeilen 40–42: Die Eigenschaften [MinValue] und [MaxValue] der numerischen Typen geben die Grenzen ihrer Wertebereiche an.
Die Ausgabe zeigt die .NET-Typnamen statt der C#-Aliase an. Beachten Sie das Dezimalkomma bei Gleitkommazahlen: Die Zahlen werden gemäß der Ländereinstellung des Systems in Zeichenfolgen umgewandelt, hier der französischen.
3.3.2. Schreibweise für literale Daten
Daten | Beispiele für Literale |
[int] Ganzzahl (32 Bit) | 145, -7, 0xFF (hexadezimal), 0b1010_1010 (binär) |
Ganzzahl [long] (64 Bit), Suffix L | 100000L, 1_000_000_000_000L |
vorzeichenlose Ganzzahl, Suffix U oder UL | 4000000000U, 10UL |
Gleitkommazahl [double] | 134.789, -45E-18 (-45 × 10⁻¹⁸) |
reelle Zahl [float], Suffix F | 134.789F, -45E-18F |
reelle Zahl [decimal], Suffix M | 100000.50M |
Zeichen [char] | 'A', 'b', '\n', '\u00e9' |
Zeichenfolge [string] | "today", "c:\\chap1", @"c:\chap1", $"{name} is {age} years old", """plain text""" |
boolescher Wert [bool] | [true], [false] |
Datum | [new DateTime(1954, 10, 13)] (Jahr, Monat, Tag) für den 13.10.1954 |
Im Quelltext werden Gleitkommazahlen unabhängig von der Ländereinstellung des Systems immer mit Dezimalpunkt geschrieben. Seit C# 7 können Ganzzahlen binär geschrieben werden (mit dem Präfix [0b]), und Zifferngruppen können zur besseren Lesbarkeit durch das Zeichen _ getrennt werden: [1_000_000] ist die Ganzzahl eine Million.
Ein normales Zeichenfolgenliteral kann Escape-Sequenzen enthalten, die durch das Zeichen \ eingeleitet werden: "\n" steht für das Zeilenendezeichen und nicht für die Folge der beiden Zeichen \ und n, "\t" steht für einen Tabulator, "\"" steht für ein doppeltes Anführungszeichen, und "\\" steht für das Zeichen \ selbst. Um den Windows-Pfad c:\chap1\paragraph3 zu schreiben, müssen Sie daher "c:\\chap1\\paragraph3" schreiben. Sie können auch @"c:\chap1\paragraph3" schreiben: Die Syntax @"text" legt fest, dass der Text genau so übernommen wird, wie er geschrieben ist, ohne das Zeichen \ zu interpretieren. Man spricht von einer wörtlichen Zeichenfolge (Verbatim-String).
C# bietet inzwischen zwei weitere Arten von Zeichenfolgen:
- die interpolierte Zeichenfolge (C# 6) $"...": Ausdrücke in geschweiften Klammern werden ausgewertet, und ihre Werte werden in die Zeichenfolge eingefügt. Auf einen Ausdruck kann nach einem Doppelpunkt eine Formatangabe folgen: [$"{d1:F2}"] zeigt die Gleitkommazahl [d1] mit zwei Nachkommastellen an. Dies ist die lesbarste Art, eine Zeichenfolge zu konstruieren, und wir werden sie von nun an anstelle der Formate {0}, {1}, ... verwenden;
- Die Rohzeichenfolge (C# 11) """...""": Sie beginnt und endet mit mindestens drei Anführungszeichen. Sie kann Anführungszeichen und \-Zeichen ohne Escape enthalten und sich über mehrere Zeilen erstrecken. Leerzeichen vor den schließenden Anführungszeichen werden aus jeder Zeile entfernt, sodass der Text mit dem Code eingerückt werden kann. Das ist sehr nützlich zum Schreiben von JSON, SQL oder HTML.
Das Programm [basics-04.cs] demonstriert diese verschiedenen Schreibweisen:
Ergebnisse:
Kommentare:
- Zeile 3: [0xFF] ist 255 und [0b1010_1010] ist 170;
- Zeile 7: -45E-18 wird als -4,5E-17 angezeigt: Es ist derselbe Wert, normalisiert;
- Zeile 12: Die Sequenz \u00e9 bezeichnet das Unicode-Zeichen mit dem Hexadezimalcode 00E9, also é;
- Zeile 16: ein Datum. Die Methode [ToShortDateString] zeigt es im kurzen Format der französischen Kultur an. Für ein Datum ohne Uhrzeit hat .NET 6 den Typ [DateOnly] hinzugefügt; darauf kommen wir in Kapitel 5 zurück;
- Zeilen 20–22: Die beiden Zeichenfolgen sind identisch, wie die Ausgabe zeigt;
- Zeile 30: eine interpolierte Zeichenfolge. Die Ausdrücke [name], [age], und [age + 10] werden ausgewertet und anschließend in die Zeichenfolge eingefügt;
- Zeile 32: einige Formate: F1 (eine Nachkommastelle), X (hexadezimal), B8 (8-stellig binär, .NET 8), N0 (Tausendertrennzeichen, keine Nachkommastelle);
- Zeile 33: ein benutzerdefiniertes Datumsformat: Wochentag, Tag, Monat ausgeschrieben, Jahr;
- Zeilen 36–41: eine mehrzeilige Rohzeichenfolge. Anführungszeichen und das Zeichen \ werden unverändert geschrieben. Die vier Leerzeichen vor den schließenden Anführungszeichen wurden aus jeder Zeile entfernt;
- Zeile 44: eine interpolierte Rohzeichenfolge. Bei zwei $-Zeichen werden Ausdrücke zwischen doppelten geschweiften Klammern {{ und }} geschrieben: Die einfachen geschweiften Klammern, die in JSON häufig vorkommen, bleiben gewöhnlicher Text.
3.3.3. Deklaration von Daten
3.3.3.1. Aufgabe von Deklarationen
Ein Programm verarbeitet Daten, die durch einen Namen und einen Typ gekennzeichnet sind. Diese Daten werden im Speicher abgelegt. Beim Kompilieren des Programms weist der Compiler jedem Datum einen Speicherplatz zu, der durch eine Adresse und eine Größe gekennzeichnet ist. Dabei stützt er sich auf die Deklarationen des Programmierers. Außerdem ermöglichen diese Deklarationen dem Compiler, Programmierfehler zu erkennen. So wird die Operation [x = x * 2;] als ungültig abgelehnt, wenn [x] eine Zeichenfolge ist.
3.3.3.2. Konstanten deklarieren
Die Syntax zur Deklaration einer Konstante lautet:
Zum Beispiel:
Warum Konstanten deklarieren?
- Das Programm ist leichter lesbar, wenn die Konstante einen aussagekräftigen Namen erhält;
- das Programm lässt sich leichter ändern, wenn die „Konstante“ angepasst werden muss. Ändert sich beispielsweise der Mehrwertsteuersatz auf 0,25, ist nur die Anweisung zu ändern, die seinen Wert festlegt: [const double VatRate = 0.25;]. Wäre 0,2 explizit im Programm verwendet worden, müssten zahlreiche Anweisungen geändert werden.
Der Wert einer Konstante muss zur Kompilierzeit bekannt sein: eine Zahl, eine Zeichenfolge, ein boolescher Wert oder ein Ausdruck, der sich aus anderen Konstanten berechnen lässt. In .NET beginnen Konstantennamen üblicherweise mit einem Großbuchstaben.
3.3.3.3. Deklaration von Variablen
Eine Variable wird durch einen Namen identifiziert und ist einem Datentyp zugeordnet. C# unterscheidet zwischen Groß- und Kleinschreibung: Die Variablen [END] und [end] sind verschieden.
Variablen können bei ihrer Deklaration initialisiert werden. Die Syntax zur Deklaration einer oder mehrerer Variablen lautet:
Dabei ist [type] ein vordefinierter oder ein vom Programmierer definierter Typ. Die Initialisierung ist optional; C# erlaubt jedoch nicht die Verwendung einer lokalen Variable, der noch kein Wert zugewiesen wurde.
Sie können den Typ einer Variable auch weglassen, indem Sie anstelle des Typs das Schlüsselwort [var] verwenden:
Das Schlüsselwort [var] bedeutet nicht, dass die Variable keinen bestimmten Typ hätte: Sie hat den vom Compiler ermittelten Typ des ihr zugewiesenen Werts. Die Initialisierung ist hier erforderlich, damit der Compiler den Typ ableiten kann. Wir verwenden [var] , wenn der Typ aus dem Wert offensichtlich ist.
Das Programm [basics-05.cs] sieht so aus:
Ergebnisse:
Kommentare:
- Zeilen 2–3: zwei Konstanten;
- Zeile 8: ein explizit typisiertes Datum;
- Zeile 9: [GetType().Name] ist der Kurzname des Typs, [GetType().FullName] ist sein vollständiger Name;
- Zeile 11: ein implizit typisierter Wert. Da 3 vom Typ [int] ist, wird [j] vom Typ [int] sein;
- Zeile 13: Da [DateTime.Now] (das aktuelle Datum und die aktuelle Uhrzeit) vom Typ [DateTime] ist, wird [today] vom Typ [DateTime] sein;
- Zeilen 15–18: Der abgeleitete Typ hängt von der Schreibweise des Literals ab: 3.5 ist ein [double], 3.5F ist ein [float], und 10L ist ein [long];
- Zeile 21: drei Variablen, die in derselben Zeile deklariert werden; nur [a] und [c] werden initialisiert. [b] erhält in der nächsten Zeile einen Wert.
Eine mit dem Schlüsselwort [var] implizit typisierte Variable kann ihren Typ danach nicht mehr ändern. So könnten Sie nach Zeile 13 Folgendes nicht schreiben:
denn [today] ist vom Typ [DateTime]. In Kapitel 5 werden wir mit LINQ sehen, dass sich innerhalb eines Ausdrucks ein Typ „im Handumdrehen“ erzeugen lässt: ein anonymer Typ, dem der Programmierer keinen Namen gegeben hat. Sollen Daten eines anonymen Typs einer Variable zugewiesen werden, lässt sich diese Variable nur mit dem Schlüsselwort [var] deklarieren.
3.3.4. Nullable-Typen
Eine Variable eines Werttyps wie [int] enthält immer einen Wert. Manchmal ist es nützlich, das Fehlen eines Werts ausdrücken zu können: ein unbekanntes Alter, ein leeres Feld in einer Datenbank. Der Typ [int?] (C# 2) ist der Typ [int] , erweitert um den Wert [null], der „kein Wert“ bedeutet. Man spricht von einem Nullable-Werttyp. Das Prinzip gilt für alle Werttypen: [double?], [bool?], [DateTime?], ...
Eine Variable eines Referenztyps wie [string] kann immer den Wert [null] haben: Das bedeutet, dass sie auf kein Objekt verweist. Der Versuch, einen Member einer solchen Variable zu verwenden, etwa ihre Eigenschaft [Length], führt zu einem Laufzeitfehler ([NullReferenceException]), einem der häufigsten Fehler in C#. Ab C# 8 kann der Compiler dies verhindern helfen: mit Nullable-Referenztypen, die in mit dem Befehl [dotnet new] erstellten Projekten und in Einzeldatei-Anwendungen standardmäßig aktiviert sind, gilt:
- der Typ [string] bezeichnet eine Zeichenfolge, die niemals den Wert [null] hat;
- der Typ [string?] bezeichnet eine Zeichenfolge, die [null] sein kann.
Der Compiler verfolgt die möglichen Werte von Variablen und gibt eine Warnung aus, wenn die Gefahr besteht, den Wert [null] zu verwenden: [null] einer Variable [string] zuzuweisen, [Length] auf eine nicht geprüfte Variable [string?] anzuwenden usw. Anders als [int?] erzeugt [string?] zur Laufzeit keinen neuen Typ: Es ist eine für den Compiler bestimmte Anweisung.
Diesen Typen begegnen wir schon in den ersten Beispielen, denn die Methode [Console.ReadLine()], die eine über die Tastatur eingegebene Zeile liest, gibt einen [string?] zurück: Sie gibt [null] zurück, wenn nichts mehr zu lesen ist (Ende des Eingabestroms). Das Programm [basics-06.cs] sieht so aus:
Ergebnisse bei Texteingabe über die Tastatur:
Ergebnisse, wenn der Benutzer Strg-D drückt (unter Windows Strg-Z gefolgt von der Eingabetaste), was den Eingabestrom schließt:
Kommentare:
- Zeile 3: [age] enthält keinen Wert;
- Zeile 4: Die Eigenschaft [HasValue] gibt an, ob die Variable einen Wert enthält; die Eigenschaft [Value] liefert diesen Wert;
- Zeile 8: Ein [int?] kann nicht direkt einem [int] zugewiesen werden, da es gleich [null] sein kann. Erforderlich ist eine explizite Konvertierung, die eine Ausnahme auslöst, wenn [age] gleich [null] ist. Den sichereren Operator [??] besprechen wir später;
- Zeile 12: eine Zeichenfolge, die gleich [null] sein kann;
- Zeile 15: eine Zeichenfolge, die niemals gleich [null] ist. Die Anweisung [name = null;] würde eine Compilerwarnung auslösen;
- Zeile 20: [Console.ReadLine()] ergibt den Typ [string?]. Würde man [line] als Typ [string] deklarieren, gäbe es eine Warnung;
- Zeile 21: Der Wert [null] wird geprüft;
- Zeile 29: Im [else]-Zweig weiß der Compiler, dass [line] nicht gleich [null] ist: Er gibt keine Warnung für die Verwendung von [line.Length] aus.
3.3.5. Konvertierungen zwischen Zahlen und Zeichenfolgen
Konvertierung | Methode |
Zahl -> Zeichenfolge | [number.ToString()] oder eine interpolierte Zeichenfolge [$"{number}"] |
Zeichenfolge -> int | [int.Parse(str)] oder [int.TryParse(str, out int number)] |
Zeichenfolge -> long | [long.Parse(str)] oder [long.TryParse(str, out long number)] |
Zeichenfolge -> double | [double.Parse(str)] oder [double.TryParse(str, out double number)] |
Zeichenfolge -> float | [float.Parse(str)] oder [float.TryParse(str, out float number)] |
Zeichenfolge -> decimal | [decimal.Parse(str)] oder [decimal.TryParse(str, out decimal number)] |
Die Konvertierung einer Zeichenfolge in eine Zahl kann fehlschlagen, wenn die Zeichenfolge keine gültige Zahl darstellt. Die Methode [Parse] erzeugt dann einen schwerwiegenden Fehler, der Ausnahme genannt wird. Dieser Fehler lässt sich mit der folgenden [try / catch]-Klausel behandeln:
Löst die Funktion keine Ausnahme aus, wird die Ausführung mit der nächsten Anweisung fortgesetzt; andernfalls springt sie in den Rumpf der [catch]-Klausel und danach zur nächsten Anweisung. Auf die Ausnahmebehandlung kommen wir in dem ihr gewidmeten Abschnitt zurück.
Die Methode [TryParse] (.NET 2.0) vermeidet die Ausnahme: Sie gibt den booleschen Wert [true] zurück, wenn die Konvertierung gelingt, andernfalls [false] , und speichert die resultierende Zahl in einer Variable, die mit dem Schlüsselwort [out] übergeben wird. Ab C# 7 kann diese Variable im Aufruf selbst deklariert werden: [int.TryParse(str, out var number)]. Die Übergabeart [out] wird im Abschnitt über die Parameterübergabe erklärt. Wenn mit fehlerhaften Eingaben zu rechnen ist, etwa bei der Tastatureingabe, ist [TryParse] gegenüber [Parse] vorzuziehen: Ein Eingabefehler ist keine Ausnahmesituation.
Das Programm [basics-07.cs] demonstriert mehrere Techniken zur Konvertierung zwischen Zahlen und Zeichenfolgen. Die Funktion [Display] zeigt den Wert ihres Parameters auf dem Bildschirm an:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | |
Ergebnisse:
Kommentare:
- Zeile 2: Der Namespace [System.Globalization], der die Klasse [CultureInfo] enthält, gehört nicht zu den impliziten using-Anweisungen;
- Zeilen 5–8: die zu konvertierenden Daten;
- Zeilen 11–14: Jedes Objekt hat eine Methode [ToString()], die es in eine Zeichenfolge umwandelt;
- Zeilen 25–30: Die Ausnahme, die [int.Parse] auslösen kann, wird behandelt. [e.Message] ist die der Ausnahme [e] zugeordnete Fehlermeldung. Die Ausnahmemeldungen von .NET sind auf Englisch: .NET 10 stellt keine französische Übersetzung bereit;
- Zeile 47: Die Zeichenfolge verwendet ein Dezimalkomma, entsprechend der französischen Ländereinstellung des Systems;
- Zeile 73: [TryParse] ist erfolgreich und speichert 123 in der Variable [i2], die im Aufruf deklariert wird;
- Zeile 77: [TryParse] schlägt fehl und gibt [false] zurück; der Variable [i3] wird dann der Wert 0 zugewiesen;
- Zeile 83: Die aktuelle Ländereinstellung des Programms ist fr-FR;
- Zeile 86: In der französischen Ländereinstellung ist der Punkt kein Dezimaltrennzeichen: Die Konvertierung schlägt fehl;
- Zeile 94: Die invariante Ländereinstellung [CultureInfo.InvariantCulture] verwendet unabhängig vom Rechner den Dezimalpunkt. Sie dient zum Lesen und Schreiben von Zahlen in Dateien oder beim Austausch zwischen Programmen, die nicht von der Sprache des Benutzers abhängen dürfen;
- Zeilen 95–96: dieselbe Zahl, gemäß der aktuellen Ländereinstellung (100,87) und gemäß der invarianten Ländereinstellung (100.87) in eine Zeichenfolge umgewandelt;
- Zeile 97: [TryParse] akzeptiert auch eine Ländereinstellung;
- Zeilen 103–105: eine lokale Funktion. In einer Programmierung mit Top-Level-Anweisungen können Sie keine Methoden schreiben, da es keine Klassen gibt; stattdessen schreibt man lokale Funktionen, die vor ihrer Definition aufgerufen werden können. Sie werden im Abschnitt „Lokale Funktionen und Tupel“ behandelt.
Der Kurs von 2008 gab an, dass reelle Zahlen in Zeichenform ein Komma verwenden müssen: Das gilt nur in der französischen Kultur. Ein Programm, das Zahlen liest, muss immer wissen, in welcher Kultur sie geschrieben wurden.
3.3.6. Datenarrays
Ein C#-Array ist ein Objekt, mit dem sich Daten desselben Typs unter einem einzigen Bezeichner zusammenfassen lassen. Es wird wie folgt deklariert:
[n] ist die Anzahl der Datenelemente, die das Array enthalten kann. Die Syntax [array[i]] bezeichnet das Datenelement Nummer i, wobei i im Bereich [0, n-1] liegt. Jeder Zugriff auf das Datenelement [array[i]] mit einem i außerhalb des Bereichs [0, n-1] löst eine Ausnahme aus. Bei der Erzeugung erhält jedes Element des Arrays den Standardwert seines Typs: 0 für Zahlen, [false] für boolesche Werte und [null] für Referenztypen. Ein Array kann gleichzeitig mit seiner Deklaration initialisiert werden:
oder einfacher:
oder ab C# 12 mit einem Collection-Ausdruck:
Diese letzte Form verwenden wir von nun an. Arrays haben eine Eigenschaft [Length], die die Anzahl der enthaltenen Elemente angibt.
Ein zweidimensionales Array wird wie folgt deklariert:
Dabei ist [n] die Anzahl der Zeilen und [m] die Anzahl der Spalten. Die Syntax [array[i, j]] bezeichnet das Element j der Zeile i. Das zweidimensionale Array kann ebenfalls gleichzeitig mit seiner Deklaration initialisiert werden:
Die Anzahl der Elemente in jeder Dimension erhält man mit der Methode [GetLength(i)], wobei i=0 die Dimension des ersten Index, i=1 die Dimension des zweiten Index usw. darstellt. Die Anzahl der Dimensionen erhält man mit der Eigenschaft [Rank], die Gesamtzahl der Elemente mit der Eigenschaft [Length].
Ein Array von Arrays (auch gezacktes Array genannt) wird wie folgt deklariert:
Die obige Deklaration erzeugt ein Array mit n Elementen. Jedes Element [array[i]], ist eine Referenz auf ein eindimensionales Array. Diese Referenzen werden von der obigen Deklaration nicht initialisiert; sie haben den Wert [null]. Anders als bei einem zweidimensionalen Array kann jede Zeile eine andere Länge haben.
C# 8 hat zwei praktische Schreibweisen eingeführt:
- die Indizierung von hinten: [array[^1]] ist das letzte Element, [array[^2]] ist das vorletzte usw. [array[^1]] entspricht [array[array.Length - 1]];
- der Bereich: [array[1..3]] ist ein neues Array aus den Elementen mit den Indizes 1 und 2. Der Startindex ist eingeschlossen, der Endindex ausgeschlossen. Die Grenzen können weggelassen werden: [array[2..]] reicht von Index 2 bis zum Ende, und [array[..^1]] reicht vom Anfang bis einschließlich zum vorletzten Element.
Das Programm [basics-08.cs] kombiniert diese verschiedenen Arrays:
Ergebnisse:
Kommentare:
- Zeile 3: Ein eindimensionales Array wird initialisiert;
- Zeile 4: Eine Schleife [for] durchläuft die Indizes von 0 bis [integers.Length - 1]. Die Schleife [for] wird weiter unten vorgestellt;
- Zeile 10: ein zweidimensionales Array (2 Zeilen, 2 Spalten);
- Zeilen 11–13: [GetLength(0)] ist die Anzahl der Zeilen, [GetLength(1)] ist die Anzahl der Spalten;
- Zeile 21: ein Array [names] mit 3 Elementen. Jedes Element ist eine Referenz auf ein Array vom Typ [string[]], derzeit [null];
- Zeile 24: Die 3 Elemente des Arrays [names] werden initialisiert. [names[i]] verweist nun auf ein Array aus i+1 Zeichenfolgen;
- Zeile 31: [names[i][j]] ist das j-te Element des Arrays, auf das [names[i]] verweist. Da [names[i]] ein Array ist, ist [names[i].Length] die Anzahl seiner Elemente. Der Ausdruck „name“ + i + j wird von links nach rechts ausgewertet: „name“ + i ergibt eine Zeichenfolge, an die j angehängt wird;
- Zeilen 44–45: ohne Anfangswerte erzeugte Arrays. Der Typ [string?[]] ist ein Array, dessen Elemente [null] sein können;
- Zeile 49: ein Collection-Ausdruck;
- Zeile 51: Die Methode [string.Join] bildet aus den Elementen des Arrays eine Zeichenfolge, getrennt durch die als ersten Parameter übergebene Zeichenfolge;
- Zeile 53: das letzte und das vorletzte Element;
- Zeile 55: die Elemente mit den Indizes 1 und 2;
- Zeilen 60–61: Ein Bereich erzeugt eine Kopie: Die Änderung von [slice] ändert [values] nicht.
3.4. Grundlegende C#-Anweisungen
Es gibt:
- grundlegende Anweisungen, die der Computer ausführt;
- Anweisungen, die den Programmablauf steuern.
Die grundlegenden Anweisungen werden verständlich, wenn man den Aufbau eines Mikrocomputers und seiner Peripheriegeräte betrachtet:

- 1: Informationen von der Tastatur lesen;
- 2: Informationen verarbeiten;
- 3: Informationen auf den Bildschirm schreiben.
3.4.1. Auf den Bildschirm schreiben
Es gibt verschiedene Anweisungen zum Schreiben auf den Bildschirm:
Dabei ist [expression] ein beliebiges Datum, das sich zur Anzeige auf dem Bildschirm in eine Zeichenfolge umwandeln lässt. Alle C#- oder .NET-Objekte haben eine Methode [ToString()], mit der diese Umwandlung erfolgt. Die Methode [Write] tut dasselbe wie [WriteLine] , jedoch ohne Zeilenumbruch.
Die Klasse [System.Console] bietet Zugriff auf Schreiboperationen für den Bildschirm ([Write], [WriteLine]). Sie hat zwei Eigenschaften, [Out] und [Error], die Schreibströme vom Typ [TextWriter] sind:
- [Console.WriteLine()] entspricht [Console.Out.WriteLine()] und schreibt in den Strom [Out], der üblicherweise dem Bildschirm zugeordnet ist;
- [Console.Error.WriteLine()] schreibt in den Strom [Error], der ebenfalls üblicherweise dem Bildschirm zugeordnet ist.
Die Ströme [Out] und [Error] können zur Laufzeit in Dateien umgeleitet werden, wie wir gleich sehen werden.
3.4.2. Über die Tastatur eingegebene Daten lesen
Der Datenstrom der Tastatur wird durch das Objekt [Console.In] vom Typ [TextReader] dargestellt. Dieser Objekttyp erlaubt es, mit der Methode [ReadLine] eine Textzeile zu lesen:
Die Klasse [Console] stellt eine Methode [ReadLine] bereit, die standardmäßig dem Strom [In] zugeordnet ist. Daher können Sie schreiben:
Die über die Tastatur eingegebene Zeile wird ohne das Zeilenendezeichen in der Variable [line] gespeichert und kann anschließend vom Programm verarbeitet werden. Wie wir gesehen haben, gibt [ReadLine] den Wert [null] zurück, wenn der Eingabestrom erschöpft ist: Deshalb hat die Variable den Typ [string?]. Der Strom [In] kann wie die Ströme [Out] und [Error] in eine Datei umgeleitet werden.
3.4.3. Beispiel für Ein- und Ausgabe
Das Programm [basics-09.cs] veranschaulicht Ein- und Ausgabeoperationen über Tastatur und Bildschirm:
Ergebnisse:
Kommentare:
- Zeile 4: [obj] ist eine Objektreferenz;
- Zeile 5: [obj] wird auf dem Bildschirm angezeigt. Die Methode [obj.ToString()] wird aufgerufen, um den anzuzeigenden Text zu ermitteln;
- Zeile 9: Der Text wird in den Strom [Error] geschrieben;
- Zeile 10: dasselbe, aber mit einem Format. Der erste Parameter, "i={0}", ist das Anzeigeformat; die übrigen Parameter sind die anzuzeigenden Ausdrücke. Die Elemente {n} sind Positionsparameter: Zur Laufzeit wird {n} durch den Wert des n-ten Ausdrucks ersetzt;
- Zeilen 13–14: Eine Eingabeaufforderung wird ohne Zeilenumbruch angezeigt, anschließend wird die über die Tastatur eingegebene Zeile gelesen;
- Zeile 15: In einer interpolierten Zeichenfolge ergäbe ein Wert wie [null] eine leere Zeichenfolge: Es wird keine Warnung ausgegeben.
In den Ergebnissen:
- Zeile 2: die von Zeile 5 des Codes erzeugte Ausgabe. Die Methode
*[obj.ToString()]hat den Typnamen der Variable*[obj]*angezeigt:*[System.Object]*. Der Typ [object] ist ein C#-Alias für den .NET-Typ [System.Object]*; - Zeilen 3–4: Die beiden Ausgaben für den [Error]-Strom erscheinen auf dem Bildschirm wie die für den [Out]-Strom.
3.4.4. Ein-/Ausgabeumleitung
Windows, Linux und macOS kennen drei Standardgeräte:
- das Standardeingabegerät, das standardmäßig die Tastatur bezeichnet und die Nummer 0 trägt;
- das Standardausgabegerät, das standardmäßig den Bildschirm bezeichnet und die Nummer 1 trägt;
- das Standardfehlergerät, das standardmäßig auf den Bildschirm eingestellt ist und die Nummer 2 trägt.
In C# schreibt der Schreibstrom [Console.Out] auf das Gerät 1, der Schreibstrom [Console.Error] auf das Gerät 2, und der Lesestrom [Console.In] liest Daten vom Gerät 0.
Wenn Sie ein Programm in einem Befehlsfenster ausführen, können Sie festlegen, welche Geräte für das ausgeführte Programm 0, 1 und 2 sind. Nach den Programmargumenten können Sie die Standardeingabe- und -ausgabegeräte in Dateien umleiten:
Umleitung | Bedeutung |
0<in.txt oder <in.txt | Der Standardeingabestrom Nr. 0 wird in die Datei in.txt umgeleitet. Im Programm liest der Strom [Console.In] seine Daten daher aus der Datei in.txt |
1>out.txt oder >out.txt | leitet die Ausgabe Nr. 1 in die Datei out.txt um. Im Programm schreibt der Strom [Console.Out] seine Daten daher in die Datei out.txt |
1>>out.txt oder >>out.txt | Wie oben, aber die geschriebenen Daten werden an den aktuellen Inhalt der Datei out.txt angehängt |
2>err.txt | leitet die Ausgabe Nr. 2 in die Datei err.txt um. Im Programm schreibt der Stream [Console.Error] seine Daten daher in die Datei err.txt |
2>>err.txt | Wie oben, aber die geschriebenen Daten werden an den aktuellen Inhalt der Datei err.txt angehängt |
1>out.txt 2>err.txt | Die Geräte 1 und 2 werden beide in Dateien umgeleitet |
Beachten Sie: Um die Ein- und Ausgabeströme eines Programms in Dateien umzuleiten, muss das Programm nicht geändert werden; die Art der Geräte 0, 1 und 2 bestimmt das Betriebssystem. Betrachten Sie das folgende Programm, [basics-10.cs]:
Der Kurs von 2008 erzeugte mit Visual Studio eine ausführbare Datei und startete sie anschließend in einem DOS-Fenster. Heute genügt der Befehl [dotnet run] : Die Umleitungen werden auf das gestartete Programm angewendet. Hier eine Sitzung in einem Linux-Terminal (bash):
Kommentare:
- Zeile 1: Die Zeichenkette „test“ wird in die Datei in.txt geschrieben;
- Zeile 2: Der Inhalt der Datei in.txt wird zur Kontrolle angezeigt;
- Zeile 4: Das Programm wird ausgeführt. Der Stream [In] wird in die Datei in.txt umgeleitet, der Stream [Out] in die Datei out.txt und der Stream [Error] in die Datei err.txt. Die Ausführung erzeugt keinerlei Ausgabe;
- Zeilen 5–6: Der Inhalt der Datei out.txt zeigt, dass die Datei in.txt gelesen wurde und dass das Schreiben in den Stream [Out] nach out.txt umgeleitet wurde;
- Zeilen 7–8: entsprechende Überprüfung für die Datei err.txt;
- Zeilen 9–10: Nur der Stream [Error] wird umgeleitet: Auf dem Bildschirm erscheint nur der Schreibvorgang in den Stream [Out];
- Zeilen 11–12: Nur der Stream [Out] wird umgeleitet: Auf dem Bildschirm erscheint nur der Schreibvorgang in den Stream [Error].
Es ist offensichtlich, dass die Streams [Out] und [Error] nicht in dieselben Geräte schreiben, da sie getrennt umgeleitet werden konnten. Der Stream [Error] ist für Fehlermeldungen gedacht: So können Sie die Ausgabe eines Programms in eine Datei umleiten und dennoch seine Fehlermeldungen auf dem Bildschirm sehen.
Die Operatoren >, >> und 2> werden in der Windows-Eingabeaufforderung ([cmd]), in PowerShell und in bash gleich geschrieben. Der Operator < wird von [cmd] und bash erkannt, nicht jedoch von PowerShell, das ihn für eine künftige Verwendung reserviert: In PowerShell sendet man eine Datei über eine Pipe (|) an die Standardeingabe eines Programms. Die folgenden Befehle, die nur zur Veranschaulichung dienen (sie wurden für diesen Kurs nicht ausgeführt), leisten unter Windows das, was die obige bash-Sitzung leistet:
3.4.5. Zuweisung des Werts eines Ausdrucks an eine Variable
Hier betrachten wir die Operation [variable = expression;]. Der Ausdruck kann arithmetisch, relational, boolesch, eine Zeichenkette usw. sein.
3.4.5.1. Interpretation der Zuweisungsoperation
Die Operation [variable = expression;] ist selbst ein Ausdruck, der wie folgt ausgewertet wird:
- die rechte Seite der Zuweisung wird ausgewertet: Das Ergebnis ist ein Wert V;
- der Wert V wird der Variablen zugewiesen;
- der Wert V ist zugleich der Wert der Zuweisung, die nun als Ausdruck betrachtet wird.
Somit ist die Operation [V1 = V2 = expression] gültig. Da der Operator = von rechts nach links ausgewertet wird, erhalten wir [V1 = (V2 = expression)]. Der Ausdruck [V2 = expression] wird ausgewertet und hat den Wert V. Durch seine Auswertung wurde V an V2 zugewiesen. Anschließend wird der nächste Operator = als [V1 = V] ausgewertet. Der Wert dieses Ausdrucks ist weiterhin V; seine Auswertung bewirkt, dass V an V1 zugewiesen wird. Die Operation [V1 = V2 = expression] ist also ein Ausdruck, dessen Auswertung:
- bewirkt, dass der Wert von [expression] den Variablen V1 und V2 zugewiesen wird;
- den Wert von [expression] zurückgibt.
Dies lässt sich auf einen Ausdruck der Form [V1 = V2 = ... = Vn = expression] verallgemeinern.
3.4.5.2. Arithmetische Ausdrücke
In arithmetischen Ausdrücken werden die folgenden Operatoren verwendet:
Operator | Beschreibung |
+ | Addition |
- | Subtraktion |
* | Multiplikation |
/ | Division: Das Ergebnis ist der exakte Quotient, wenn mindestens einer der Operanden eine reelle Zahl ist. Sind beide Operanden ganze Zahlen, ist das Ergebnis der ganzzahlige Quotient. So ergibt 5/2 den Wert 2 und 5.0/2 den Wert 2.5 |
% | Rest der Division (Modulo), unabhängig von der Art der Operanden. Der Rest hat dasselbe Vorzeichen wie der Dividend: -5 % 2 ergibt -1 |
Es gibt verschiedene mathematische Funktionen. Hier einige davon:
Funktion | Beschreibung |
[double Sqrt(double x)] | Quadratwurzel |
[double Cos(double x)], [Sin], [Tan] | Kosinus, Sinus, Tangens (Winkel im Bogenmaß) |
[double Pow(double x, double y)] | x hoch y |
[double Exp(double x)] | Exponentialfunktion |
[double Log(double x)], [Log10], [Log2] | natürlicher Logarithmus, dekadischer Logarithmus, Logarithmus zur Basis 2 |
[Abs(x)], [Max(x, y)], [Min(x, y)] | Absolutwert, Maximum, Minimum (für alle numerischen Typen) |
[Floor(x)], [Ceiling(x)], [Truncate(x)] | untere ganze Zahl (abrunden), obere ganze Zahl (aufrunden), Abschneiden |
[Round(x)], [Round(x, n)] | Runden auf die nächste ganze Zahl, auf n Nachkommastellen |
[Math.PI], [Math.E] | die Konstanten π und e |
Alle diese Funktionen sind in einer .NET-Klasse namens Math definiert. Bei ihrer Verwendung müssen Sie ihnen den Namen der Klasse voranstellen, in der sie definiert sind. Sie würden also schreiben:
Der Kurs von 2008 enthielt an dieser Stelle die vollständige Definition der Klasse [Math]: Heute finden Sie sie in der Online-Dokumentation zu .NET, learn.microsoft.com/dotnet/api/system.math.
Das Programm [basics-11.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 3: Die Division zweier ganzer Zahlen ist eine ganzzahlige Division;
- Zeile 5: Der Rest hat dasselbe Vorzeichen wie der Dividend; der Operator % ist auch auf reelle Zahlen anwendbar;
- Zeile 8: Die Division einer reellen Zahl durch null löst keinen Fehler aus; sie liefert unendlich (angezeigt als ∞) oder den Sonderwert NaN („Not a Number“) für 0/0. Die Division einer ganzen Zahl durch null löst dagegen eine [DivideByZeroException]-Ausnahme aus;
- Zeilen 11–12: das obige Beispiel;
- Zeile 18: [Floor] rundet ab, [Ceiling] rundet auf, [Truncate] rundet in Richtung null;
- Zeile 20: Standardmäßig rundet [Math.Round] einen Wert, der genau in der Mitte liegt, auf die nächste gerade Zahl („Banker’s Rounding“): 2.5 wird zu 2 und 3.5 wird zu 4;
- Zeile 21: Für das in der Schule gelehrte Rundungsverfahren (2.5 wird zu 3) geben Sie den Rundungsmodus an;
- Zeile 25: Operatorrangfolge, wie unten dargestellt;
- Zeile 29: eine Mehrfachzuweisung.
3.4.5.3. Reihenfolge der Auswertung arithmetischer Ausdrücke
Bei der Auswertung eines arithmetischen Ausdrucks gilt die folgende Reihenfolge (von der höchsten zur niedrigsten Priorität):
Operatoren innerhalb desselben Blocks [ ] haben dieselbe Priorität. Bei gleicher Priorität erfolgt die Auswertung von links nach rechts: 10 - 4 - 3 wird als (10 - 4) - 3 = 3 ausgewertet.
3.4.5.4. Relationale Ausdrücke
Die Operatoren sind: <, <=, ==, !=, >, >=. Ihre Priorität ist:
- >, >=, <, <=;
- ==, !=.
Das Ergebnis eines relationalen Ausdrucks ist der boolesche Wert [false] , wenn der Ausdruck falsch ist, andernfalls [true].
Vergleich zweier Zeichen
Seien C1 und C2 zwei Zeichen. Sie können mit den Operatoren <, <=, ==, !=, >, >= verglichen werden. Dabei werden ihre Unicode-Codes verglichen, die Zahlen sind. Gemäß der Unicode-Reihenfolge gelten die folgenden Beziehungen:
Vergleich zweier Zeichenketten
Sie werden Zeichen für Zeichen verglichen. Die erste Ungleichheit, die zwischen zwei Zeichen auftritt, führt zu einer Ungleichheit derselben Richtung für die Zeichenketten. Betrachten Sie den Vergleich der Zeichenketten „Cart“ und „Cat“:
Diese letzte Ungleichung erlaubt den Schluss, dass „Cart“ < „Cat“ gilt. Betrachten Sie nun den Vergleich der Zeichenketten „Cat“ und „Catkin“. Sie sind gleich, bis die Zeichenkette „Cat“ erschöpft ist. In diesem Fall gilt die erschöpfte Zeichenkette als die „kleinere“. Es gilt also die Beziehung „Cat“ < „Catkin“.
Funktionen zum Vergleich zweier Zeichenketten
Mit den relationalen Operatoren == und != können Sie testen, ob zwei Zeichenketten gleich sind, oder mit der Methode [Equals] der Klasse [System.String]. Für die Beziehungen <, <=, > und >= sind die Operatoren auf Zeichenketten nicht anwendbar: Sie müssen die Methode [CompareTo] der Klasse [System.String] oder die statische Methode [string.Compare] verwenden. Sie liefern eine ganze Zahl:
- null, wenn die beiden Zeichenketten gleich sind;
- positiv, wenn Zeichenkette 1 größer ist als Zeichenkette 2;
- negativ, wenn Zeichenkette 1 kleiner ist als Zeichenkette 2.
Es gibt eine Feinheit: [CompareTo] und [string.Compare] vergleichen nicht einfach Unicode-Codes. Sie folgen den Sortierregeln der aktuellen Kultur, wie in einem Wörterbuch: Im Französischen steht „élan“ vor „face“, obwohl der Code von ‚é‘ (233) größer ist als der von ‚f‘ (102). Um den Vergleichsmodus zu wählen, akzeptieren [string.Compare] und [Equals] einen Parameter vom Typ [StringComparison]:
- [StringComparison.Ordinal]: zeichenweiser Vergleich der Unicode-Codes. Dies ist der schnellste Vergleich; er sollte für Bezeichner, Schlüsselwörter und Dateinamen verwendet werden;
- [StringComparison.OrdinalIgnoreCase]: wie oben, jedoch ohne Beachtung der Groß- und Kleinschreibung;
- [StringComparison.CurrentCulture] (der Standardwert von [CompareTo]): folgt den üblichen kulturspezifischen Konventionen zum Sortieren von Text, der für Benutzer bestimmt ist.
Der Operator == und die Methode [Equals] ohne Parameter führen einen ordinalen Vergleich durch.
Das Programm [basics-12.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 3: ein relationaler Ausdruck;
- Zeile 7: Zeichenvergleich;
- Zeile 8: Die Konvertierung [(int)] eines Zeichens liefert seinen Unicode-Code;
- Zeile 12: Der Variablen [n] wird eine negative ganze Zahl zugewiesen, weil „cat“ < „dog“ gilt;
- Zeile 13: Die Variable [equal] hat den Wert [true] , wenn die beiden Zeichenketten gleich sind, [false] andernfalls;
- Zeile 15: Mit den Operatoren == und != wird geprüft, ob zwei Zeichenketten gleich sind. In einer Zeichenketteninterpolation steht \" für ein Anführungszeichen;
- Zeile 16: Die Zeichenkette, die zuerst erschöpft ist, ist die kürzere;
- Zeilen 19–20: Vergleiche nach französischen Konventionen: „élan“ steht vor „face“, und „Cat“ steht nach „cat“ (bei gleicher Buchstabenzahl stehen Kleinbuchstaben vor Großbuchstaben);
- Zeilen 22–23: ordinale Vergleiche: Das Ergebnis ist hier die Differenz zwischen den Codes der ersten abweichenden Zeichen: 233 – 102 = 131 und 67 – 99 = –32;
- Zeilen 25–27: Wird die Groß- und Kleinschreibung ignoriert, sind „Cat“ und „cat“ gleich.
3.4.5.5. Boolesche Ausdrücke
Als Operatoren stehen UND (&&), ODER (||) und NICHT (!) zur Verfügung. Das Ergebnis eines booleschen Ausdrucks ist ein boolescher Wert. Operatorpriorität:
- ! ;
- && ;
- ||.
Relationale Operatoren haben eine höhere Priorität als die Operatoren && und ||. Diese beiden Operatoren werten ihren rechten Operanden nur aus, wenn es nötig ist: In [a && b] wird b nicht ausgewertet, wenn a falsch ist; in [a || b] wird b nicht ausgewertet, wenn a wahr ist. Man spricht von „Kurzschlussauswertung“. Daher ist es unbedenklich, [text != null && text.Length > 0] zu schreiben.
3.4.5.6. Bitweise Operationen
Seien [i] und [j] zwei ganze Zahlen:
Operation | Beschreibung |
i << n | Verschiebt i um n Bits nach links. Die nachrückenden Bits sind Nullen |
i >> n | Verschiebt i um n Bits nach rechts. Ist i eine vorzeichenbehaftete ganze Zahl ([sbyte], [short], [int], [long]), bleibt das Vorzeichenbit erhalten |
i >>> n | vorzeichenlose Rechtsverschiebung (C# 11): Die nachrückenden Bits sind Nullen, auch wenn i vorzeichenbehaftet ist |
i & j | führt die bitweise logische UND-Verknüpfung von i und j aus |
i | j | führt die bitweise logische ODER-Verknüpfung von i und j aus |
~i | bildet das Einerkomplement von i |
i ^ j | führt die bitweise EXKLUSIV-ODER-Verknüpfung von i und j aus |
Das Programm [basics-13.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 4: Das Format {0:x4} zeigt den Parameter Nr. 0 hexadezimal (x) mit 4 Ziffern (4) an;
- Zeile 7: Operationen auf den Bits eines [short] ergeben einen [int]; dieser wird zurück in einen [short] konvertiert, um 4 Hexadezimalziffern anzuzeigen. Ohne Konvertierung würde ~i mit 8 Ziffern angezeigt (ffffff9b);
- Zeile 10: Das Format B16 zeigt eine 16-stellige binäre ganze Zahl an. Wir prüfen Bit für Bit die logische UND-Verknüpfung von i und j;
- Zeile 13: Die Verschiebung [>>] erhält das Vorzeichenbit von m, das negativ ist; die Verschiebung [>>>] füllt mit Nullen auf.
3.4.5.7. Kombination von Operatoren
[a = a + b] kann als [a += b] geschrieben werden; [a = a - b] kann als [a -= b] geschrieben werden. Dasselbe gilt für die Operatoren /, %, *, <<, >>, >>>, &, |, ^. So kann [a = a / 2;] als [a /= 2;] geschrieben werden.
3.4.5.8. Inkrement- und Dekrementoperatoren
Die Schreibweise [variable++] bedeutet [variable = variable + 1] oder [variable += 1]. Die Schreibweise [variable--] bedeutet [variable = variable - 1] oder [variable -= 1]. In einem Ausdruck haben diese Operatoren zwei Formen:
- [i++] (Postfix): Der Wert des Ausdrucks ist der Wert von i vor dem Inkrement;
- [++i] (Präfix): Der Wert des Ausdrucks ist der Wert von i nach dem Inkrement.
3.4.5.9. Der ternäre Operator ?:
Der Ausdruck [expr_cond ? expr1 : expr2] wird wie folgt ausgewertet:
- Der Ausdruck [expr_cond] wird ausgewertet. Es handelt sich um einen booleschen Ausdruck;
- ist er wahr, ist der Wert des Ausdrucks der von [expr1], und [expr2] wird nicht ausgewertet;
- ist er falsch, geschieht das Gegenteil: Der Wert des Ausdrucks ist der von [expr2], und [expr1] wird nicht ausgewertet.
Die Operation [i = (j > 4 ? j + 1 : j - 1);] weist der Variablen i den Wert j+1 zu, wenn j > 4 gilt, andernfalls j-1. Das entspricht der Schreibweise [if (j > 4) i = j + 1; else i = j - 1;], ist aber kompakter.
3.4.5.10. Die Operatoren ??, ??= und ?.
Diese Operatoren erleichtern den Umgang mit Werten [null]:
- [a ?? b] (C# 2) ergibt a, wenn a ungleich [null] ist, andernfalls b. Er dient dazu, einen Ersatzwert bereitzustellen: [string name = Console.ReadLine() ?? "";]. Das Ergebnis ist nicht mehr nullable;
- [a ??= b] (C# 8) weist a nur dann b zu, wenn a gleich [null] ist;
- [a?.Member] (C# 6) ist [null] , wenn a [null] ist, andernfalls [a.Member]. So verursacht [text?.Length] keinen Fehler, wenn [text] gleich [null] ist; das Ergebnis hat den Typ [int?].
Das Programm [basics-14.cs] kombiniert diese verschiedenen Operatoren:
Ergebnisse:
Kommentare:
- Zeile 4: ein boolescher Ausdruck;
- Zeilen 9–17: kombinierte Operatoren: 10+5=15, 15*2=30, 30/4=7 (ganzzahlige Division), 7%4=3, 3<<2=12;
- Zeile 22: [j] wird 5 zugewiesen, dann wird [i] auf 6 gesetzt;
- Zeile 23: [i] wird zu 7, dann erhält [k] den Wert 7;
- Zeilen 30–31: zwei ternäre Operatoren;
- Zeile 36: [input] ist gleich [null]: [name] erhält „unknown“. Der Typ von [name] ist [string], nicht [string?];
- Zeile 38: Der Operator ?? ermöglicht es, einen [int?] ohne Ausnahmerisiko in einen [int] zu konvertieren;
- Zeilen 42–43: Die erste Zuweisung erfolgt, weil [title] gleich [null] ist; die zweite Zuweisung erfolgt nicht;
- Zeile 47: [text] ist gleich [null], also ist es auch [length];
- Zeile 48: Die Operatoren werden kombiniert: Ist [length] gleich [null], wird die Zeichenkette „null“ angezeigt.
3.4.5.11. Allgemeine Operatorrangfolge
Die folgende Tabelle listet die Operatorrangfolge von der höchsten zur niedrigsten Priorität auf:
Operatoren | Assoziativität |
[x.y] [x?.y] [f(x)] [a[i]] [x++] [x--] [new] [typeof] [checked] [nameof] | lr |
[+x] [-x] [!x] [~x] [++x] [--x] [^x] [(T)x] (Typänderung) | rl |
[x..y] (Bereich) | lr |
[switch] (switch-Ausdruck) | lr |
[*] [/] [%] | lr |
[+] [-] | lr |
[<<] [>>] [>>>] | lr |
[<] [<=] [>] [>=] [is] [as] | lr |
[==] [!=] | lr |
[&] | lr |
[^] | lr |
[|] | lr |
[&&] | lr |
[||] | lr |
[??] | rl |
[? :] (ternär) | rl |
[=] [+=] [-=] [??=] usw., [=>] | rl |
lr bedeutet, dass bei gleicher Priorität von links nach rechts ausgewertet wird: Enthält ein Ausdruck Operatoren gleicher Priorität, wird der am weitesten links stehende Operator zuerst ausgewertet. rl bedeutet Auswertung von rechts nach links. Im Zweifelsfall setzen Sie ruhig Klammern: Sie machen den Ausdruck außerdem lesbarer.
3.4.5.12. Typumwandlung
In einem Ausdruck ist es möglich, die Darstellung eines Werts vorübergehend zu ändern. Man spricht von „Typumwandlung“ (Type Casting). Die Syntax zur Änderung des Typs eines Werts in einem Ausdruck lautet wie folgt:
Der Wert nimmt dann den angegebenen Typ an. Dies führt zu einer Änderung der Darstellung des Werts. Man unterscheidet:
- implizite Konvertierungen, die der Compiler automatisch durchführt, wenn dabei keine Information verloren geht: von einem [int] in einen [long], von einem [int] in einen [double], von einem [char] in einen [int] und so weiter. Auch die Konvertierung von einem [long] in einen [double] erfolgt implizit, obwohl sie jenseits von 2⁵³ an Genauigkeit verlieren kann;
- explizite Konvertierungen, bei denen Information verloren gehen kann und die der Programmierer mit der Schreibweise (Typ) ausdrücklich anfordern muss: von einem [double] in einen [int] (der Nachkommateil geht verloren), von einem [long] in einen [int] (die höchstwertigen Bits gehen verloren) usw.
Standardmäßig wird ein Überlauf bei einer Ganzzahlberechnung oder einer Ganzzahlkonvertierung nicht gemeldet: Das Ergebnis ist schlicht falsch. Das Schlüsselwort [checked] bewirkt dagegen, dass ein Überlauf eine [OverflowException]-Ausnahme auslöst. Es lässt sich auf einen Ausdruck anwenden, [checked(expression)], oder auf einen Anweisungsblock, [checked { ... }].
Das Programm [basics-15.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 3: [f1] hat den Wert 0. Die Division 3/4 ist eine ganzzahlige Division, da beide Operanden den Typ [int] haben; ihr Ergebnis 0 wird anschließend in [float] konvertiert;
- Zeile 4: [(float)i] ist der Wert von [i] , konvertiert in [float]. Wir haben nun eine Division zwischen einer reellen Zahl vom Typ [float] und einer ganzen Zahl vom Typ [int]: Der Wert von [j] wird ebenfalls in [float] umgewandelt, und dann werden die beiden reellen Zahlen dividiert. [f2] hat den Wert 0.75. In der Operation [(float)i] ist [i] ein Wert, der exakt als 4-Byte-Zahl codiert ist, während [(float)i] derselbe Wert als näherungsweise codierte reelle 4-Byte-Zahl ist. Diese Umcodierung findet nur während der Berechnung statt: Die Variable [i] behält stets ihren Typ [int];
- Zeilen 8–9: implizite Konvertierungen;
- Zeile 14: Bei der Konvertierung einer Gleitkommazahl in eine ganze Zahl wird der Nachkommateil abgeschnitten;
- Zeile 15: Zum Runden verwenden wir [Math.Round], das einen [double]liefert, und konvertieren dann;
- Zeile 18: 3 Milliarden passen nicht in einen [int]: Es bleiben nur die niederwertigen 32 Bits erhalten, und das Ergebnis ergibt keinen Sinn mehr;
- Zeilen 22–23: Konvertierungen zwischen Zeichen und Unicode-Codes; die zweite ist implizit;
- Zeile 28: Der Kapazitätsüberlauf bleibt unbemerkt: Man erhält den kleinstmöglichen [int]-Wert;
- Zeile 33: Mit [checked] löst der Überlauf eine [OverflowException]-Ausnahme aus;
- Zeilen 42–45: ein [checked]-Block: Auch die Konvertierung von [large] in [int] löst eine Ausnahme aus.
Tritt der Überlauf in einem Ausdruck auf, der ausschließlich aus Konstanten besteht, etwa [int.MaxValue + 1], erkennt der Compiler ihn und weist das Programm zurück.
3.5. Anweisungen zur Steuerung des Programmablaufs
3.5.1. Anhalten
Die Methode [Exit] der Klasse [Environment] erlaubt es, die Ausführung eines Programms anzuhalten:
[Exit] beendet den aktuellen Prozess und gibt die Kontrolle an den aufrufenden Prozess zurück, in der Regel den Befehlsinterpreter. Der Wert von [status], der Rückgabecode genannt wird, kann vom Befehlsinterpreter ausgewertet werden. Per Konvention bedeutet 0, dass das Programm erfolgreich beendet wurde, jeder andere Wert zeigt einen Fehler an. Unter Windows steht der Rückgabecode in der Eingabeaufforderung in der Variablen [%ERRORLEVEL%] und in PowerShell in der Variablen [$LASTEXITCODE] zur Verfügung; unter Linux und macOS steht er in der Variablen [$?] der Shell zur Verfügung. Somit:
beendet das Programm mit dem Rückgabecode 0. Bei Anweisungen auf oberster Ebene beendet auch eine [return]-Anweisung das Programm (Rückgabecode 0), sofern sie sich nicht innerhalb einer Funktion befindet.
Das Programm [basics-16.cs] erhält seinen Rückgabecode als Argument:
Ergebnisse in einem bash-Terminal:
Kommentare:
- Zeile 4: Wir prüfen, ob ein Argument übergeben wurde und ob es eine ganze Zahl ist. Die Argumente des Programms werden später beschrieben;
- Zeile 7: Ist dies nicht der Fall, wird das Programm mit dem Rückgabecode 1 beendet;
- Zeile 8: Diese Anweisung wird nie ausgeführt, aber der Compiler weiß nicht, dass [Environment.Exit] die Kontrolle nie zurückgibt. Ohne sie würde der Compiler annehmen, dass die nächste Zeile mit einer nicht initialisierten Variablen [code] erreicht werden könnte, und das Programm zurückweisen;
- Zeile 11: Beendet das Programm mit dem als Argument übergebenen Rückgabecode. Die folgende Zeile wird nicht ausgeführt;
- Zeilen 4–9: Der Befehl [echo $?] zeigt den Rückgabecode des zuletzt ausgeführten Programms an: 3, dann 1.
3.5.2. Einfache Entscheidungsstruktur
Hinweise:
- die Bedingung steht in runden Klammern;
- jede Aktion endet mit einem Semikolon;
- auf geschweifte Klammern folgt kein Semikolon;
- geschweifte Klammern sind nur erforderlich, wenn es mehr als eine Aktion gibt; sie werden jedoch häufig auch bei einer einzelnen Aktion gesetzt, der Lesbarkeit wegen und um Fehler beim Hinzufügen einer Aktion zu vermeiden;
- die Klausel [else] kann entfallen;
- es gibt kein Schlüsselwort [then].
Das algorithmische Gegenstück dieser Struktur ist die Struktur if...then...else:
Beispiel:
Auswahlstrukturen können verschachtelt werden. Das führt manchmal zu dem Problem, das das Programm [basics-17.cs] veranschaulicht:
Ergebnisse:
Kommentare:
- Zeilen 4–8: Auf welches [if] bezieht sich das [else] in Zeile 7? Die Regel lautet: Ein [else] bezieht sich immer auf das nächstgelegene [if], hier [if (n > 6)] in Zeile 5. Die Einrückung des Codes, die für den Compiler ohne Bedeutung ist, wurde so gewählt, dass sie dies veranschaulicht;
- Zeilen 12–21: Hier wollte man ein [else] neben [if (n2 > 1)], und nicht ein [else] neben [if (n2 > 6)] platzieren. Wegen der vorherigen Regel müssen wir [if (n2 > 1) { ... }] in geschweifte Klammern setzen;
- Zeilen 27–41: Eine Folge sich gegenseitig ausschließender Auswahlmöglichkeiten wird mit aufeinanderfolgenden [else if] geschrieben. Die Bedingungen werden der Reihe nach geprüft; die erste wahre Bedingung bestimmt die auszuführende Aktion.
3.5.3. Fallunterscheidung
3.5.3.1. Die Anweisung switch
Die Syntax lautet wie folgt:
Hinweise:
- Der Wert des Kontrollausdrucks in [switch] kann eine ganze Zahl, ein Zeichen, eine Zeichenkette, ein Aufzählungswert usw. sein;
- der Kontrollausdruck steht in runden Klammern;
- Die Klausel [default] kann fehlen;
- die Werte vi sind mögliche Werte des Ausdrucks. Hat der Ausdruck den Wert vi, werden die Aktionen ausgeführt, die auf die Klausel [case vi] folgen;
- die Anweisung [break] verlässt die Fallunterscheidung;
- Jeder Anweisungsblock, der einem Wert vi zugeordnet ist, muss mit einer Sprunganweisung enden ([break], [return], [throw], ...); andernfalls meldet der Compiler einen Fehler. Allerdings können mehrere [case]-Klauseln ohne Anweisungen dazwischen aufeinanderfolgen: In diesem Fall teilen sie sich dieselben Aktionen.
Beispiel in der Algorithmik:
3.5.3.2. Der switch-Ausdruck
Sehr oft dient eine Fallunterscheidung ausschließlich dazu, einen Wert auszuwählen. C# 8 hat hierfür den switch-Ausdruck eingeführt:
Der Ausdruck wird nacheinander mit den Mustern verglichen; der Wert des ersten passenden Musters ist das Ergebnis. Das Muster \_ passt auf alle Werte: Es fungiert als Platzhalter. Ein Muster kann sein:
- eine Konstante: [0], ["saturday"];
- ein relationales Muster (C# 9): [< 0], [>= 18];
- eine Kombination von Mustern mit [and], [or], und [not] (C# 9): [> 0 and <= 10], ["saturday" or "sunday"].
Dieselben Muster werden mit dem Operator [is] verwendet: [day is "saturday" or "sunday"] ist wahr, wenn [day] „saturday“ oder „sunday“ ist. In den folgenden Kapiteln lernen wir weitere Formen davon kennen.
Das Programm [basics-18.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeilen 4–15: die C#-Umsetzung des obigen Algorithmus;
- Zeile 7: Bei Anweisungen auf oberster Ebene beendet [return] das Programm;
- Zeilen 24–25: zwei Werte für dieselben Aktionen;
- Zeilen 34–38: ein switch-Ausdruck auf eine Zeichenkette. Die Muster werden mit [or] kombiniert;
- Zeile 49: das Muster [not] mit dem Operator [is];
- Zeilen 53–60: zwei lokale Funktionen;
- Zeilen 63–69: eine lokale Funktion, deren Rumpf ein switch-Ausdruck ist. Die Schreibweise => ersetzt den in geschweifte Klammern gesetzten Rumpf und die Anweisung [return]; man spricht von einem Ausdruckskörper. Die relationalen Muster klassifizieren die ganze Zahl [n].
3.5.4. Wiederholungsstrukturen
3.5.4.1. Bekannte Anzahl von Wiederholungen
Die for-Struktur
Die Syntax lautet wie folgt:
Hinweise:
- Die drei Argumente von [for] stehen in runden Klammern und sind durch Semikolons getrennt;
- Jede Aktion in [for] wird durch ein Semikolon abgeschlossen;
- geschweifte Klammern sind nur erforderlich, wenn es mehr als eine Aktion gibt;
- auf die geschweifte Klammer folgt kein Semikolon.
Das algorithmische Gegenstück ist die Struktur for:
die sich in eine while-Struktur übersetzen lässt:
Die foreach-Struktur
Die Syntax lautet wie folgt:
Hinweise:
- [collection] ist eine aufzählbare Sammlung von Objekten. Die aufzählbare Sammlung, die wir bereits kennen, ist das Array; weitere ([List<T>], [Dictionary<K, V>], ...) lernen wir in Kapitel 5 kennen;
- [Type] ist der Typ der Objekte der Sammlung. Bei einem Array ist dies der Typ der Array-Elemente. Wir können stattdessen [var] schreiben;
- [variable] ist eine lokale Variable der Schleife, die nacheinander alle Werte der Sammlung annimmt. Sie kann innerhalb der Schleife nicht verändert werden.
3.5.4.2. Unbekannte Anzahl von Wiederholungen
Die while-Schleife
Die Schleife läuft, solange die Bedingung wahr ist. Es ist möglich, dass die Schleife nie ausgeführt wird. Die Hinweise sind dieselben wie für [for]. Die entsprechende algorithmische Struktur ist die Struktur while:
Die „do while“-Schleife
Die Syntax lautet wie folgt:
Die Schleife läuft, bis die Bedingung falsch wird. Hier wird die Schleife mindestens einmal ausgeführt. Die entsprechende algorithmische Struktur ist die Struktur „repeat … until“:
Allgemeine Schleifenstruktur (for)
Die Syntax lautet wie folgt:
Die Schleife läuft, solange die Bedingung wahr ist (vor jedem Durchlauf ausgewertet). Die Anweisungen [start_instructions] werden ausgeführt, bevor die Schleife zum ersten Mal betreten wird. Die Anweisungen [end_of_loop_instructions] werden nach jedem Durchlauf der Schleife ausgeführt. Die verschiedenen Anweisungen in [start_instructions] und [end_of_loop_instructions] werden durch Kommas getrennt. Die entsprechende algorithmische Struktur lautet wie folgt:
3.5.4.3. Anweisungen zur Schleifensteuerung
Anweisung | Beschreibung |
[break] | Verlässt die Schleife [for], [foreach], [while], [do ... while] |
[continue] | springt zum nächsten Durchlauf der Schleifen [for], [foreach], [while], [do ... while] |
3.5.4.4. Beispiele
Das Programm [basics-19.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeilen 3–30: vier Möglichkeiten, die Summe der ersten 10 ganzen Zahlen zu berechnen;
- Zeilen 4–8: ein klassisches [for];
- Zeilen 10–13: Die gesamte Arbeit erfolgt in den Anweisungen am Schleifenende; der Schleifenrumpf ist leer. Der Kurs von 2008 verwendete [for (...) ;]: C# akzeptiert diese leere Anweisung, aber der Compiler gibt eine Warnung aus („possible invalid empty statement“), weil ein versehentlich hinter ein [for] gesetztes Semikolon ein klassischer Fehler ist. Ein leerer Block { } drückt dasselbe eindeutig aus;
- Zeile 28: [i++] liefert den Wert von [i] vor dessen Inkrementierung: [i] wird zu [sum] addiert, dann wird [i] inkrementiert;
- Zeile 34: die gebräuchlichste Form von [for]: Die Schleifenvariable wird in [for] deklariert und existiert nur innerhalb der Schleife;
- Zeilen 41–42: Die Schleife [foreach] durchläuft die Elemente des Arrays [friends];
- Zeilen 51–58: [continue] springt bei geraden Zahlen zum nächsten Durchlauf; [break] beendet die Schleife, sobald [k] größer als 7 ist;
- Zeilen 66–74: eine Endlosschleife [while (true)] , die über [break] verlassen wird. Diese Form ist praktisch, wenn die Abbruchbedingung mitten in der Schleife berechnet wird. Wir werden sie für Tastatureingaben verwenden.
3.6. Ausnahmebehandlung
Viele .NET-Methoden können Ausnahmen auslösen, also Fehler. Wenn eine Methode eine Ausnahme auslösen kann, sollte der Programmierer sie behandeln, um Programme fehlertoleranter zu machen: Ein abrupter Abbruch einer Anwendung sollte stets vermieden werden.
3.6.1. Die Struktur try/catch/finally
Die Ausnahmebehandlung folgt diesem Schema:
Löst der Code im Block [try] keine Ausnahme aus, wird mit der nächsten Anweisung fortgefahren; andernfalls wird der Rumpf des Blocks [catch] ausgeführt und danach die nächste Anweisung. Beachten Sie folgende Punkte:
- [e] ist ein Objekt vom Typ [Exception] oder von einem abgeleiteten Typ. Es gibt viele Arten von Ausnahmen: [IndexOutOfRangeException], [FormatException], [OverflowException], [ArgumentException] usw. Mit [catch (Exception e)] geben Sie an, dass Sie alle Arten von Ausnahmen behandeln möchten. Kann der Code der Klausel [try] mehrere Arten von Ausnahmen erzeugen, sollten Sie gegebenenfalls genauer vorgehen und die Ausnahme mit mehreren [catch]-Klauseln behandeln:
Die [catch]-Klauseln werden der Reihe nach ausgewertet; die erste, deren Typ zur Ausnahme passt, wird ausgeführt. Eine Klausel [catch (Exception e)] muss daher an letzter Stelle stehen;
- den Klauseln [finally] kann eine Klausel [try / catch] hinzugefügt werden:
Ob eine Ausnahme auftritt oder nicht: Der Code der Klausel [finally] wird immer ausgeführt. Damit können Sie zum Beispiel eine Datei schließen;
- in der Klausel [catch] möchten Sie das verfügbare Objekt [Exception] unter Umständen nicht verwenden. Statt [catch (Exception e) { ... }] schreiben Sie dann [catch (Exception) { ... }] oder, einfacher, [catch { ... }];
- die Klasse [Exception] hat eine Eigenschaft [Message] , die den aufgetretenen Fehler näher beschreibt. Um sie anzuzeigen, schreiben Sie:
- Die Klasse [Exception] hat eine Methode [ToString] , die eine Zeichenkette mit dem Ausnahmetyp, dem Wert der Eigenschaft [Message] und dem Aufrufstapel zurückgibt, also der Liste der Methoden, die zum Zeitpunkt des Fehlers ausgeführt wurden, samt Namen der Quelldatei und Zeilennummer. Dies sind die nützlichsten Informationen für den Entwickler, sie sind aber nicht für den Benutzer bestimmt. In diesem Kurs zeigen wir meist den Namen des Ausnahmetyps, [ex.GetType().Name], und die zugehörige Meldung an.
3.6.2. Ein erstes Beispiel
Das Programm [basics-20.cs] zeigt eine Ausnahme, die durch den Zugriff auf ein nicht existierendes Array-Element erzeugt wird:
Ergebnisse:
Kommentare:
- Zeile 16: Diese Anweisung löst eine Ausnahme aus, weil das Array [tab] kein Element mit dem Index 100 hat;
- Zeile 20: Die Ausnahme ist vom Typ [System.IndexOutOfRangeException] (Zeile 10 der Ergebnisse);
- Zeile 21: Das Programm wird beendet;
- Zeilen 23–25: Die Klausel [finally] wurde ausgeführt (Zeile 11 der Ergebnisse), obwohl die Klausel [catch] eine Anweisung [return] enthielt. Beachten Sie, dass die Klausel [finally] immer ausgeführt wird;
- Zeile 27: Wegen [return] wird diese Zeile nicht ausgeführt.
3.6.3. Eine kontrollierte Eingabe
Hier ein weiteres Beispiel, [basics-21.cs], in dem wir die Ausnahme behandeln, die durch die Umwandlung einer Zeichenkette, die keine ganze Zahl darstellt, in eine ganze Zahl entsteht:
Ergebnisse:
Kommentare:
- Zeile 4: Ist der Eingabestream geschlossen, liefert [ReadLine] den Wert [null]: Er wird durch eine leere Zeichenkette ersetzt. Die Variable [name] kann daher den Typ [string] haben;
- Zeilen 8–23: die Schleife zur Eingabe des Alters;
- Zeile 15: Die über die Tastatur eingegebene Zeile wird mit der Methode [int.Parse] in eine ganze Zahl umgewandelt. Diese Methode löst eine Ausnahme aus, wenn die Umwandlung nicht möglich ist. Deshalb wurde die Operation in ein [try / catch] gesetzt;
- Zeile 16: Wird diese Zeile erreicht, war die Umwandlung erfolgreich. Wir prüfen jedoch, ob die erhaltene ganze Zahl größer oder gleich 1 ist;
- Zeile 18: Wird eine [FormatException]-Ausnahme ausgelöst, geht die Kontrolle an [catch] über, wo keine Aktion erfolgt. Die boolesche Variable [ageOK], die mit [false] initialisiert wurde, bleibt somit auf [false]. Der Code des Kurses von 2008 schrieb [catch { }], was alle Ausnahmen abfängt: Das wird nicht empfohlen, weil dadurch auch Fehler verdeckt werden, mit denen man nicht gerechnet hat;
- Zeilen 21–23: Ist das Alter fehlerhaft, wird eine Fehlermeldung angezeigt.
Dieses Programm hat eine Schwäche: Ein Alter wie 99999999999 löst eine [OverflowException]-Ausnahme aus, die nicht abgefangen wird und zum Abbruch des Programms führt. Wir könnten eine [catch]-Klausel hinzufügen; einfacher ist es jedoch, [int.TryParse] zu verwenden, wie es die folgende Beispielanwendung tun wird. Ausnahmen heben wir uns für wirklich außergewöhnliche Situationen auf.
3.6.4. Mehrere catch-Klauseln, Filter und das Auslösen von Ausnahmen
Das Programm selbst kann mit der Anweisung [throw] eine Ausnahme auslösen:
Die Ausführung der aktuellen Methode wird angehalten, und die Ausnahme wird durch die aufrufenden Methoden nach oben weitergereicht, bis eine [catch]-Klausel sie behandelt; tut dies keine, wird das Programm beendet und zeigt die Ausnahme an. In einer [catch]-Klausel löst die Anweisung [throw;] (ohne Parameter) die aktuelle Ausnahme erneut aus, zum Beispiel nachdem sie protokolliert wurde.
Ab C# 6 kann auf eine [catch]-Klausel ein [when (condition)] -Filter folgen: Die Klausel wird nur ausgeführt, wenn die Bedingung wahr ist. Ab C# 7 kann [throw] auch als Ausdruck verwendet werden, rechts vom Operator ?? oder innerhalb eines ternären Operators.
Das Programm [basics-22.cs] veranschaulicht diese Möglichkeiten:
Ergebnisse:
Kommentare:
- Zeile 2: simulierte Eingaben, teils gültig, teils ungültig;
- Zeile 7: Die lokale Funktion [ReadAge] kann mehrere Arten von Ausnahmen auslösen;
- Zeile 11: Diese Klausel behandelt eine [FormatException] nur, wenn die Eingabe leer ist;
- Zeile 15: die andere [FormatException];
- Zeile 19: eine Zahl, die für einen [int] zu groß ist;
- Zeile 23: die Ausnahme, die von [ReadAge] selbst ausgelöst wird;
- Zeile 35: ein [throw]-Ausdruck: Ist [name] gleich [null], wird eine [ArgumentNullException]-Ausnahme ausgelöst. Der Operator [nameof] (C# 6) liefert den Namen einer Variablen als Zeichenkette; [ArgumentNullException] fügt ihn seiner Meldung hinzu (Zeile 9 der Ergebnisse);
- Zeile 52: Die Funktion [ReadAge] löst eine Ausnahme aus, wenn das Alter außerhalb der Grenzen liegt.
3.7. Beispielanwendung – V1
Wir wollen ein Programm zur Berechnung der Steuerschuld eines Steuerpflichtigen schreiben. Wir betrachten den vereinfachten Fall eines Steuerpflichtigen, der nur ein einziges Gehalt angeben muss. Die Zahlen stammen aus dem Steuertarif 2004 für die Einkünfte des Jahres 2003 und werden unverändert verwendet: Dies ist eine Programmierübung und keine Berechnung aktueller Steuern. Diese Anwendung wird uns als roter Faden dienen: Wir werden in den folgenden Kapiteln auf sie zurückkommen und dabei Klassen, Dateien, eine Datenbank und schließlich Netzwerkfunktionen einbauen.
- Wir berechnen die Anzahl der Anteile des Arbeitnehmers: Anteile = nbChildren/2 + 1, wenn er ledig ist, nbChildren/2 + 2, wenn er verheiratet ist, wobei nbChildren die Anzahl seiner Kinder ist;
- hat er mindestens drei Kinder, erhält er einen zusätzlichen halben Anteil;
- sein steuerpflichtiges Einkommen R wird als R = 0.72 * S berechnet, wobei S sein Jahresgehalt ist;
- sein Familienquotient wird als QF = R / Anteile berechnet;
- seine Steuer I wird anhand der folgenden Tabelle berechnet:
Schwelle | coeffR | coeffN |
4962 | 0 | 0 |
8382 | 0.068 | 291.09 |
14,753 | 0.191 | 1,322.92 |
23,888 | 0.283 | 2,668.39 |
38,868 | 0.374 | 4,846.98 |
47,932 | 0.426 | 6,883.66 |
0 | 0.481 | 9,505.54 |
Jede Zeile hat 3 Felder. Um die Steuer I zu berechnen, suchen Sie die erste Zeile, in der QF kleiner oder gleich der Grenze ist. Ist beispielsweise QF = 5,000, lautet die gefundene Zeile:
Die Steuer I ist dann gleich 0.068 * R - 291.09 * Anteile, auf den Euro abgeschnitten. Ist QF so beschaffen, dass die Bedingung QF ≤ Grenze nie erfüllt ist, werden die Koeffizienten der letzten Zeile verwendet: I = 0.481 * R - 9505.54 * Anteile. Die Grenze 0 in der letzten Zeile wird also nie verwendet.
Das entsprechende C#-Programm [tax-v1.cs] lautet wie folgt:
Kommentare:
- Zeilen 5–7: Numerische Werte erhalten das Suffix M, damit sie vom Typ [decimal] sind. Der Typ [decimal] codiert Dezimalzahlen wie 0.068 exakt; dies ist der Typ für Finanzberechnungen. Mit einem [double] wäre 0.068 nur eine binäre Näherung;
- Zeilen 10–21: Eingabe des Familienstands in einer [while (true)]-Schleife, die über [break] verlassen wird, wenn die Antwort korrekt ist;
- Zeile 14: [Console.ReadLine()] liefert die Zeichenkette C1 so, wie sie über die Tastatur eingegeben wurde, oder [null] (ersetzt durch ""); [C1.Trim()] entfernt die führenden und nachfolgenden Leerzeichen von C1 und liefert die Zeichenkette C2; [C2.ToLower()] liefert die in Kleinbuchstaben umgewandelte Zeichenkette C2. Dadurch werden sowohl Y als auch y akzeptiert;
- Zeile 15: ein mit [or] kombiniertes Muster;
- Zeile 19: Fehlermeldungen werden in den Stream [Error] geschrieben;
- Zeile 21: Der boolesche Wert [married] erhält den Wert [true] oder [false] aus der Beziehung [answer == "y"];
- Zeile 28: [TryParse] liefert [false] , wenn die Eingabe keine ganze Zahl ist; die Bedingung [nbChildren >= 0] wird dann nicht ausgewertet (der Operator && wird kurzgeschlossen). [TryParse] akzeptiert eine Zeichenkette [null]: Es liefert dann [false]. Anders als in der Version von 2008 werden keine Ausnahmen verwendet;
- Zeile 40: Dasselbe gilt für das Gehalt;
- Zeile 48: Sie können nicht einfach nbChildren / 2 schreiben: Ist nbChildren gleich 3, erhielten Sie 3/2, eine ganzzahlige Division, die 1 ergäbe, nicht 1.5. Da der Divisor 2M vom Typ [decimal] ist, wird die Division als [decimal]-Division ausgeführt. Das Kursmaterial von 2008 verwendete [(decimal)nbChildren / 2], was auf dasselbe hinausläuft;
- Zeilen 62–65: Bestimmung der Steuerstufe. Die Berechnung endet bei der ersten Schwelle, die größer oder gleich dem Familienquotienten ist, spätestens aber bei der letzten Steuerstufe. Die Version von 2008 schrieb zunächst QF in die letzte Zelle der Grenzwerttabelle, damit die Suche dort anhielt: Dadurch wurden die Daten des Steuertarifs verändert; die Bedingung [i < limits.Length - 1] vermeidet diesen Nebeneffekt;
- Zeile 69: Die Steuer wird auf den Euro abgeschnitten, indem sie in [int] umgewandelt wird.
Hier einige Beispiele für die Ausgabe:
Dies sind dieselben Ergebnisse wie im Kurs von 2008: 4,282 Euro für einen verheirateten Steuerpflichtigen mit 2 Kindern und 2,959 Euro mit 3 Kindern bei einem Jahresgehalt von 60,000 Euro. Eine alleinstehende Person ohne Kinder mit demselben Gehalt zahlt 11,519 Euro. Im zweiten Durchlauf wird die Eingabe „60000 euros“ abgelehnt: [int.TryParse] akzeptiert nur Zeichenketten, die eine exakte ganze Zahl darstellen (führende und nachfolgende Leerzeichen sind erlaubt).
3.8. Argumente des Hauptprogramms
Die Hauptfunktion [Main] kann ein Array von Zeichenketten [string[]] als Parameter entgegennehmen. Dieses Array enthält die Kommandozeilenargumente, mit denen die Anwendung gestartet wurde. Wird das Programm P also mit dem folgenden Befehl gestartet:
und ist die Funktion [Main] wie folgt deklariert:
dann gilt args[0]="arg0", args[1]="arg1" und so weiter. Bei Anweisungen auf oberster Ebene schreibt der Programmierer keine Methode [Main], aber das Array [args] steht trotzdem auf dieselbe Weise zur Verfügung: Es ist der Parameter der vom Compiler erzeugten Methode [Main].
Bei [dotnet run] werden die Argumente für das Programm hinter zwei Bindestrichen ([--]) angegeben, die sie von den Optionen des Befehls [dotnet run] selbst trennen:
Der Kurs von 2008 legte die Argumente in den Projekteigenschaften von Visual Studio fest; heute genügt die Kommandozeile. Hier ein Beispiel, [basics-23.cs]:
Ergebnisse:
Ein Argument, das Leerzeichen enthält, muss in Anführungszeichen gesetzt werden:
Dasselbe Programm, geschrieben mit einer klassischen Methode [Main]: [basics-24.cs]:
Ergebnisse:
Kommentare:
- Zeile 2: ein Namespace mit Dateigültigkeitsbereich (C# 10);
- Zeile 4: Eine statische Klasse enthält nur statische Member;
- Zeile 6: der Einstiegspunkt des Programms. Da diese Datei keine Anweisungen auf oberster Ebene enthält, sucht der Compiler nach einer statischen Methode namens [Main];
- Zeile 8: Der Rest ist identisch mit [basics-23.cs].
Die Signatur [static void Main()] ist gültig, wenn die Funktion [Main] keine Parameter hat. [Main] kann auch einen [int] zurückgeben, der dann der Rückgabecode des Programms ist: [static int Main(string[] args)].
3.9. Aufzählungen
Eine Aufzählung (Enumeration) ist ein Datentyp, dessen Wertebereich aus einer Menge benannter ganzzahliger Konstanten besteht. Betrachten Sie ein Programm, das Prüfungsnoten verarbeiten soll. Es gibt fünf mögliche Bewertungen: Pass, FairlyGood, Good, VeryGood und Excellent. Wir können dann für diese fünf Konstanten eine Aufzählung definieren:
Intern werden diese fünf Konstanten als aufeinanderfolgende ganze Zahlen codiert, beginnend mit 0 für die erste Konstante, 1 für die nächste und so weiter. Wir können diese Werte auch explizit festlegen: [enum Honours { Pass = 10, FairlyGood = 12, ... }]. Eine Variable kann so deklariert werden, dass sie ihre Werte aus der Aufzählung bezieht:
Eine Variable kann mit den verschiedenen möglichen Werten der Aufzählung verglichen werden:
So wie der einfache Typ [int] der Struktur [System.Int32] entspricht, leitet sich jede Aufzählung von der Klasse [System.Enum] ab. Diese Klasse besitzt statische Methoden, mit denen Sie die Werte und Namen eines Aufzählungstyps abrufen können:
- [Enum.GetValues<Honours>()] (.NET 5) liefert das Array der Werte der Aufzählung [Honours];
- [Enum.GetNames<Honours>()] liefert das Array ihrer Namen;
- [Enum.TryParse(str, out Honours m)] wandelt eine Zeichenkette in einen Aufzählungswert um.
Der Kurs von 2008 beschrieb [Enum.GetValues(typeof(Honours))]: Diese weiterhin gültige Form liefert ein untypisiertes Array, das anschließend konvertiert werden muss. Die generische Form [GetValues<Honours>()] liefert direkt ein Array vom Typ [Honours[]].
Das Programm [basics-25.cs] veranschaulicht das soeben Beschriebene:
Ergebnisse:
Kommentare:
- Zeile 3: eine Variable vom Typ [Honours];
- Zeile 5: Ein Aufzählungswert wird mit seinem Namen angezeigt;
- Zeilen 12–14: die Liste der Werte. Die Konvertierung [(int)m] liefert den ganzzahligen Wert der Konstante;
- Zeile 17: die Liste der Namen;
- Zeile 19: die umgekehrte Konvertierung, von einer ganzen Zahl in die Aufzählung;
- Zeile 22: die Umwandlung einer Zeichenkette in einen Aufzählungswert. Aufzählungswerte werden wie die ganzen Zahlen verglichen, die sie codieren;
- Zeilen 27–31: Aufzählungen passen gut zu switch-Anweisungen;
- Zeile 34: Der zugrunde liegende Ganzzahltyp ist standardmäßig [int] ;
- Zeile 37: die Deklaration der Aufzählung. In einer Datei mit Anweisungen auf oberster Ebene werden Typdeklarationen (Aufzählungen, Klassen usw.) nach den Anweisungen platziert.
Einer Aufzählung, deren Werte Zweierpotenzen sind (1, 2, 4, 8, ...), kann das Attribut [Flags] zugewiesen werden: Ihre Werte werden dann mit dem Operator | (bitweises ODER) kombiniert, um eine Menge von Optionen darzustellen, zum Beispiel die Zugriffsrechte auf eine Datei (read | write).
3.10. Parameterübergabe an eine Funktion
Hier geht es darum, wie Parameter an eine Funktion übergeben werden. Betrachten Sie die folgende Funktion:
In der Funktionsdefinition in Zeile 1 heißt [a] ein formaler Parameter. Er dient ausschließlich dazu, die Funktion [ChangeInt] zu definieren. Er hätte ebenso gut [b] heißen können. Betrachten wir nun ein Beispiel für die Verwendung dieser Funktion:
Hier ist in der Anweisung in Zeile 2 [age] der aktuelle Parameter , der seinen Wert an den formalen Parameter [a] übergibt. Uns interessiert, wie ein formaler Parameter den Wert eines aktuellen Parameters erhält.
3.10.1. Übergabemodi
C# unterstützt die folgenden Übergabemodi:
- als Wert (der Standardmodus): Der Wert des aktuellen Parameters wird in den entsprechenden formalen Parameter kopiert. Es sind zwei getrennte Entitäten: Ändert die Funktion den formalen Parameter, bleibt der aktuelle Parameter unverändert. Dieser Modus eignet sich für Eingabeparameter einer Funktion;
- als Referenz mit [ref]: Der aktuelle und der formale Parameter sind ein und dieselbe Entität. Ändert die Funktion den formalen Parameter, wird auch der aktuelle Parameter geändert. Das Schlüsselwort [ref] muss sowohl in der Funktionsdefinition als auch im Aufruf stehen. Der aktuelle Parameter muss vor dem Aufruf einen Wert haben. Dieser Modus eignet sich für Ein-/Ausgabeparameter;
- als Referenz mit [out]: wie [ref], aber der Parameter ist ein reiner Ausgabeparameter: Der aktuelle Parameter braucht keinen Anfangswert, und die Funktion muss dem formalen Parameter einen Wert zuweisen. Dieser Modus wird von den Methoden [TryParse] verwendet. Ab C# 7 kann die Variable im Aufruf deklariert werden: [out var x] oder [out int x];
- als schreibgeschützte Referenz mit [in] (C# 7.2): Der Parameter wird per Referenz übergeben, was das Kopieren vermeidet, aber die Funktion kann ihn nicht ändern. Dieser Modus ist nur bei großen Strukturen sinnvoll; bei vordefinierten Typen ist die Übergabe als Wert ebenso effizient.
Das Programm [basics-26.cs] veranschaulicht diese verschiedenen Modi:
Ergebnisse:
Kommentare:
- Zeilen 3–5: Der Wert 20 des aktuellen Parameters [age] wurde in den formalen Parameter [a] kopiert (Zeile 35). Dieser Parameter wurde anschließend geändert (Zeile 37). Der aktuelle Parameter blieb unverändert;
- Zeilen 8–10: Bei [ref] folgte der aktuelle Parameter [age2] der Änderung des formalen Parameters [a2];
- Zeilen 13–15: Die Variable [age3] wird vor dem Aufruf nicht initialisiert; mit [out] ist das möglich;
- Zeile 17: Die Variable [age4] wird im Aufruf deklariert;
- Zeilen 21–22: Das Vertauschen zweier Werte erfordert die Übergabe per Referenz; bei der Übergabe als Wert würde die Funktion Kopien vertauschen;
- Zeile 27: eine schreibgeschützte Übergabe. Das Schlüsselwort [in] ist im Aufruf optional. Das Ergebnis 120.0 hat eine Nachkommastelle, weil das Produkt zweier [decimal]-Werte die Nachkommastellen seiner Operanden beibehält: 100 × 1.2 = 120.0;
- Zeilen 30–32: Ein Array ist ein Referenztyp; als Wert übergeben wird die Referenz des Arrays. Die Funktion [ModifyArray] arbeitet daher auf demselben Array wie der Aufrufer: Die Änderung durch [t[0]] (Zeile 69) ist für den Aufrufer sichtbar. Lässt man jedoch [t] auf ein anderes Array zeigen (Zeile 71), ändert das nur die lokale Kopie der Referenz.
Wird Zeile 8 durch [int age2;] ersetzt, weist der Compiler das Programm zurück:
Dieses Problem lässt sich umgehen, indem man [age2] einen Anfangswert zuweist oder das Schlüsselwort [ref] durch das Schlüsselwort [out] ersetzt: Dies zeigt an, dass der Parameter ausschließlich ein Ausgabeparameter ist. Ebenso, wenn die Funktion [InclTax] versucht, ihren Parameter [in] zu ändern:
3.10.2. Optionale Parameter, benannte Argumente, variable Parameteranzahl
C# 4 führte optionale Parameter ein: Einem Parameter kann in der Funktionsdefinition ein Standardwert zugewiesen werden; der Aufrufer kann ihn dann weglassen. Optionale Parameter stehen hinter den erforderlichen Parametern. Außerdem wurden benannte Argumente eingeführt: Beim Aufruf der Funktion kann dem aktuellen Parameter der Name des formalen Parameters, gefolgt von einem Doppelpunkt, vorangestellt werden. So lässt sich ein optionaler Parameter weglassen, der vor anderen Parametern steht, oder die Parameter lassen sich in beliebiger Reihenfolge angeben.
Das Schlüsselwort [params] erlaubt es, eine Funktion mit variabler Parameteranzahl zu schreiben: Der letzte formale Parameter ist ein Array, und der Aufrufer kann entweder ein Array oder eine (möglicherweise leere) Liste von Werten übergeben, die der Compiler zu einem Array zusammenfasst. Ab C# 13 kann der Parameter [params] auch von einem anderen Sammlungstyp sein, etwa [List<T>] oder [ReadOnlySpan<T>].
Das Programm [basics-27.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 17: Die Funktion [Greet] hat einen erforderlichen Parameter, [name], und zwei optionale Parameter, [greeting] und [uppercase];
- Zeile 3: Beide optionalen Parameter nehmen ihre Standardwerte an;
- Zeile 4: Nur [uppercase] nimmt seinen Standardwert an;
- Zeile 6: Mit dem benannten Argument übergeben wir [uppercase] , ohne [greeting] zu übergeben;
- Zeile 7: Bei benannten Argumenten ist die Reihenfolge beliebig;
- Zeile 23: [Sum] akzeptiert beliebig viele ganze Zahlen;
- Zeilen 10–13: [Sum] wird ohne Parameter, mit drei ganzen Zahlen und dann mit einem Array aufgerufen;
- Zeile 15: Viele .NET-Methoden, etwa [string.Join] oder [Console.WriteLine] mit einem Format, haben einen Parameter [params].
3.11. Lokale Funktionen und Tupel
3.11.1. Lokale Funktionen
Eine lokale Funktion (C# 7) ist eine Funktion, die innerhalb einer Methode oder, wie in unseren Beispielen, zwischen Anweisungen auf oberster Ebene definiert wird. Sie kann nur an dieser Stelle verwendet werden. Da unsere Programme keine Klassen mehr haben, ersetzen lokale Funktionen die statischen Methoden der Beispiele von 2008. Eine lokale Funktion:
- kann vor ihrer Definition aufgerufen werden;
- kann die sie umgebenden lokalen Variablen verwenden, sofern sie nicht als [static] deklariert ist: Das Schlüsselwort [static] (C# 8) stellt sicher, dass sie nur von ihren Parametern abhängt, was sie leichter verständlich macht. Wir deklarieren unsere lokalen Funktionen nach Möglichkeit als [static];
- kann einen Ausdruckskörper haben: [static int Square(int x) => x * x;] ist gleichwertig mit einem Rumpf wie [{ return x * x; }].
In einem größeren Programm schreiben wir Klassen und Methoden: Das ist das Thema des nächsten Kapitels.
3.11.2. Tupel
Ein Tupel (C# 7) fasst mehrere Werte, die unterschiedliche Typen haben können, zu einer einzigen Entität zusammen. Der Typ [(int, string)] bezeichnet ein Paar aus einer ganzen Zahl und einer Zeichenkette; seine Elemente heißen [Item1] und [Item2]. Sie können benannt werden: [(int Number, string Name)]. Ein Tupel kann dekonstruiert werden: [var (number, name) = t;] weist seine Elemente zwei Variablen zu.
Mit Tupeln kann eine Funktion mehrere Werte zurückgeben, ohne [out]-Parameter zu verwenden: Das ist oft lesbarer.
Das Programm [basics-28.cs] lautet wie folgt:
Ergebnisse:
Kommentare:
- Zeile 3: eine statische lokale Funktion mit Ausdruckskörper;
- Zeilen 7–8: eine nicht statische lokale Funktion: Sie ändert die Programmvariable [counter];
- Zeile 14: ein Tupel, dessen Elemente keine Namen haben. Wird ein Tupel ausgegeben, erscheinen seine Elemente in runden Klammern;
- Zeilen 17–18: zwei Tupel mit benannten Elementen: das erste über seinen Typ, das zweite über die im Ausdruck angegebenen Namen;
- Zeile 21: das Entpacken des Tupels [t3];
- Zeile 25: Die Funktion [Divide] liefert Quotient und Rest der ganzzahligen Division; das Ergebnis wird direkt entpackt;
- Zeile 27: Hier wird das Tupel beibehalten, und die Namen seiner Elemente, [Min] und [Max], werden verwendet;
- Zeile 30: Ab .NET 6 liefert [Math.DivRem] ebenfalls ein Tupel (Quotient, Rest);
- Zeile 35: Das Vertauschen zweier Variablen lässt sich mit einem Tupel in einer einzigen Zeile ohne temporäre Variable schreiben;
- Zeile 38: Der von der Funktion zurückgegebene Typ ist ein benanntes Tupel;
- Zeilen 40–48: eine Funktion, die Minimum und Maximum eines Arrays in einem einzigen Durchlauf berechnet.