Freigeben über

Integrale numerische Typen (C#-Referenz)

Die integralen numerischen Typen stellen ganze Zahlen dar. Alle integralen numerischen Typen sind Werttypen. Die integralen Typen sind einfache Typen , und Sie initialisieren sie mit Literalen. Alle integralen numerischen Typen unterstützen arithmetische, bitweise logische, Vergleichs- und Gleichheitsoperatoren .

Die C#-Sprachreferenz dokumentiert die zuletzt veröffentlichte Version der C#-Sprache. Außerdem enthält sie erste Dokumentation für Features in der öffentlichen Vorschau für die kommende Sprachversion.

In der Dokumentation werden alle Features identifiziert, die in den letzten drei Versionen der Sprache oder in der aktuellen öffentlichen Vorschau eingeführt wurden.

Tipp

Informationen dazu, wann ein Feature erstmals in C# eingeführt wurde, finden Sie im Artikel zum Versionsverlauf der C#-Sprache.

Merkmale der integralen Typen

C# unterstützt die folgenden vordefinierten Integraltypen:

C#-Typ/Schlüsselwort Range Größe .NET-Typ
sbyte -128 bis 127 Signierte 8-Bit-Ganzzahl System.SByte
byte 0 bis 255 Nicht signierte 8-Bit-Ganzzahl System.Byte
short -32.768 bis 32.767 Signierte 16-Bit-Ganzzahl System.Int16
ushort 0 bis 65.535 Nicht signierte 16-Bit-Ganzzahl System.UInt16
int -2.147.483.648 bis 2.147.483.647 32-Bit-Ganzzahl System.Int32
uint 0 bis 4.294.967.295 Nicht signierte 32-Bit-Ganzzahl System.UInt32
long -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 64-Bit-Ganzzahl System.Int64
ulong 0 bis 18.446.744.073.709.551.615 Nicht signierte 64-Bit-Ganzzahl System.UInt64
nint Hängt von der Plattform ab (zur Laufzeit berechnet) Signierte 32-Bit- oder 64-Bit-Ganzzahl System.IntPtr
nuint Hängt von der Plattform ab (zur Laufzeit berechnet) Nicht signierte 32-Bit- oder 64-Bit-Ganzzahl System.UIntPtr

In allen Tabellenzeilen mit Ausnahme der letzten beiden Zeilen ist jedes C#-Typ-Schlüsselwort aus der spalte ganz links ein Alias für den entsprechenden .NET-Typ. Das Schlüsselwort und der .NET-Typname sind austauschbar. Die folgenden Deklarationen deklarieren beispielsweise Variablen desselben Typs:

int a = 123;
System.Int32 b = 123;

Die nint- und nuint-Typen in den letzten beiden Zeilen der Tabelle sind Integerwerte mit nativer Größe. Sie können die nint und nuint kontextbezogenen Schlüsselwörter verwenden, um Ganzzahlen nativer Größe zu definieren. Ganzzahlen in systemeigener Größe sind 32-Bit-Ganzzahlen, wenn sie in einem 32-Bit-Prozess ausgeführt werden, oder 64-Bit-Ganzzahlen, wenn sie in einem 64-Bit-Prozess ausgeführt werden. Verwenden Sie sie für Interoperabilitätsszenarien, Bibliotheken auf niedriger Ebene und optimieren Sie die Leistung in Szenarien, in denen ganzzahlige Mathematik umfassend verwendet wird.

Die ganzzahligen Typen der nativen Größe werden intern als .NET-Typen System.IntPtr und System.UIntPtr dargestellt. Die nint Typen nuint sind Aliase für die zugrunde liegenden Typen.

Der Standardwert jedes integralen Typs ist Null, 0.

Jeder der integralen Typen hat die Eigenschaften MinValue und MaxValue, die den minimalen und maximalen Wert dieses Typs bereitstellen. Diese Eigenschaften sind Kompilierzeit-Konstanten, mit Ausnahme der Typen nativer Größe (nint und nuint). Die Eigenschaften MinValue und MaxValue werden zur Laufzeit für Typen mit nativer Größe berechnet. Die Größen dieser Typen hängen von den Prozesseinstellungen ab.

Verwenden Sie die System.Numerics.BigInteger Struktur, um eine signierte ganze Zahl ohne obere oder untere Grenzen darzustellen.

Ganzzahlenliteral

Ganzzahlige Literale können sein:

  • Dezimalzahl: ohne Präfix
  • de-DE: hexadezimal: mit dem 0x oder 0X Präfix
  • binär: mit dem 0b oder 0B Präfix

Der folgende Code veranschaulicht ein Beispiel für jede:

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

Das vorangehende Beispiel zeigt auch die Verwendung von _ als Zifferntrennzeichen. Sie können das Zifferntrennzeichen mit allen Arten numerischer Literale verwenden.

Das Suffix bestimmt den Typ eines ganzzahligen Literals wie folgt:

  • Wenn das Literal kein Suffix aufweist, weist der Compiler den Typ als erster der folgenden Typen zu, in denen sein Wert dargestellt werden kann: int, , , longuintulong.

    Hinweis

    Der Compiler interpretiert Literale als positive Werte. Beispielsweise stellt das Literal 0xFF_FF_FF_FF die Nummer 4,294,967,295 des uint Typs dar, obwohl es dieselbe Bitdarstellung wie die Nummer -1 des int Typs aufweist. Wenn Sie einen Wert eines bestimmten Typs benötigen, können Sie ein Literal in diesen Typ umwandeln. Verwenden Sie den unchecked Operator, wenn kein Literalwert im Zieltyp dargestellt werden kann. Beispielsweise erzeugt unchecked((int)0xFF_FF_FF_FF) den Wert -1.

  • Wenn das Literal das Uu Oder-Suffix enthält, weist der Compiler den Typ als ersten der folgenden Typen zu, in denen sein Wert dargestellt werden kann: uint, ulong.

  • Wenn das Literal das Ll Oder-Suffix enthält, weist der Compiler den Typ als ersten der folgenden Typen zu, in denen sein Wert dargestellt werden kann: long, ulong.

    Hinweis

    Sie können den Kleinbuchstaben l als Suffix verwenden. Generiert jedoch eine Compilerwarnung, l da der Buchstabe l mit der Ziffer 1verwechselt werden kann. Verwenden Sie L um Übersichtlichkeit zu erreichen.

  • Wenn das Literal eines der : , Ul, , uL, ul, LULu, , lU, oder lu Suffixe enthält, weist der Compiler den Typ als ulong.UL

Wenn der durch ein ganzzahliges Literal dargestellte Wert überschritten wird UInt64.MaxValue, tritt ein Compilerfehler CS1021 auf.

Wenn der Compiler den Typ eines ganzzahligen Literals bestimmt int und der durch das Literal dargestellte Wert innerhalb des Bereichs des Zieltyps liegt, kann der Wert implizit sbytein , , byte, , uintushortulongshort, , oder :nuintnint

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

Wie im vorherigen Beispiel gezeigt, tritt ein Compilerfehler CS0031 auf, wenn der Literalwert nicht innerhalb des Zieltyps liegt.

Sie können auch eine Umwandlung verwenden, um den Wert, der durch ein Ganzzahlliteral dargestellt wird, in einen anderen Typ als den festgelegten Literaltyp zu konvertieren:

var signedByte = (sbyte)42;
var longVariable = (long)42;

Konvertierungen

Sie können einen beliebigen integralen numerischen Typ in einen anderen integralen numerischen Typ konvertieren. Wenn der Zieltyp alle Werte des Quelltyps speichern kann, ist die Konvertierung implizit. Verwenden Sie andernfalls einen Umwandlungsausdruck , um eine explizite Konvertierung auszuführen. Weitere Informationen finden Sie unter den integrierten numerischen Konvertierungen.

Integerwerte mit nativer Größe

Systemeigene ganzzahlige Typen weisen ein spezielles Verhalten auf, da der Speicher mit der natürlichen ganzzahligen Größe auf dem Zielcomputer übereinstimmt.

  • Um die Größe einer systemeigenen ganzzahligen Zahl zur Laufzeit abzurufen, verwenden Sie sizeof(). Der Code muss jedoch in einem unsicheren Kontext kompiliert werden. Beispiel:

    Console.WriteLine($"size of nint = {sizeof(nint)}");
Console.WriteLine($"size of nuint = {sizeof(nuint)}");

// output when run in a 64-bit process
//size of nint = 8
//size of nuint = 8

// output when run in a 32-bit process
//size of nint = 4
//size of nuint = 4

    Sie können auch den entsprechenden Wert aus den statischen IntPtr.Size und UIntPtr.Size Eigenschaften abrufen.

  • Um die Mindest- und Höchstwerte von Integer-Zahlen während der Laufzeit zu ermitteln, verwenden Sie MinValue und MaxValue als statische Eigenschaften mit den Schlüsselwörtern nint und nuint, wie im folgenden Beispiel gezeigt:

    Console.WriteLine($"nint.MinValue = {nint.MinValue}");
Console.WriteLine($"nint.MaxValue = {nint.MaxValue}");
Console.WriteLine($"nuint.MinValue = {nuint.MinValue}");
Console.WriteLine($"nuint.MaxValue = {nuint.MaxValue}");

// output when run in a 64-bit process
//nint.MinValue = -9223372036854775808
//nint.MaxValue = 9223372036854775807
//nuint.MinValue = 0
//nuint.MaxValue = 18446744073709551615

// output when run in a 32-bit process
//nint.MinValue = -2147483648
//nint.MaxValue = 2147483647
//nuint.MinValue = 0
//nuint.MaxValue = 4294967295

  • Während der gesamte Bereich von nint und nuint kann größer sein, sind Kompilierungszeitkonstanten auf einen 32-Bit-Bereich beschränkt:

  • Der Compiler stellt implizite und explizite Konvertierungen in andere numerische Typen bereit. Weitere Informationen finden Sie unter den integrierten numerischen Konvertierungen.

  • Es gibt keine direkte Syntax für Integer-Literale in nativer Größe. Es gibt kein Suffix, das angibt, dass es sich bei einem Literal um einen Integerwert mit nativer Größe handelt (wie L, um long anzugeben). Verwenden Sie stattdessen implizite oder explizite Umwandlungen anderer ganzzahliger Werte. Beispiel:

    nint a = 42
nint a = (nint)42;

C#-Sprachspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:

Siehe auch

  • Last updated on