C#: Variablen, Typen und Ausgabe

Kurz: Console.WriteLine("{name} ist {alter} Jahre alt"); // String-Interpolation Console.WriteLine(“Preis: {preis:F2} / {betrag:C} / {alter,5} / {alter:D4}”); Console.WriteLine(“Summe.

Teil des Kurses C#

Kapitel 2 von 16 im Kurs C# (Abschnitt „Grundlagen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

int alter = 17;
double preis = 19.99;
decimal betrag = 19.99m;            // exakt, für Geld
bool fertig = true;
char buchstabe = 'A';
string name = "Mia";
var zahl = 42;                      // var: Typ wird erkannt (int)
const double Pi = 3.14159;
 
Console.WriteLine($"{name} ist {alter} Jahre alt");            // String-Interpolation
Console.WriteLine($"Preis: {preis:F2} / {betrag:C} / {alter,5} / {alter:D4}");
Console.WriteLine("Summe: " + (zahl + 1) + " " + fertig + " " + buchstabe + " " + Pi);
Console.Write("ohne Zeilenumbruch, ");
Console.WriteLine("dann weiter");

Ausgabe:

Mia ist 17 Jahre alt
Preis: 19.99 / ¤19.99 /    17 / 0017
Summe: 43 True A 3.14159
ohne Zeilenumbruch, dann weiter

Eingebaute Typen

Typ	Größe	Bereich / Zweck
byte / sbyte	8 Bit	0 bis 255 / -128 bis 127
short / ushort	16 Bit
int / uint	32 Bit	±2,1 Milliarden (Standard)
long / ulong	64 Bit	±9,2 · 10¹⁸
float	32 Bit	ca. 7 Stellen (3.5f)
double	64 Bit	ca. 15 Stellen (Standard für Kommazahlen)
decimal	128 Bit	28 Stellen, exakt für Geld (19.99m)
bool		true / false
char	16 Bit	ein UTF-16-Zeichen
string		Text (unveränderlich)
object		Basis aller Typen

Console.WriteLine($"{int.MaxValue} {int.MinValue} {long.MaxValue}");
Console.WriteLine($"{double.MaxValue} {decimal.MaxValue}");
Console.WriteLine(0.1 + 0.2);
Console.WriteLine(0.1m + 0.2m);                    // decimal rechnet exakt
Console.WriteLine(7 / 2 + " " + 7 / 2.0 + " " + 7 % 3 + " " + (double) 7 / 2);
int gross = int.MaxValue;
unchecked { gross++; }
Console.WriteLine(gross);                          // Überlauf: springt auf das Minimum
try { checked { int k = int.MaxValue; k++; } } catch (OverflowException) { Console.WriteLine("Überlauf erkannt"); }

Ausgabe:

2147483647 -2147483648 9223372036854775807
1.7976931348623157E+308 79228162514264337593543950335
0.30000000000000004
0.3
3 3.5 1 3.5
-2147483648
Überlauf erkannt

Typumwandlung

int a = 7;
double d = a;                                  // automatisch (verlustfrei)
int b = (int) 3.99;                            // explizit: schneidet ab
long l = 5_000_000_000;                        // Unterstriche lesbar
Console.WriteLine($"{d} {b} {l}");
 
int n = int.Parse("42");
bool ok = int.TryParse("abc", out int wert);   // sicher: kein Fehler bei ungültiger Eingabe
Console.WriteLine($"{n} {ok} {wert}");
double x = double.Parse("3.5", System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine(x * 2);
Console.WriteLine(Convert.ToInt32("17") + Convert.ToString(255, 16) + " " + 42.ToString("D5"));

Ausgabe:

7 3 5000000000
42 False 0
7
17ff 00042

Nutze TryParse für Eingaben von Menschen: Es wirft keine Ausnahme, sondern liefert false.

Konstanten und readonly

const int MaxVersuche = 3;                    // Compile-Zeit-Konstante
Console.WriteLine(MaxVersuche);
var pruefung = new Pruefung();
Console.WriteLine(pruefung.Erstellt.Year > 2000);
 
class Pruefung
{
    public readonly DateTime Erstellt = DateTime.Now;     // nur im Konstruktor/Initialisierer zuweisbar
}

Ausgabe:

3
True

Werte- und Referenztypen

• Werttypen (int, double, bool, struct, enum) enthalten den Wert direkt; Zuweisung kopiert
• Referenztypen (class, string, Arrays, object) enthalten einen Verweis; Zuweisung kopiert den Verweis

int a = 1, b = a;
b = 99;
Console.WriteLine($"{a} {b}");                // 1 99: unabhängige Kopien
 
int[] x = {1, 2, 3};
int[] y = x;                                  // gleicher Verweis
y[0] = 99;
Console.WriteLine(x[0]);                      // 99: dasselbe Array
 
string s1 = "Hallo", s2 = s1;
s2 += "!";
Console.WriteLine($"{s1} {s2}");              // Strings sind unveränderlich: s1 bleibt

Ausgabe:

1 99
99
Hallo Hallo!

Merke

• Typen: int, double, decimal (Geld), bool, char, string; var lässt den Compiler den Typ erkennen
• String-Interpolation $"{name}" mit Formaten (:F2, :C, :D4)
• TryParse ist die sichere Umwandlung von Eingaben
• decimal für Geld, double für Wissenschaft
• Werttypen werden kopiert, Referenztypen teilen sich das Objekt
• checked erkennt Überläufe

Übungsaufgabe

Berechne aus einem Nettopreis (decimal) und 19 % Steuer den Bruttopreis und gib ihn als Währung aus.

Quiz zur Selbstkontrolle

Welchen Typ nimmst du für Geldbeträge?

• decimal (richtig)
• float
• double
• int

Was macht int.TryParse?

• Wandelt Text in int um und meldet Erfolg als bool (richtig)
• Wirft immer eine Ausnahme
• Rundet Zahlen
• Formatiert Zahlen

y = x?

• y und x zeigen auf dasselbe Array (richtig)
• Das Array wird kopiert
• Ein Compilerfehler
• y wird leer

Weiter im Kurs

Zurück: Was ist C#?

Weiter: Operatoren, Bedingungen und Schleifen

Alle Kapitel: C# im Überblick