Freigeben über

Integrierte Typen und Literale

Tipp

Neu bei der Entwicklung von Software? Beginnen Sie zuerst mit den Lernprogrammen " Erste Schritte ". Sie stellen Typen vor, während Sie Ihre ersten Programme schreiben.

Haben Sie Erfahrung in einer anderen Sprache? Integrierte C#-Typen ordnen Typen in Java, C++ und anderen Sprachen genau zu. Überfliegen Sie die Literalsyntax und Typinferenz-Abschnitte für C#-spezifische Details.

C# stellt eine Reihe integrierter Typen bereit, die Sie in jedem Programm ohne zusätzliche Verweise verwenden können. Diese Typen decken die am häufigsten verwendeten Daten ab, mit den Sie arbeiten: Zahlen, Wahr/Falsch-Werte, einzelne Zeichen und Text. Eine vollständige Referenztabelle, die C#-Schlüsselwörter zu .NET-Typen zuordnen, finden Sie unter Integrierte Typen (C#-Referenz).

Numerische Typen

C# verfügt über integrierte Typen für ganze Zahlen, Gleitkommazahlen und Dezimalzahlen. Die am häufigsten verwendeten Typen sind int, doubleund decimal:

int population = 67_000_000;
long distance = 384_400_000L;
short temperature = -40;
byte red = 255;

double pi = 3.141592653589793;
float gravity = 9.81f;
decimal price = 19.99m;

Jeder numerische Typ weist eine feste Größe und einen festen Bereich auf. int Speichert 32-Bit-Ganzzahlen (ungefähr ±2,1 Mrd.), long speichert 64-Bit-Ganzzahlen und shortbyte speichert kleinere Werte. Eine vollständige Liste der Größen und Bereiche finden Sie unter Integrale numerische Typen und numerische Gleitkommatypen.

Verwenden Sie double für allgemeine Gleitkommaberechnungen, float wenn der Speicher begrenzt ist, und decimal wenn Sie Dezimalgenauigkeit (z. B. Finanzberechnungen) benötigen. Fügen Sie das f Suffix für float Literale und m für decimal Literale an. Ohne Suffix behandelt der Compiler eine Zahl mit einem Dezimalkomma als double.

Nicht signierte Typen

Jeder signierte ganzzahlige Typ weist ein nicht signiertes Gegenstück auf, das nur nicht negative Werte mit doppelt dem positiven Bereich speichert:

uint fileSize = 4_294_967_295;
ulong totalBytes = 18_446_744_073_709_551_615;
ushort port = 443;

Sie können nicht signierte Typen verwenden, wenn negative Werte für die Daten nicht gültig sind, z. B. Dateigrößen oder Netzwerkports. In der Praxis verwenden viele Anwendungen int oder long selbst für ausschließlich positive Werte, da signierte Typen die Standardeinstellung in den .NET-APIs sind.

Ganzzahlen in systemeigener Größe

Die nint Und nuint Typen stellen ganze Zahlen dar, deren Größe der systemeigenen Zeigergröße der Plattform entspricht: 32 Bits auf einer 32-Bit-Plattform, 64 Bits auf einer 64-Bit-Plattform:

nint bufferSize = 1024;
nuint elementCount = 256;

Es ist unwahrscheinlich, dass Sie nint oder nuint im Alltagscode benötigen. Sie sind für Interoperabilitätsszenarien und Speichervorgänge niedriger Ebene vorhanden, bei denen die Übereinstimmung mit der Zeigergröße der Plattform wichtig ist. Verwenden Sie int oder long, es sei denn, Sie haben einen spezifischen Grund, datentypen in nativer Größe zu verwenden. Weitere Informationen finden Sie unter nint und nuint.

bool, char und string

Neben Zahlen bietet C# drei weitere häufig verwendete integrierte Typen:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Speichert true oder false. Verwenden Sie sie in Bedingungen, Schleifen und logischen Ausdrücken.
  • char – Speichert ein einzelnes Unicode-Zeichen (UTF-16-Codeeinheit), das in einfache Anführungszeichen eingeschlossen ist.
  • string - Speichert eine Abfolge von Zeichen, die in doppelte Anführungszeichen eingeschlossen sind. Zeichenfolgen sind unveränderlich. Nachdem Sie eine Zeichenfolge erstellt haben, können Sie den Inhalt nicht mehr ändern. Vorgänge, die scheinbar eine Zeichenfolge ändern, erstellen tatsächlich eine neue.

Zeichenfolgen sind einer der am häufigsten verwendeten Typen in C#. Ausführliche Erklärungen zu Zeichenfolgenvorgängen, einschließlich Interpolation, Rohzeichenfolgenliteralen, Suche, Teilung und Vergleich, finden Sie im Abschnitt "Zeichenfolgen".

Literal-Syntax

Ein Literal ist ein Wert, den Sie direkt in Ihren Code schreiben. Der Compiler weist jedem Literal einen Typ basierend auf seinem Format und jedem von Ihnen bereitgestellten Suffix zu. C# unterstützt die folgenden Arten von Literalen:

  • Ganzzahlige Literale — Dezimalzahl (42), Hexadezimal (0x2A) und Binär (0b_0010_1010).
  • Gleitkommaliterale – double standardmäßig (3.14), float mit dem f Suffix (3.14f) und decimal mit m (3.14m).
  • Zeichenliterale – Ein einzelnes Zeichen in einfachen Anführungszeichen ('A'), einschließlich Escape-Sequenzen ('\n').
  • Zeichenkettenliterale – regulär ("hello"), wörtlich (@"C:\path"), roh (""" ... """) und interpoliert ($"value: {x}").
  • Boolesche Literale — true und false.
  • Das null-Literal – Stellt das Fehlen eines Werts für Referenztypen und null-Wertetypen dar.
  • Das default Literal – Erzeugt den Standardwert für einen beliebigen Typ (abgedeckt in default Ausdrücken).

In den folgenden Abschnitten werden die am häufigsten verwendeten Literalformen ausführlich behandelt.

Ganzzahlenliteral

int dec = 42;
int hex = 0x2A;
int bin = 0b_0010_1010;
long big = 1_000_000_000L;

Verwenden Sie das 0x Präfix für die Hexadezimalzahl und 0b für die Binärdatei. Append L for long, U for uint, oder UL für ulong.

Platzieren Sie das _ Zifferntrennzeichen an einer beliebigen Stelle innerhalb einer Zahl, um das Lesen zu erleichtern. Allgemeine Muster umfassen Tausendertrennzeichen in Dezimalliteralen (1_000_000_000), Byte- oder Wortgrenzen in hexadezimalen Darstellungen (0xFF_FF) und Nibbelgrenzen in Binärdarstellungen (0b_0010_1010).

Gleitkommaliterale

double d = 3.14;
float f = 3.14f;
decimal m = 3.14m;
double scientific = 1.5e6; // 1,500,000

Ohne Suffix ist doubleein numerisches Literal mit einem Dezimalkomma . Anfügen f für float und m für decimal. Wissenschaftliche Notation (1.5e6) wird ebenfalls unterstützt.

Zeichenkonstanten und Stringliterale

char newline = '\n';
char unicode = '\u0041'; // 'A'

string message = $"Found {dec} items";            // interpolated string
string path = @"C:\Users\docs\file.txt";        // verbatim string
string json = """
    { "name": "Alice", "age": 30 }
    """;                                           // raw string literal
string raw = $"""
    Found {dec} items in "{greeting}"
    """;                                           // raw + interpolated

Zeichenliterale verwenden einfache Anführungszeichen und unterstützen Escapesequenzen (\n, \t, \u). Zeichenfolgenliterale verwenden doppelte Anführungszeichen.

Präfixe Zeichenfolgen mit $ für die Interpolation. Wenn eine Zeichenfolge Anführungszeichen, umgekehrte Schrägstriche oder eingebettete JSON oder XML enthält, verwenden Sie ein unformatiertes """Zeichenfolgenliteral (durch Trennzeichen getrennt), anstatt jedes Zeichen zu entfernen. Rohe Zeichenfolgenliterale werden auch mit Interpolation ($""") kombiniert.

Älterer Code verwendet @ (Verbatim-Zeichenfolgen), um die Escape-Verarbeitung zu vermeiden. Unformatierte Zeichenfolgenliterale sind einfacher zu lesen und zu schreiben, daher bevorzugen Sie sie für neuen Code.

default Ausdrücke

Der default Ausdruck erzeugt den Standardwert für einen Typ: 0 für numerische Typen, false für , für boolund null für Referenztypen:

int defaultInt = default;          // 0
bool defaultBool = default;        // false
string? defaultString = default;   // null

// Use default in a conditional:
var limit = (args.Length > 0) ? int.Parse(args[0]) : default(int);

Der default Ausdruck ist am nützlichsten im generischen Code, in dem Sie den konkreten Typ nicht kennen und einen bestimmten Wert wie 0 oder nullnicht hartcodieren können. Schreiben default (ohne Typargument), wenn der Compiler den Typ aus dem Kontext ableiten kann oder default(T) wenn der Typ nicht offensichtlich ist. Die vollständige Liste der Standardwerte nach Typ finden Sie unter Standardwerte von C#-Typen.

Implizit eingegebene Variablen mit var

Das var Schlüsselwort weist den Compiler an, den Typ einer lokalen Variablen vom Initialisierer abzuleiten:

var count = 10;              // compiler infers int
var name = "C#";             // compiler infers string
var items = new List<int>(); // compiler infers List<int>

// var requires an initializer — the compiler needs a value to infer the type.
// The following line wouldn't compile:
// var unknown;

Die Variable ist immer noch stark typiert; var macht es nicht dynamisch. Der Compiler bestimmt den Typ zur Kompilierungszeit und erzwingt die Typsicherheit wie gewohnt. Verwenden Sie var , wenn der Typ von der rechten Seite aus offensichtlich ist, um visuelle Rauschen zu reduzieren. Schreiben Sie den Typ aus, wenn dies den Code klarer macht. Weitere Informationen finden Sie unter implizit typierten lokalen Variablen.

Ausdrücke mit Zieltyp new

Wenn Sie den Zieltyp bereits aus dem Kontext kennen, z. B. eine Variabledeklaration oder einen Methodenparameter, können Sie den Typnamen aus dem new Ausdruck weglassen:

List<string> names = new() { "Alice", "Bob", "Charlie" };
Dictionary<string, int> scores = new()
{
    ["Alice"] = 95,
    ["Bob"] = 87
};

Zieltyp reduziert new Wiederholungen, wenn der Typname lang ist oder auf der linken Seite der Zuordnung angezeigt wird. Er funktioniert an einer beliebigen Stelle, an der der Compiler den Zieltyp bestimmen kann, einschließlich Methodenargumente und Rückgabeanweisungen. Weitere Informationen finden Sie unter new Operator – Zieltyp.new

Der Typ dynamic

Der dynamic Typ umgeht die Überprüfung des Kompilierungszeittyps. Der Compiler löst zur Laufzeit stattdessen Vorgänge mit einer dynamic-Variable auf.

dynamic value = 42;
Console.WriteLine(value.GetType()); // System.Int32

value = "Now I'm a string";
Console.WriteLine(value.GetType()); // System.String

// The compiler doesn't check operations on dynamic at compile time.
// Errors surface at run time instead.

Verwenden Sie dynamic bei der Interaktion mit COM-APIs, dynamischen Programmiersprachen oder reflektionsintensiven Szenarien, in denen Typen zur Kompilierungszeit nicht bekannt sind. Vermeiden Sie dynamic in den meisten Anwendungscode, da die Kompilierungszeitsicherheit verloren geht. Fehler, die der Compiler normalerweise abfangen, werden stattdessen zu Laufzeit-Ausnahmen. Weitere Informationen finden Sie unter "Dynamischer Typ".

Siehe auch

  • Last updated on