Skip to content

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:

Image

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:

1
2
3
4
5
// minimales Programm mit Top-Level-Anweisungen (C# 9)
// die Anweisungen stehen direkt in der Datei: keine Klasse, keine Methode Main
Console.WriteLine("Hello world!");
// der vollständige Name der Klasse Console lautet System.Console
System.Console.WriteLine("Number of arguments received: " + args.Length);

Ergebnisse:

1
2
3
> dotnet run basics-01.cs
Hello world!
Number of arguments received: 0

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):

1
2
3
> dotnet run basics-01.cs -- a0 a1
Hello world!
Number of arguments received: 2

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]:

// die klassische Form desselben Programms (bis C# 8 die einzig mögliche)
using System;

namespace Basics
{
    class Program
    {
        // die Methode Main ist der Einstiegspunkt des Programms
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world!");
            System.Console.WriteLine("Number of arguments received: " + args.Length);
        }
    }
}

Ergebnisse:

1
2
3
> dotnet run basics-02.cs
Hello world!
Number of arguments received: 0

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:

1
2
3
4
5
6
7
8
// <auto-generated/>
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using System.Net.Http;
global using System.Threading;
global using System.Threading.Tasks;

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:

string? typeName = 3.GetType().FullName;

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:

// die vordefinierten Typen: .NET-Typ und Größe in Bytes
int integer = 2;
float fl = 10.5F;
double d = -4.6;
string s = "test";
uint ui = 5;
long l = 1000;
ulong ul = 1001;
byte octet = 5;
sbyte so = -5;
short sh = -4;
ushort ush = 10;
decimal dec = 10.67M;
bool b = true;
char c = 'A';
// {0}, {1}, {2} werden durch die auf das Format folgenden Parameter Nr. 0, 1, 2 ersetzt
Console.WriteLine("Type of integer[{1}] : [{0},{2}]", integer.GetType().FullName, integer, sizeof(int));
Console.WriteLine("Type of fl[{1}] : [{0},{2}]", fl.GetType().FullName, fl, sizeof(float));
Console.WriteLine("Type of d[{1}] : [{0},{2}]", d.GetType().FullName, d, sizeof(double));
Console.WriteLine("Type of s[{1}] : [{0}]", s.GetType().FullName, s);
Console.WriteLine("Type of ui[{1}] : [{0},{2}]", ui.GetType().FullName, ui, sizeof(uint));
Console.WriteLine("Type of l[{1}] : [{0},{2}]", l.GetType().FullName, l, sizeof(long));
Console.WriteLine("Type of ul[{1}] : [{0},{2}]", ul.GetType().FullName, ul, sizeof(ulong));
Console.WriteLine("Type of octet[{1}] : [{0},{2}]", octet.GetType().FullName, octet, sizeof(byte));
Console.WriteLine("Type of so[{1}] : [{0},{2}]", so.GetType().FullName, so, sizeof(sbyte));
Console.WriteLine("Type of sh[{1}] : [{0},{2}]", sh.GetType().FullName, sh, sizeof(short));
Console.WriteLine("Type of ush[{1}] : [{0},{2}]", ush.GetType().FullName, ush, sizeof(ushort));
Console.WriteLine("Type of dec[{1}] : [{0},{2}]", dec.GetType().FullName, dec, sizeof(decimal));
Console.WriteLine("Type of b[{1}] : [{0},{2}]", b.GetType().FullName, b, sizeof(bool));
Console.WriteLine("Type of c[{1}] : [{0},{2}]", c.GetType().FullName, c, sizeof(char));
// Ganzzahl, deren Größe der einer Speicheradresse entspricht (je nach Rechner 4 oder 8 Bytes)
nint ni = 7;
Console.WriteLine("Type of ni[{1}] : [{0},{2}]", ni.GetType().FullName, ni, nint.Size);
// 2 Byte große Gleitkommazahl (.NET 5)
Half h = (Half)1.5;
Console.WriteLine("Type of h[{1}] : [{0}]", h.GetType().FullName, h);
// das Literal 3 ist ebenfalls ein Objekt
Console.WriteLine("Type of the literal 3 : " + 3.GetType().FullName);
// Extremwerte
Console.WriteLine("int : [{0}, {1}]", int.MinValue, int.MaxValue);
Console.WriteLine("long : [{0}, {1}]", long.MinValue, long.MaxValue);
Console.WriteLine("decimal : [{0}, {1}]", decimal.MinValue, decimal.MaxValue);

Ergebnisse:

> dotnet run basics-03.cs
Type of integer[2] : [System.Int32,4]
Type of fl[10,5] : [System.Single,4]
Type of d[-4,6] : [System.Double,8]
Type of s[test] : [System.String]
Type of ui[5] : [System.UInt32,4]
Type of l[1000] : [System.Int64,8]
Type of ul[1001] : [System.UInt64,8]
Type of octet[5] : [System.Byte,1]
Type of so[-5] : [System.SByte,1]
Type of sh[-4] : [System.Int16,2]
Type of ush[10] : [System.UInt16,2]
Type of dec[10,67] : [System.Decimal,16]
Type of b[True] : [System.Boolean,1]
Type of c[A] : [System.Char,2]
Type of ni[7] : [System.IntPtr,8]
Type of h[1,5] : [System.Half]
Type of the literal 3 : System.Int32
int : [-2147483648, 2147483647]
long : [-9223372036854775808, 9223372036854775807]
decimal : [-79228162514264337593543950335, 79228162514264337593543950335]

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:

// die Schreibweise literaler Daten
// Ganzzahlen: dezimal, hexadezimal (0x), binär (0b), Trennzeichen _
int i1 = 145, i2 = -7, i3 = 0xFF, i4 = 0b1010_1010;
long l1 = 100000L, l2 = 1_000_000_000_000L;
Console.WriteLine("integers : {0} {1} {2} {3} {4} {5}", i1, i2, i3, i4, l1, l2);
// Gleitkommazahlen
double d1 = 134.789, d2 = -45E-18;
float f1 = 134.789F;
decimal m1 = 100000.50M;
Console.WriteLine("reals : {0} {1} {2} {3}", d1, d2, f1, m1);
// Zeichen und boolesche Werte
char c1 = 'A', c2 = '\u00e9';
bool b1 = true;
Console.WriteLine("characters : {0} {1}, boolean : {2}", c1, c2, b1);
// ein Datum: (Jahr, Monat, Tag)
DateTime birth = new DateTime(1954, 10, 13);
Console.WriteLine("date : {0}", birth.ToShortDateString());

// klassische Zeichenketten: das Zeichen \ leitet eine Escape-Sequenz ein
string path1 = "c:\\chap1\\paragraph3";
// Verbatim-Zeichenkette: der Text wird unverändert übernommen
string path2 = @"c:\chap1\paragraph3";
Console.WriteLine(path1);
Console.WriteLine(path2);
Console.WriteLine("line 1\nline 2\t[tab]");

// interpolierte Zeichenkette: die Ausdrücke in geschweiften Klammern werden ausgewertet
string name = "dupont";
int age = 23;
Console.WriteLine($"{name} is {age} years old, in 10 years he will be {age + 10}");
// mit einem Format nach dem Zeichen :
Console.WriteLine($"d1={d1:F1}, i3 in hexadecimal={i3:X}, i4 in binary={i4:B8}, l2={l2:N0}");
Console.WriteLine($"date={birth:dddd d MMMM yyyy}");

// Raw-String (C# 11): kein Escaping, keine verdoppelten Anführungszeichen
string json = """
    {
      "name": "dupont",
      "path": "c:\chap1"
    }
    """;
Console.WriteLine(json);
// interpolierter Raw-String: mit $$ stehen die Ausdrücke zwischen {{ und }}
string json2 = $$"""{ "name": "{{name}}", "age": {{age}} }""";
Console.WriteLine(json2);

Ergebnisse:

> dotnet run basics-04.cs
integers : 145 -7 255 170 100000 1000000000000
reals : 134,789 -4,5E-17 134,789 100000,50
characters : A é, boolean : True
date : 13/10/1954
c:\chap1\paragraph3
c:\chap1\paragraph3
line 1
line 2    [tab]
dupont is 23 years old, in 10 years he will be 33
d1=134,8, i3 in hexadecimal=FF, i4 in binary=10101010, l2=1 000 000 000 000
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }

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:

const type name = value;

Zum Beispiel:

const double VatRate = 0.2;

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:

type variable1 = value1, variable2 = value2, ...;

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:

var variable1 = value1;

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:

// Konstanten und Variablen
const double VatRate = 0.2;
const string Currency = "euros";
double priceExclTax = 100;
Console.WriteLine($"Price incl. tax : {priceExclTax * (1 + VatRate)} {Currency}");

// ein explizit typisiertes Datum
int i = 2;
Console.WriteLine($"Type of int i=2 : {i.GetType().Name},{i.GetType().FullName}");
// implizit typisiertes Datum mit var
var j = 3;
Console.WriteLine($"Type of var j=3 : {j.GetType().Name},{j.GetType().FullName}");
var today = DateTime.Now;
Console.WriteLine($"Type of var today : {today.GetType().Name},{today.GetType().FullName}");
var x = 3.5;
var y = 3.5F;
var z = 10L;
var name = "dupont";
Console.WriteLine($"x : {x.GetType().Name}, y : {y.GetType().Name}, z : {z.GetType().Name}, name : {name.GetType().Name}");
// mehrere Variablen in derselben Zeile deklariert
int a = 1, b, c = 3;
b = a + c;
Console.WriteLine($"a={a}, b={b}, c={c}");

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run basics-05.cs
Price incl. tax : 120 euros
Type of int i=2 : Int32,System.Int32
Type of var j=3 : Int32,System.Int32
Type of var today : DateTime,System.DateTime
x : Double, y : Single, z : Int64, name : String
a=1, b=4, c=3

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:

today = "today";

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:

// Nullable-Typen
// ein Nullable-Werttyp (int?) akzeptiert zusätzlich zu den Ganzzahlen den Wert null
int? age = null;
Console.WriteLine($"age.HasValue={age.HasValue}");
age = 23;
Console.WriteLine($"age.HasValue={age.HasValue}, age.Value={age.Value}");
// int? -> int: eine explizite Konvertierung ist erforderlich (Exception, wenn age null ist)
int n = (int)age;
Console.WriteLine($"n={n}");

// ein Nullable-Referenztyp (string?) akzeptiert den Wert null
string? firstName = null;
Console.WriteLine($"firstName is null : {firstName == null}");
// der Typ string (ohne ?) ist definitionsgemäß nie null
string name = "dupont";
Console.WriteLine($"name has {name.Length} characters");

// Console.ReadLine liefert einen string?: null, wenn der Eingabestrom erschöpft ist
Console.Write("Type a line: ");
string? line = Console.ReadLine();
if (line == null)
{
    Console.WriteLine();
    Console.WriteLine("No line: the input stream is closed");
}
else
{
    // hier weiß der Compiler, dass line nicht null ist
    Console.WriteLine($"You typed [{line}] : {line.Length} character(s)");
}

Ergebnisse bei Texteingabe über die Tastatur:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: hello
You typed [hello] : 5 character(s)

Ergebnisse, wenn der Benutzer Strg-D drückt (unter Windows Strg-Z gefolgt von der Eingabetaste), was den Eingabestrom schließt:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: 
No line: the input stream is closed

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:

1
2
3
4
5
6
7
8
9
try
{
    call the function likely to throw the exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

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:

// Konvertierungen zwischen Zahlen und Zeichenketten
using System.Globalization;

// Daten
const int i = 10;
const long l = 100000;
const float f = 45.78F;
double d = -14.98;

// Zahl --> string
Display(i.ToString());
Display(l.ToString());
Display(f.ToString());
Display(d.ToString());

// boolean --> string
const bool b = false;
Display(b.ToString());

// string --> int
int i1 = int.Parse("10");
Display(i1.ToString());
try
{
    i1 = int.Parse("10.67");
    Display(i1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// string --> long
long l1 = long.Parse("100");
Display(l1.ToString());
try
{
    l1 = long.Parse("10.675");
    Display(l1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// string --> double
double d1 = double.Parse("100,87");
Display(d1.ToString());
try
{
    d1 = double.Parse("abcd");
    Display(d1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// string --> float
float f1 = float.Parse("100,87");
Display(f1.ToString());
try
{
    f1 = float.Parse("abcd");
    Display(f1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// TryParse: liefert false, statt eine Exception auszulösen
if (int.TryParse("123", out int i2))
{
    Display($"TryParse(\"123\") succeeded : {i2}");
}
if (!int.TryParse("12x", out var i3))
{
    Display($"TryParse(\"12x\") failed, i3={i3}");
}

// die Kultur: Dezimaltrennzeichen der aktuellen Kultur
Display($"Current culture : {CultureInfo.CurrentCulture.Name}");
try
{
    d1 = double.Parse("100.87");
    Display(d1.ToString());
}
catch (FormatException e)
{
    Display("Error : " + e.Message);
}
// die invariante Kultur verwendet den Dezimalpunkt
double d2 = double.Parse("100.87", CultureInfo.InvariantCulture);
Display(d2.ToString());
Display(d2.ToString(CultureInfo.InvariantCulture));
if (double.TryParse("3.14", CultureInfo.InvariantCulture, out double pi))
{
    Display($"pi={pi}");
}

// eine lokale Funktion (siehe später), die ihren Parameter anzeigt
static void Display(string s)
{
    Console.WriteLine($"S={s}");
}

Ergebnisse:

> dotnet run basics-07.cs
S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Error : The input string '10.67' was not in a correct format.
S=100
S=Error : The input string '10.675' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=TryParse("123") succeeded : 123
S=TryParse("12x") failed, i3=0
S=Current culture : fr-FR
S=Error : The input string '100.87' was not in a correct format.
S=100,87
S=100.87
S=pi=3,14

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:

Type[] array = new Type[n];

[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:

int[] integers = new int[] { 0, 10, 20, 30 };

oder einfacher:

int[] integers = { 0, 10, 20, 30 };

oder ab C# 12 mit einem Collection-Ausdruck:

int[] integers = [0, 10, 20, 30];

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:

Type[,] array = new Type[n, m];

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:

double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };

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:

Type[][] array = new Type[n][];

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:

// Arrays
// ein initialisiertes eindimensionales Array
int[] integers = new int[] { 0, 10, 20, 30 };
for (int i = 0; i < integers.Length; i++)
{
    Console.WriteLine($"integers[{i}]={integers[i]}");
}

// ein initialisiertes zweidimensionales Array
double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };
for (int i = 0; i < reals.GetLength(0); i++)
{
    for (int j = 0; j < reals.GetLength(1); j++)
    {
        Console.WriteLine($"reals[{i},{j}]={reals[i, j]}");
    }
}
Console.WriteLine($"reals : Rank={reals.Rank}, Length={reals.Length}");

// ein Array von Arrays (Jagged Array)
string[][] names = new string[3][];
for (int i = 0; i < names.Length; i++)
{
    names[i] = new string[i + 1];
}
// Initialisierung
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        names[i][j] = "name" + i + j;
    }
}
// Anzeige
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        Console.WriteLine($"names[{i}][{j}]={names[i][j]}");
    }
}

// ein ohne Anfangswerte erzeugtes Array: Elemente mit dem Standardwert des Typs
bool[] flags = new bool[3];
string?[] strings = new string?[2];
Console.WriteLine($"flags[0]={flags[0]}, strings[0] is null : {strings[0] == null}");

// Collection Expression (C# 12)
int[] values = [0, 10, 20, 30, 40];
// string.Join verbindet die Elemente eines Arrays mit einem Trennzeichen
Console.WriteLine($"values=[{string.Join(", ", values)}]");
// Index vom Ende (C# 8): ^1 bezeichnet das letzte Element
Console.WriteLine($"values[^1]={values[^1]}, values[^2]={values[^2]}");
// Bereich (C# 8): die Elemente mit den Indizes 1 und 2 (die Obergrenze ist ausgeschlossen)
int[] slice = values[1..3];
Console.WriteLine($"values[1..3]=[{string.Join(", ", slice)}]");
Console.WriteLine($"values[2..]=[{string.Join(", ", values[2..])}]");
Console.WriteLine($"values[..^1]=[{string.Join(", ", values[..^1])}]");
// der Ausschnitt ist eine Kopie: das ursprüngliche Array wird nicht verändert
slice[0] = 100;
Console.WriteLine($"slice[0]={slice[0]}, values[1]={values[1]}");

Ergebnisse:

> dotnet run basics-08.cs
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0,0]=0,5
reals[0,1]=1,7
reals[1,0]=8,4
reals[1,1]=-6
reals : Rank=2, Length=4
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=False, strings[0] is null : True
values=[0, 10, 20, 30, 40]
values[^1]=40, values[^2]=30
values[1..3]=[10, 20]
values[2..]=[20, 30, 40]
values[..^1]=[0, 10, 20, 30]
slice[0]=100, values[1]=10

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:

Image

  • 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:

1
2
3
Console.Out.WriteLine(expression);
Console.WriteLine(expression);
Console.Error.WriteLine(expression);

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:

string? line = Console.In.ReadLine();

Die Klasse [Console] stellt eine Methode [ReadLine] bereit, die standardmäßig dem Strom [In] zugeordnet ist. Daher können Sie schreiben:

string? line = Console.ReadLine();

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:

// Ein-/Ausgabe über Tastatur und Bildschirm

// Schreiben in den Out-Strom
object obj = new object();
Console.Out.WriteLine(obj);

// Schreiben in den Error-Strom
int i = 10;
Console.Error.WriteLine("i=" + i);
Console.Error.WriteLine("i={0}", i);

// eine über die Tastatur eingegebene Zeile lesen
Console.Write("Type a line: ");
string? line = Console.ReadLine();
Console.WriteLine($"line={line}");

Ergebnisse:

1
2
3
4
5
6
> dotnet run basics-09.cs
System.Object
i=10
i=10
Type a line: here I am
line=here I am

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]:

1
2
3
4
5
6
7
// Umleitungen der Ein-/Ausgabeströme
// Lesen des In-Stroms
string? data = Console.In.ReadLine();
// Schreiben in den Out-Strom
Console.Out.WriteLine("writing to the Out stream : " + data);
// Schreiben in den Error-Strom
Console.Error.WriteLine("writing to the Error stream : " + data);

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):

> echo test > in.txt
> cat in.txt
test
> dotnet run basics-10.cs < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the Out stream : test
> cat err.txt
writing to the Error stream : test
> dotnet run basics-10.cs < in.txt 2> err.txt
writing to the Out stream : test
> dotnet run basics-10.cs < in.txt > out.txt
writing to the Error stream : test

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:

rem Windows command prompt (cmd)
echo test>in.txt
dotnet run basics-10.cs <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | dotnet run basics-10.cs > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

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:

double x, y = 4;
x = Math.Sqrt(y);

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:

// arithmetische Ausdrücke
// Ganzzahldivision und Division reeller Zahlen
Console.WriteLine($"5 / 2 = {5 / 2}, 5.0 / 2 = {5.0 / 2}, 5 / 2.0 = {5 / 2.0}");
// Divisionsrest (Modulo)
Console.WriteLine($"5 % 2 = {5 % 2}, -5 % 2 = {-5 % 2}, 5.5 % 2 = {5.5 % 2}");
// reelle Division durch null: kein Fehler, sondern Unendlich oder NaN (Not a Number)
double zero = 0;
Console.WriteLine($"1 / 0.0 = {1 / zero}, 0 / 0.0 = {0 / zero}");

// einige Funktionen der Klasse Math
double x, y = 4;
x = Math.Sqrt(y);
Console.WriteLine($"Math.Sqrt(4) = {x}");
Console.WriteLine($"Math.Pow(2, 10) = {Math.Pow(2, 10)}");
Console.WriteLine($"Math.Abs(-3.5) = {Math.Abs(-3.5)}, Math.Max(3, 7) = {Math.Max(3, 7)}");
Console.WriteLine($"Math.PI = {Math.PI}, Math.Cos(Math.PI) = {Math.Cos(Math.PI)}");
Console.WriteLine($"Math.Exp(1) = {Math.Exp(1)}, Math.Log(Math.E) = {Math.Log(Math.E)}");
Console.WriteLine($"Math.Floor(-2.5) = {Math.Floor(-2.5)}, Math.Ceiling(-2.5) = {Math.Ceiling(-2.5)}, Math.Truncate(-2.5) = {Math.Truncate(-2.5)}");
// Math.Round rundet standardmäßig zur nächsten geraden Zahl
Console.WriteLine($"Math.Round(2.5) = {Math.Round(2.5)}, Math.Round(3.5) = {Math.Round(3.5)}");
Console.WriteLine($"Math.Round(2.5, MidpointRounding.AwayFromZero) = {Math.Round(2.5, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"Math.Round(2.567, 2) = {Math.Round(2.567, 2)}");

// Vorrang: * / % vor + -
Console.WriteLine($"2 + 3 * 4 = {2 + 3 * 4}, (2 + 3) * 4 = {(2 + 3) * 4}, 10 - 4 - 3 = {10 - 4 - 3}");

// die Zuweisung ist ein Ausdruck: Mehrfachzuweisung
int v1, v2;
v1 = v2 = 7 * 6;
Console.WriteLine($"v1={v1}, v2={v2}");

Ergebnisse:

> dotnet run basics-11.cs
5 / 2 = 2, 5.0 / 2 = 2,5, 5 / 2.0 = 2,5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1,5
1 / 0.0 = ∞, 0 / 0.0 = NaN
Math.Sqrt(4) = 2
Math.Pow(2, 10) = 1024
Math.Abs(-3.5) = 3,5, Math.Max(3, 7) = 7
Math.PI = 3,141592653589793, Math.Cos(Math.PI) = -1
Math.Exp(1) = 2,718281828459045, Math.Log(Math.E) = 1
Math.Floor(-2.5) = -3, Math.Ceiling(-2.5) = -2, Math.Truncate(-2.5) = -2
Math.Round(2.5) = 2, Math.Round(3.5) = 4
Math.Round(2.5, MidpointRounding.AwayFromZero) = 3
Math.Round(2.567, 2) = 2,57
2 + 3 * 4 = 14, (2 + 3) * 4 = 20, 10 - 4 - 3 = 3
v1=42, v2=42

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):

[functions], [( )], [*, /, %], [+, -]

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].

1
2
3
bool end;
int x = 5;
end = x > 4;

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:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

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“:

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

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:

// Vergleichsausdrücke und Zeichenkettenvergleich
int x = 5;
bool end = x > 4;
Console.WriteLine($"x > 4 : {end}, x == 5 : {x == 5}, x != 5 : {x != 5}");

// Vergleich von Zeichen: ihre Unicode-Codes werden verglichen
Console.WriteLine($"'a' < 'b' : {'a' < 'b'}, 'Z' < 'a' : {'Z' < 'a'}, '9' < 'A' : {'9' < 'A'}");
Console.WriteLine($"codes : 'A'={(int)'A'}, 'a'={(int)'a'}, 'é'={(int)'é'}");

// Vergleich von Zeichenketten
string string1 = "cat", string2 = "dog";
int n = string1.CompareTo(string2);
bool equal = string1.Equals(string2);
Console.WriteLine($"n={n}, equal={equal}");
Console.WriteLine($"\"dog\"==string1 : {"dog" == string1}, \"dog\"!=string2 : {"dog" != string2}");
Console.WriteLine($"\"Cat\".CompareTo(\"Catkin\") : {"Cat".CompareTo("Catkin")}");

// CompareTo und string.Compare folgen den Regeln der aktuellen Kultur (fr-FR)
Console.WriteLine($"\"élan\".CompareTo(\"face\") : {"élan".CompareTo("face")}");
Console.WriteLine($"string.Compare(\"Cat\", \"cat\") : {string.Compare("Cat", "cat")}");
// StringComparison.Ordinal: Vergleich der Unicode-Codes, Zeichen für Zeichen
Console.WriteLine($"Ordinal(\"élan\", \"face\") : {string.Compare("élan", "face", StringComparison.Ordinal)}");
Console.WriteLine($"Ordinal(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.Ordinal)}");
// Groß-/Kleinschreibung ignorieren
Console.WriteLine($"OrdinalIgnoreCase(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.OrdinalIgnoreCase)}");
Console.WriteLine($"\"Cat\".Equals(\"cat\") : {"Cat".Equals("cat")}");
Console.WriteLine($"\"Cat\".Equals(\"cat\", OrdinalIgnoreCase) : {"Cat".Equals("cat", StringComparison.OrdinalIgnoreCase)}");

Ergebnisse:

> dotnet run basics-12.cs
x > 4 : True, x == 5 : True, x != 5 : False
'a' < 'b' : True, 'Z' < 'a' : True, '9' < 'A' : True
codes : 'A'=65, 'a'=97, 'é'=233
n=-1, equal=False
"dog"==string1 : False, "dog"!=string2 : False
"Cat".CompareTo("Catkin") : -1
"élan".CompareTo("face") : -1
string.Compare("Cat", "cat") : 1
Ordinal("élan", "face") : 131
Ordinal("Cat", "cat") : -32
OrdinalIgnoreCase("Cat", "cat") : 0
"Cat".Equals("cat") : False
"Cat".Equals("cat", OrdinalIgnoreCase) : True

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:

  • ! ;
  • && ;
  • ||.
double x = 3.5;
bool valid = x > 2 && x < 4;

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:

// Bitmanipulation
short i = 100, j = -13;
ushort k = 0xF123;
Console.WriteLine("i=0x{0:x4}, j=0x{1:x4}, k=0x{2:x4}", i, j, k);
Console.WriteLine("i<<4=0x{0:x4}, i>>4=0x{1:x4}, k>>4=0x{2:x4}", i << 4, i >> 4, k >> 4);
Console.WriteLine("i&j=0x{0:x4}, i|j=0x{1:x4}, i^j=0x{2:x4}, ~i=0x{3:x4}",
    (short)(i & j), (short)(i | j), (short)(i ^ j), (short)~i);
Console.WriteLine("j<<2=0x{0:x4}, j>>2=0x{1:x4}", (short)(j << 2), (short)(j >> 2));
// dieselben Werte binär (Format B, .NET 8)
Console.WriteLine($"i={i:B16}, j={j:B16}, i&j={(short)(i & j):B16}");
// vorzeichenloses Rechtsschieben >>> (C# 11): die nachrückenden Bits sind Nullen
int m = -16;
Console.WriteLine($"m={m:B32}, m>>2={m >> 2:B32}, m>>>2={m >>> 2:B32}");

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run basics-13.cs
i=0x0064, j=0xfff3, k=0xf123
i<<4=0x0640, i>>4=0x0006, k>>4=0x0f12
i&j=0x0060, i|j=0xfff7, i^j=0xff97, ~i=0xff9b
j<<2=0xffcc, j>>2=0xfffc
i=0000000001100100, j=1111111111110011, i&j=0000000001100000
m=11111111111111111111111111110000, m>>2=11111111111111111111111111111100, m>>>2=00111111111111111111111111111100

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:

// weitere Operatoren
// boolesche Ausdrücke
double x = 3.5;
bool valid = x > 2 && x < 4;
Console.WriteLine($"valid={valid}, !valid={!valid}, valid || x > 10 : {valid || x > 10}");

// zusammengesetzte Operatoren
int a = 10;
a += 5;
Console.Write($"a += 5 : {a}");
a *= 2;
Console.Write($", a *= 2 : {a}");
a /= 4;
Console.Write($", a /= 4 : {a}");
a %= 4;
Console.Write($", a %= 4 : {a}");
a <<= 2;
Console.WriteLine($", a <<= 2 : {a}");

// Inkrement und Dekrement
int i = 5;
int j = i++;    // j erhält den alten Wert von i, danach wird i inkrementiert
int k = ++i;    // i wird inkrementiert, danach erhält k den neuen Wert von i
Console.WriteLine($"i={i}, j={j}, k={k}");
i--;
Console.WriteLine($"i={i}");

// ternärer Operator
int n = 5;
int p = n > 4 ? n + 1 : n - 1;
string parity = n % 2 == 0 ? "even" : "odd";
Console.WriteLine($"p={p}, {n} is {parity}");

// Operator ??: Ersatzwert, wenn der linke Operand null ist
string? input = null;
string name = input ?? "unknown";
int? age = null;
int displayedAge = age ?? -1;
Console.WriteLine($"name={name}, displayedAge={displayedAge}");
// Operator ??=: Zuweisung nur, wenn die Variable null ist
string? title = null;
title ??= "Untitled";
title ??= "Other title";
Console.WriteLine($"title={title}");
// Operator ?.: Zugriff auf ein Member nur, wenn das Objekt nicht null ist
string? text = null;
int? length = text?.Length;
Console.WriteLine($"length={length?.ToString() ?? "null"}");
text = "hello";
Console.WriteLine($"length={text?.Length}");

Ergebnisse:

> dotnet run basics-14.cs
valid=True, !valid=False, valid || x > 10 : True
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a <<= 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=5

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:

(type) value

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:

// Typänderungen
int i = 3, j = 4;
float f1 = i / j;
float f2 = (float)i / j;
Console.WriteLine($"f1={f1}, f2={f2}");

// implizite Konvertierungen: ohne Informationsverlust
long l = i;
double d = l;
Console.WriteLine($"l={l}, d={d}");

// explizite Konvertierungen (Cast): möglicher Informationsverlust
double real = 3.99;
int truncated = (int)real;
int rounded = (int)Math.Round(real);
Console.WriteLine($"(int)3.99={truncated}, (int)Math.Round(3.99)={rounded}");
long large = 3_000_000_000;
int overflowed = (int)large;
Console.WriteLine($"(int)3000000000={overflowed}");

// Zeichen und Ganzzahlen
char c = (char)65;
int code = 'é';
Console.WriteLine($"(char)65={c}, code of 'é'={code}");

// Überlauf: standardmäßig stillschweigend
int max = int.MaxValue;
int next = max + 1;
Console.WriteLine($"int.MaxValue + 1 = {next}");
// checked: der Überlauf löst eine Exception aus
try
{
    int verified = checked(max + 1);
    Console.WriteLine($"verified={verified}");
}
catch (OverflowException e)
{
    Console.WriteLine($"checked(max + 1) : {e.GetType().Name} - {e.Message}");
}
try
{
    checked
    {
        int conversion = (int)large;
        Console.WriteLine($"conversion={conversion}");
    }
}
catch (OverflowException e)
{
    Console.WriteLine($"checked((int)large) : {e.GetType().Name} - {e.Message}");
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run basics-15.cs
f1=0, f2=0,75
l=3, d=3
(int)3.99=3, (int)Math.Round(3.99)=4
(int)3000000000=-1294967296
(char)65=A, code of 'é'=233
int.MaxValue + 1 = -2147483648
checked(max + 1) : OverflowException - Arithmetic operation resulted in an overflow.
checked((int)large) : OverflowException - Arithmetic operation resulted in an overflow.

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:

Environment.Exit(int status);

[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:

Environment.Exit(0);

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:

// Programm mit einem Exit-Code beenden
Console.WriteLine("Start of the program");
// der Exit-Code wird als Argument übergeben (siehe den Abschnitt über Programmargumente)
if (args.Length == 0 || !int.TryParse(args[0], out int code))
{
    Console.Error.WriteLine("Syntax : dotnet run basics-16.cs -- exit_code");
    Environment.Exit(1);
    return;
}
Console.WriteLine($"Stopping with exit code {code}");
Environment.Exit(code);
Console.WriteLine("This line is never executed");

Ergebnisse in einem bash-Terminal:

> dotnet run basics-16.cs -- 3
Start of the program
Stopping with exit code 3
> echo $?
3
> dotnet run basics-16.cs
Start of the program
Syntax : dotnet run basics-16.cs -- exit_code
> echo $?
1

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

1
2
3
4
5
6
7
8
if (condition)
{
    actions_condition_true;
}
else
{
    actions_condition_false;
}

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:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

Beispiel:

if (x > 0) { nx = nx + 1; sx = sx + x; } else dx = dx - x;

Auswahlstrukturen können verschachtelt werden. Das führt manchmal zu dem Problem, das das Programm [basics-17.cs] veranschaulicht:

// einfache Auswahlstruktur if
int n = 5;
// ein else gehört immer zum nächstgelegenen if
if (n > 1)
    if (n > 6)
        Console.WriteLine(">6");
    else
        Console.WriteLine("<=6");

// mit geschweiften Klammern gehört das else zum ersten if
int n2 = 0;
if (n2 > 1)
{
    if (n2 > 6)
    {
        Console.WriteLine(">6");
    }
}
else
{
    Console.WriteLine("<=1");
}

// eine Folge von Auswahlen: else if
int grade = 13;
string honours;
if (grade < 10)
{
    honours = "failed";
}
else if (grade < 12)
{
    honours = "pass";
}
else if (grade < 14)
{
    honours = "fairly good";
}
else
{
    honours = "good";
}
Console.WriteLine($"grade={grade}, honours={honours}");

Ergebnisse:

1
2
3
4
> dotnet run basics-17.cs
<=6
<=1
grade=13, honours=fairly good

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:

switch (expression)
{
    case v1:
        actions1;
        break;
    case v2:
        actions2;
        break;
    ...
    default:
        actions_otherwise;
        break;
}

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:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

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:

1
2
3
4
5
6
7
result = expression switch
{
    pattern1 => value1,
    pattern2 => value2,
    ...
    _ => value_otherwise
};

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:

// Fallunterscheidung: switch-Anweisung und switch-Ausdruck
int choice = 2;
bool error = false;
switch (choice)
{
    case 0:
        return;
    case 1:
        M1();
        break;
    case 2:
        M2();
        break;
    default:
        error = true;
        break;
}
Console.WriteLine($"error={error}");

// mehrere Werte für denselben Fall, Ausdruck vom Typ string
string day = "saturday";
switch (day)
{
    case "saturday":
    case "sunday":
        Console.WriteLine($"{day} : weekend");
        break;
    default:
        Console.WriteLine($"{day} : weekday");
        break;
}

// switch-Ausdruck (C# 8): er liefert einen Wert
string dayType = day switch
{
    "saturday" or "sunday" => "weekend",
    "monday" or "tuesday" or "wednesday" or "thursday" or "friday" => "weekday",
    _ => "unknown day"
};
Console.WriteLine($"{day} : {dayType}");

// relationale Muster (<, <=, >, >=) und logische Muster (and, or, not) (C# 9)
Console.WriteLine($"-5 : {Classify(-5)}");
Console.WriteLine($"0 : {Classify(0)}");
Console.WriteLine($"7 : {Classify(7)}");
Console.WriteLine($"42 : {Classify(42)}");
Console.WriteLine($"1000 : {Classify(1000)}");
// das not-Muster
bool workingDay = day is not ("saturday" or "sunday");
Console.WriteLine($"{day} working day : {workingDay}");

// oben verwendete lokale Funktionen
static void M1()
{
    Console.WriteLine("M1");
}

static void M2()
{
    Console.WriteLine("M2");
}

static string Classify(int n) => n switch
{
    < 0 => "negative",
    0 => "zero",
    > 0 and <= 10 => "small",
    > 10 and < 100 => "medium",
    _ => "large"
};

Ergebnisse:

> dotnet run basics-18.cs
M2
error=False
saturday : weekend
saturday : weekend
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
saturday working day : False

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:

1
2
3
4
for (i = id; i <= if; i = i + ip)
{
    actions;
}

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:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

die sich in eine while-Struktur übersetzen lässt:

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

Die foreach-Struktur

Die Syntax lautet wie folgt:

1
2
3
4
foreach (Type variable in collection)
{
    instructions;
}

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

1
2
3
4
while (condition)
{
    actions;
}

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:

1
2
3
while condition
    actions
endwhile

Die „do while“-Schleife

Die Syntax lautet wie folgt:

1
2
3
4
do
{
    instructions;
} while (condition);

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“:

1
2
3
repeat
    actions
until not condition

Allgemeine Schleifenstruktur (for)

Die Syntax lautet wie folgt:

1
2
3
4
for (start_instructions; condition; end_of_loop_instructions)
{
    instructions;
}

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:

1
2
3
4
5
start_instructions
while condition
    actions
    end_of_loop_instructions
endwhile

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:

// Wiederholungsstrukturen
// vier Möglichkeiten, die Summe der ersten 10 Ganzzahlen zu berechnen
int i, sum, n = 10;
for (i = 1, sum = 0; i <= n; i = i + 1)
{
    sum = sum + i;
}
Console.WriteLine($"for (1) : sum={sum}");

for (i = 1, sum = 0; i <= n; sum = sum + i, i = i + 1)
{
}
Console.WriteLine($"for (2) : sum={sum}");

i = 1;
sum = 0;
while (i <= n)
{
    sum += i;
    i++;
}
Console.WriteLine($"while : sum={sum}");

i = 1;
sum = 0;
do
{
    sum += i++;
} while (i <= n);
Console.WriteLine($"do while : sum={sum}");

// die Schleifenvariable kann im for deklariert werden: sie existiert nur innerhalb der Schleife
int product = 1;
for (int k = 1; k <= 5; k++)
{
    product *= k;
}
Console.WriteLine($"5! = {product}");

// foreach: Iteration über alle Elemente einer Collection
string[] friends = ["paul", "hélène", "jacques", "sylvie"];
foreach (string name in friends)
{
    Console.WriteLine(name);
}

// break und continue
for (int k = 1; k <= 10; k++)
{
    // gerade Zahlen werden übersprungen
    if (k % 2 == 0)
    {
        continue;
    }
    // nach der 7 wird abgebrochen
    if (k > 7)
    {
        break;
    }
    Console.Write($"{k} ");
}
Console.WriteLine();

// Endlosschleife, die mit break verlassen wird: das erste Vielfache von 7 über 50
int multiple = 50;
while (true)
{
    multiple++;
    if (multiple % 7 == 0)
    {
        break;
    }
}
Console.WriteLine($"first multiple of 7 greater than 50 : {multiple}");

Ergebnisse:

> dotnet run basics-19.cs
for (1) : sum=55
for (2) : sum=55
while : sum=55
do while : sum=55
5! = 120
paul
hélène
jacques
sylvie
1 3 5 7 
first multiple of 7 greater than 50 : 56

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:

1
2
3
4
5
6
7
8
9
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

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:
try
{
    code likely to throw the exceptions
}
catch (IndexOutOfRangeException e1)
{
    handle the exception e1
}
catch (FormatException e2)
{
    handle the exception e2
}
next statement

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:
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
finally
{
    code executed after try or catch
}
next statement

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:
1
2
3
4
5
catch (Exception ex)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
    ...
}
  • 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:

// eine durch einen falschen Array-Index verursachte Exception
int[] tab = [0, 1, 2, 3];
// Anzeige des Arrays mit einem for
for (int i = 0; i < tab.Length; i++)
{
    Console.WriteLine($"tab[{i}]={tab[i]}");
}
// Anzeige des Arrays mit einem foreach
foreach (int elmt in tab)
{
    Console.WriteLine(elmt);
}
// eine Exception auslösen
try
{
    tab[100] = 6;
}
catch (Exception e)
{
    Console.Error.WriteLine($"The following error occurred: {e.GetType().FullName} - {e.Message}");
    return;
}
finally
{
    Console.WriteLine("finally ...");
}
Console.WriteLine("This line is not executed");

Ergebnisse:

> dotnet run basics-20.cs
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: System.IndexOutOfRangeException - Index was outside the bounds of the array.
finally ...

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:

// Eingabe eines Alters mit Behandlung der Konvertierungs-Exception
// wir fragen nach dem Namen
Console.Write("Name: ");
string name = Console.ReadLine() ?? "";
// wir fragen nach dem Alter
int age = 0;
bool ageOK = false;
while (!ageOK)
{
    // Frage
    Console.Write("age: ");
    // Lesen und Prüfen der Antwort
    try
    {
        age = int.Parse(Console.ReadLine() ?? "");
        ageOK = age >= 1;
    }
    catch (FormatException)
    {
    }
    if (!ageOK)
    {
        Console.WriteLine("Incorrect age, try again...");
    }
}
// abschließende Anzeige
Console.WriteLine($"Your name is {name} and you are {age} year(s) old");

Ergebnisse:

1
2
3
4
> dotnet run basics-21.cs
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
1
2
3
4
5
6
7
8
> dotnet run basics-21.cs
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old

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:

throw new ArgumentException("error message");

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:

// mehrere catch-Klauseln, when-Filter, Auslösen von Exceptions
string[] inputs = ["12", "abc", "", "99999999999", "-3", "150"];
foreach (string input in inputs)
{
    try
    {
        int age = ReadAge(input);
        Console.WriteLine($"[{input}] : age={age}");
    }
    // when-Filter: die Klausel wird nur gewählt, wenn die Bedingung wahr ist
    catch (FormatException) when (input.Length == 0)
    {
        Console.WriteLine($"[{input}] : empty input");
    }
    catch (FormatException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (OverflowException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
}

// throw-Ausdruck (C# 7): rechts von ?? oder in einem ternären Operator
string?[] names = ["dupont", null];
foreach (string? name in names)
{
    try
    {
        string valid = name ?? throw new ArgumentNullException(nameof(name), "the name is mandatory");
        Console.WriteLine($"name={valid}");
    }
    catch (ArgumentNullException e)
    {
        Console.WriteLine($"{e.GetType().Name} - {e.Message}");
    }
}

// eine lokale Funktion, die Exceptions auslöst
static int ReadAge(string text)
{
    // int.Parse löst FormatException oder OverflowException aus
    int age = int.Parse(text);
    // wir lösen selbst eine Exception aus, wenn das Alter außerhalb der Grenzen liegt
    if (age < 0 || age > 130)
    {
        throw new ArgumentException($"age out of bounds [0,130] : {age}");
    }
    return age;
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run basics-22.cs
[12] : age=12
[abc] : FormatException - The input string 'abc' was not in a correct format.
[] : empty input
[99999999999] : OverflowException - Value was either too large or too small for an Int32.
[-3] : ArgumentException - age out of bounds [0,130] : -3
[150] : ArgumentException - age out of bounds [0,130] : 150
name=dupont
ArgumentNullException - the name is mandatory (Parameter 'name')

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:

8382    0.068    291.09

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:

// Steuerberechnung - Version 1
// Steuertarif 2004 (Einkommen 2003): dies ist eine Übung, nicht der aktuelle Steuertarif

// für die Steuerberechnung benötigte Datenarrays
decimal[] limits = [4962M, 8382M, 14753M, 23888M, 38868M, 47932M, 0M];
decimal[] coeffR = [0M, 0.068M, 0.191M, 0.283M, 0.374M, 0.426M, 0.481M];
decimal[] coeffN = [0M, 291.09M, 1322.92M, 2668.39M, 4846.98M, 6883.66M, 9505.54M];

// Familienstand
string answer;
while (true)
{
    Console.Write("Are you married (Y/N)? ");
    answer = (Console.ReadLine() ?? "").Trim().ToLower();
    if (answer is "y" or "n")
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}
bool married = answer == "y";

// Anzahl der Kinder
int nbChildren;
while (true)
{
    Console.Write("Number of children: ");
    if (int.TryParse(Console.ReadLine(), out nbChildren) && nbChildren >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// Jahresgehalt
int salary;
while (true)
{
    Console.Write("Annual salary: ");
    if (int.TryParse(Console.ReadLine(), out salary) && salary >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// Anzahl der Anteile
decimal shares = married ? nbChildren / 2M + 2 : nbChildren / 2M + 1;
if (nbChildren >= 3)
{
    shares += 0.5M;
}

// zu versteuerndes Einkommen
decimal income = 0.72M * salary;

// Familienquotient
decimal quotient = income / shares;

// Suche der Steuerstufe: die erste mit Quotient <= Grenze,
// die letzte, wenn keine passt
int i = 0;
while (i < limits.Length - 1 && quotient > limits[i])
{
    i++;
}

// die Steuer (auf den Euro abgeschnitten)
int tax = (int)(coeffR[i] * income - coeffN[i] * shares);

// Anzeige des Ergebnisses
Console.WriteLine($"Tax to pay: {tax} euros");

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:

1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> dotnet run tax-v1.cs
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

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:

P arg0 arg1 ... argn

und ist die Funktion [Main] wie folgt deklariert:

        static void Main(string[] args)

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:

dotnet run prog.cs -- a0 a1 a2

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]:

1
2
3
4
5
6
7
// die Kommandozeilenargumente
// bei Top-Level-Anweisungen ist das Array args vordefiniert
Console.WriteLine($"There are {args.Length} argument(s)");
for (int i = 0; i < args.Length; i++)
{
    Console.WriteLine($"args[{i}]={args[i]}");
}

Ergebnisse:

1
2
3
4
5
6
> dotnet run basics-23.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Ein Argument, das Leerzeichen enthält, muss in Anführungszeichen gesetzt werden:

1
2
3
4
> dotnet run basics-23.cs -- "jean dupont" 23
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

Dasselbe Programm, geschrieben mit einer klassischen Methode [Main]: [basics-24.cs]:

// die Kommandozeilenargumente mit einer klassischen Methode Main
namespace Basics;

public static class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine($"There are {args.Length} argument(s)");
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine($"args[{i}]={args[i]}");
        }
    }
}

Ergebnisse:

1
2
3
4
5
6
> dotnet run basics-24.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

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:

enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

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:

Honours myHonours = Honours.Pass;

Eine Variable kann mit den verschiedenen möglichen Werten der Aufzählung verglichen werden:

1
2
3
4
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}

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:

// Aufzählungen
// eine Variable, die ihre Werte aus der Aufzählung Honours bezieht
Honours myHonours = Honours.Pass;
// Anzeige des Werts der Variablen
Console.WriteLine($"honours={myHonours}");
// Test mit einem Wert der Aufzählung
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}
// Liste der Honours: Name und Ganzzahlwert
foreach (Honours m in Enum.GetValues<Honours>())
{
    Console.WriteLine($"{m} = {(int)m}");
}
// Liste der Namen
Console.WriteLine(string.Join(", ", Enum.GetNames<Honours>()));
// Ganzzahl --> Aufzählung
Honours m3 = (Honours)3;
Console.WriteLine($"(Honours)3 = {m3}");
// string --> Aufzählung
if (Enum.TryParse("Good", out Honours m2))
{
    Console.WriteLine($"m2={m2}, m2 > Pass : {m2 > Honours.Pass}");
}
// eine Aufzählung in einem switch-Ausdruck
string assessment = myHonours switch
{
    Honours.Pass or Honours.FairlyGood => "correct",
    Honours.Good or Honours.VeryGood => "very correct",
    _ => "remarkable"
};
Console.WriteLine($"assessment : {assessment}");
Console.WriteLine($"type : {typeof(Honours).FullName}, underlying type : {Enum.GetUnderlyingType(typeof(Honours)).Name}");

// die Deklaration eines Typs steht nach den Top-Level-Anweisungen
enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

Ergebnisse:

> dotnet run basics-25.cs
honours=Pass
Could do better
Pass = 0
FairlyGood = 1
Good = 2
VeryGood = 3
Excellent = 4
Pass, FairlyGood, Good, VeryGood, Excellent
(Honours)3 = VeryGood
m2=Good, m2 > Pass : True
assessment : correct
type : Honours, underlying type : Int32

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:

1
2
3
4
5
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

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:

1
2
3
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

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:

// Arten der Parameterübergabe
// 1 - Übergabe als Wert
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

// 2 - Übergabe als Referenz mit ref
int age2 = 20;
ChangeInt2(ref age2);
Console.WriteLine($"Actual parameter age2={age2}");

// 3 - Übergabe als Referenz mit out: die Variable muss nicht initialisiert sein
int age3;
ChangeInt3(out age3);
Console.WriteLine($"Actual parameter age3={age3}");
// out var (C# 7): die Variable wird im Aufruf deklariert
ChangeInt3(out var age4);
Console.WriteLine($"Actual parameter age4={age4}");

// 4 - ein Vertauschen von Werten mit ref
int x = 1, y = 2;
Swap(ref x, ref y);
Console.WriteLine($"after swap : x={x}, y={y}");

// 5 - schreibgeschützte Übergabe als Referenz mit in
decimal price = 100M;
Console.WriteLine($"InclTax({price})={InclTax(in price)}");

// 6 - ein als Wert übergebenes Array: kopiert wird seine Referenz
int[] array = [1, 2, 3];
ModifyArray(array);
Console.WriteLine($"array=[{string.Join(", ", array)}]");

// die lokalen Funktionen
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

static void ChangeInt2(ref int a2)
{
    a2 = 30;
    Console.WriteLine($"Formal parameter a2={a2}");
}

static void ChangeInt3(out int a3)
{
    a3 = 30;
    Console.WriteLine($"Formal parameter a3={a3}");
}

static void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

static decimal InclTax(in decimal amount)
{
    // amount = 0; würde abgelehnt: ein in-Parameter kann nicht verändert werden
    return amount * 1.2M;
}

static void ModifyArray(int[] t)
{
    // wir verändern das referenzierte Array: der Aufrufer sieht die Änderung
    t[0] = 100;
    // wir lassen t auf ein anderes Array zeigen: der Aufrufer sieht das nicht
    t = [7, 8, 9];
    Console.WriteLine($"in ModifyArray : t=[{string.Join(", ", t)}]");
}

Ergebnisse:

> dotnet run basics-26.cs
Formal parameter a=30
Actual parameter age=20
Formal parameter a2=30
Actual parameter age2=30
Formal parameter a3=30
Actual parameter age3=30
Formal parameter a3=30
Actual parameter age4=30
after swap : x=2, y=1
InclTax(100)=120,0
in ModifyArray : t=[7, 8, 9]
array=[100, 2, 3]

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:

error CS0165: Use of unassigned local variable 'age2'

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:

error CS8331: Cannot assign to variable 'amount' or use it as the right hand side of a ref assignment because it is a readonly variable

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:

// optionale Parameter, benannte Argumente, variable Parameteranzahl
// optionale Parameter (C# 4): sie haben einen Standardwert
Console.WriteLine(Greet("Pierre"));
Console.WriteLine(Greet("Pierre", "Good evening"));
// benannte Argumente (C# 4): ein optionaler Parameter kann ausgelassen oder die Reihenfolge geändert werden
Console.WriteLine(Greet("Pierre", uppercase: true));
Console.WriteLine(Greet(uppercase: true, greeting: "Hi", name: "Paul"));

// params: variable Anzahl von Parametern
Console.WriteLine($"Sum()={Sum()}");
Console.WriteLine($"Sum(1, 2, 3)={Sum(1, 2, 3)}");
int[] values = [10, 20, 30];
Console.WriteLine($"Sum(values)={Sum(values)}");
// eine Framework-Methode mit variabler Parameteranzahl
Console.WriteLine(string.Join(" - ", "a", "b", "c"));

static string Greet(string name, string greeting = "Hello", bool uppercase = false)
{
    string message = $"{greeting} {name}";
    return uppercase ? message.ToUpper() : message;
}

static int Sum(params int[] numbers)
{
    // numbers ist ein Array
    int sum = 0;
    foreach (int number in numbers)
    {
        sum += number;
    }
    return sum;
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run basics-27.cs
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
Sum()=0
Sum(1, 2, 3)=6
Sum(values)=60
a - b - c

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:

// lokale Funktionen und Tupel
// eine lokale Funktion mit Ausdruckskörper
static int Square(int x) => x * x;
Console.WriteLine($"Square(7)={Square(7)}");

// eine nicht statische lokale Funktion kann die Variablen des Programms verwenden
int counter = 0;
void Increment() => counter++;
Increment();
Increment();
Console.WriteLine($"counter={counter}");

// ein Tupel fasst mehrere Werte zusammen
(int, string) t1 = (1, "one");
Console.WriteLine($"t1={t1}, t1.Item1={t1.Item1}, t1.Item2={t1.Item2}");
// die Elemente eines Tupels können benannt werden
(int Number, string Name) t2 = (2, "two");
var t3 = (Number: 3, Name: "three");
Console.WriteLine($"t2.Number={t2.Number}, t3.Name={t3.Name}");
// Dekonstruktion: ein Tupel wird auf mehrere Variablen verteilt
var (number, name) = t3;
Console.WriteLine($"number={number}, name={name}");

// eine Funktion, die mehrere Werte ohne out-Parameter zurückgibt
var (quotient, remainder) = Divide(17, 5);
Console.WriteLine($"17 = 5 * {quotient} + {remainder}");
var mm = MinMax([12, -4, 35, 7]);
Console.WriteLine($"min={mm.Min}, max={mm.Max}");
// das Framework verwendet ebenfalls Tupel
var (q, r) = Math.DivRem(23, 4);
Console.WriteLine($"Math.DivRem(23, 4) : quotient={q}, remainder={r}");

// zwei Variablen mit einem Tupel vertauschen
int a = 1, b = 2;
(a, b) = (b, a);
Console.WriteLine($"a={a}, b={b}");

static (int Quotient, int Remainder) Divide(int a, int b) => (a / b, a % b);

static (int Min, int Max) MinMax(int[] values)
{
    int min = values[0], max = values[0];
    foreach (int v in values)
    {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return (min, max);
}

Ergebnisse:

> dotnet run basics-28.cs
Square(7)=49
counter=2
t1=(1, one), t1.Item1=1, t1.Item2=one
t2.Number=2, t3.Name=three
number=3, name=three
17 = 5 * 3 + 2
min=-4, max=35
Math.DivRem(23, 4) : quotient=5, remainder=3
a=2, b=1

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.