Nullable Types
Deklariere int? size. Weise 4 zu. Schreibe size.HasValue und danach size.Value. Halte die Arbeit in Pine mit Main. Fuer die behaltene Datei dieser Seite brauchst du kein System.Collections.Generic. Starte mit dotnet run. Der Bildschirm soll zwei Zeilen zeigen: True dann 4. Ein int? kann eine Zahl oder null halten. HasValue sagt, ob eine Zahl gespeichert ist. Value liest die Zahl, wenn sie da ist. Behalte den oeffentlichen Klassennamen Pine.
Ein Werttyp, der auch leer sein kann
Auf der frueheren null-Seite konnte ein string null halten, ein normales int nicht. Diese Seite fuehrt die nullable Form int? ein. Das Fragezeichen auf dem Typ heisst: der Name darf int oder null halten. Fuer immer eine Zahl brauchst du weiter normales int. Fuer «noch keine Zahl» als echten Zustand nimmst du int?. Stell dir die Box als leer oder mit einer Zahl vor — nie beides gleichzeitig.
Oeffne die Pine-Datei. Der Starter heisst weiter Pine. Entferne jedes foreach ueber bag, das nur Listwerte druckt. Entferne HashSet-Count-Ueberbleibsel. Entferne jede ReadLine-Zeile. Die Datei wartet nicht auf Tippen. Ein sauberes Main macht den zweizeiligen nullable-Bildschirm vertrauenswuerdig. Bleibt foreach drin, kann 3 dann 8 statt der nullable-Zeilen erscheinen.
Behalte oben using System;. Schreibe in Main fuer den ersten Check int? size = null; dann Console.WriteLine(size.HasValue);. Speichere und starte diese kurze Form. Der Bildschirm zeigt False, weil keine Zahl gespeichert ist. Erweitere dann zu int? size = 4; mit beiden Schreibzeilen HasValue und Value als behaltene Demo. Der null-HasValue-Lauf ist nur eine Kontrollstelle; die behaltene Antwort bleibt True dann 4.
Schreibe nicht int size = null; ohne ? am Typ — der Build schlaegt fehl. Das ? gehoert zum Typnamen: int?. Gewohne dich an int?, nicht int ? mit Leerzeichen.
using System;
public class Pine
{
public static void Main()
{
int? size = null;
Console.WriteLine(size.HasValue);
}
}
Pine speichert 4 und schreibt HasValue dann Value
In Main schreibe int? size = 4; oder weise nach einem null-Start size = 4; zu. Schreibe zuerst size.HasValue, damit der Bildschirm zeigt, dass eine Zahl da ist. Dann size.Value, damit die Zahl selbst erscheint. In der behaltenen Datei gehst du nicht mit foreach ueber eine Liste. Die Demo ist der nullable int.
using System;
public class Pine
{
public static void Main()
{
int? size = 4;
Console.WriteLine(size.HasValue);
Console.WriteLine(size.Value);
}
}
Lies die behaltene Datei von oben. using System; bereitet Konsolennamen vor. public class Pine ist der Starter. public static void Main() startet die Laufzeit. int? size = 4; speichert eine Zahl im nullable int. size.HasValue schreibt True. size.Value schreibt 4.
Starte mit dotnet run. Das Programm schreibt zwei Zeilen und stoppt. Es wartet nicht. Wartet dotnet run, steckt noch ReadLine in der Datei — loesche die Zeile. Der Bildschirm zeigt True dann 4. Siehst du 3 dann 8, laeuft vielleicht noch eine foreach-Demo. Nur False bedeutet null-Kontrollstelle — wechsle zur Datei, die vor den zwei Schreibzeilen 4 setzt.
Liest du size.Value waehrend size noch null ist, kann der Lauf werfen. Pruefe HasValue oder vergleiche mit null, bevor du Value liest, wenn der Name leer sein kann. In der behaltenen Demo liegt 4 schon gespeichert, also ist Value sicher. int size = null; ohne ? bricht den Build — setze das ? auf den Typ zurueck.
int versus int? auf dieser Seite
Ein normales int haelt immer eine Zahl. Ein int? darf Zahl oder null halten. Ist nullable null, ist HasValue False; ist eine Zahl gespeichert, True. Value ist die Zahl selbst, wenn HasValue True ist.
Eine foreach (int n in bag)-Ueberbleibsel-Demo ist eine andere Lektion. Behalte hier int? size und die HasValue/Value-Schreibzeilen. Beides in einem Main kann Listenwerte statt nullable-Zeilen drucken — nimm die foreach-Arbeit raus, waehrend du int? uebst.
📊 int vs int?
| Form | Bedeutung auf dieser Seite |
|---|---|
int size = 4; |
immer eine Zahl; kann nicht null sein |
int? size = null; |
noch keine Zahl; HasValue ist False |
int? size = 4; |
Zahl da; HasValue ist True; Value ist 4 |
Was fuer exceptions uebrig bleibt
Diese Seite deklariert int?, speichert null oder eine Zahl, liest HasValue und Value. Die naechste Seite — exceptions — behandelt Fehler mit try und catch. Bleib hier bei nullable-Werttypen. Erfinde auf dieser Seite keine Exception-Syntax; Ziel ist int? selbst. Gibt dotnet run aus der behaltenen Datei True dann 4 aus, hast du die Kontrollstelle dieser Seite.
Verschachtele kein zweites Main. Lass foreach-bag-Demos nicht als einzigen Lehrpfad stehen. Zeigt der Bildschirm nur False, nutze die Datei mit 4. Lehnt der Build null auf int ab, fehlte das ? am Typ. Schreibe int? mit Fragezeichen direkt an int.
Du kannst int? size = 4; schreiben, dann size.HasValue und size.Value. Starte mit dotnet run. Der Bildschirm zeigt True dann 4. War size null, war HasValue beim frueheren Check False. Denk an int? als Box, die eine Zahl halten darf oder leer ist. HasValue fragt, ob die Box eine Zahl hat. Value liest die Zahl, wenn die Box nicht leer ist. Lies Value nicht absichtlich bei leerer Box — das kann werfen. Pine bleibt die Tuer, die du mit dotnet run oeffnest. Die naechste Seite ist exceptions, wo du Fehler faengst statt hart zu stoppen.
Behalte das ? auf int?. Halte foreach-Demos aus Main fern, damit der Bildschirm nicht versehentlich 3 dann 8 zeigt. Diese Gewohnheiten sind die Kontrollstelle vor dem Weitergehen. Normales int, wenn «fehlende Zahl» nicht erlaubt ist. int?, wenn Leersein ein Zustand ist, den du abbilden musst. Beide Formen stehen in echten Programmen nebeneinander; diese Seite will nur die nullable-Form mit True dann 4 beweisen.
🧠 Testen Sie Ihr Wissen
Testen Sie Ihr Wissen
Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen
📝 Anweisungen
- Lesen Sie jede Frage sorgfältig
- Wählen Sie die beste Antwort für jede Frage
- Sie können das Quiz so oft wiederholen, wie Sie möchten
- Ihr Fortschritt wird oben angezeigt