Integrale numerische Typen (C#-Referenz)

  • Artikel

Die integralen numerischen Typen stellen ganze Zahlen dar. Alle integralen numerischen Typen sind Werttypen. Sie sind auch einfache Typen und können mit Literalen initialisiert werden. Alle integralen numerischen Typen unterstützen arithmetic-, bitwise logical-, comparison- and equality-Operatoren.

Merkmale der integralen Typen

C# unterstützt die folgenden vordefinierten integralen Typen:

C#-Typ/Schlüsselwort Bereich Größe .NET-Typ
sbyte –128 bis 127 Ganze 8-Bit-Zahl mit Vorzeichen System.SByte
byte 0 bis 255 8-Bit-Ganzzahl ohne Vorzeichen System.Byte
short –32.768 bis 32.767 Ganze 16-Bit-Zahl mit Vorzeichen System.Int16
ushort 0 bis 65.535 16-Bit-Ganzzahl ohne Vorzeichen System.UInt16
int -2,147,483,648 bis 2,147,483,647 Eine 32-Bit-Ganzzahl mit Vorzeichen System.Int32
uint 0 bis 4.294.967.295 32-Bit Ganzzahl ohne Vorzeichen System.UInt32
long -9,223,372,036,854,775,808 bis 9,223,372,036,854,775,807 64-Bit-Ganzzahl mit Vorzeichen System.Int64
ulong 0 bis 18.446.744.073.709.551.615 64-Bit-Ganzzahl ohne Vorzeichen System.UInt64
nint Abhängig von der Plattform (zur Laufzeit berechnet) 32-Bit- oder 64-Bit-Integerwerte mit Vorzeichen System.IntPtr
nuint Abhängig von der Plattform (zur Laufzeit berechnet) 32-Bit- oder 64-Bit-Integerwerte ohne Vorzeichen System.UIntPtr

In allen Tabellenzeilen mit Ausnahme der letzten beiden ist jedes Schlüsselwort des C#-Typs aus der Spalte ganz links ein Alias für den entsprechenden .NET-Typ. Das Schlüsselwort und der .NET-Typname sind austauschbar. In den folgenden Deklarationen werden beispielsweise Variablen des gleichen Typs deklariert:

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. Ab C# 9.0 können Sie die Schlüsselwörter nint und nuint verwenden, um Integerwerte in nativer Größe zu definieren. Dabei handelt es sich um 32-Bit-Integerwerte bei Ausführung in einem 32-Bit-Prozess oder um 64-Bit-Integerwerte bei Ausführung in einem 64-Bit-Prozess. Sie können für Interop-Szenarien, Low-Level-Bibliotheken und zur Optimierung der Leistung in Szenarien verwendet werden, in denen Integermathematik ausgiebig genutzt wird.

Die Integertypen mit nativer Größe werden intern als die .NET-Typen System.IntPtr und System.UIntPtr dargestellt. Ab C# 11 sind die Typen nint und nuint Aliase für die zugrunde liegenden Typen.

Der Standardwert jedes integralen Typs ist Null (0).

Die einzelnen integralen Typen verfügen jeweils über die Eigenschaften MinValue und MaxValue, die den minimalen und maximalen Wert des Typs angeben. Bei diesen Eigenschaften handelt es sich um Kompilierzeitkonstanten mit Ausnahme der Typen mit 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 ganze Zahl mit Vorzeichen ohne obere oder untere Grenzen darzustellen.

Ganzzahlenliteral

Ganzzahlenliterale können die folgenden Typen aufweisen:

  • Dezimal : ohne Präfix
  • Hexadezimal: mit dem Präfix 0x oder 0X
  • binär: mit dem Präfix 0b oder 0B

Der folgende Code zeigt ein Beispiel für jeden Typ:

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

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

Der Typ eines integralen Literals wird wie folgt durch sein Suffix bestimmt:

  • Wenn das Literal kein Suffix besitzt, ist sein Typ der erste dieser Typen, in dem sein Wert dargestellt werden kann: int, uint, long, ulong.

    Hinweis

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

  • Wenn das Literal das Suffix U oder u aufweist, ist sein Typ der erste dieser Typen, in dem sein Wert dargestellt werden kann: uint, ulong.

  • Wenn das Literal das Suffix L oder l aufweist, ist sein Typ der erste dieser Typen, in dem sein Wert dargestellt werden kann: long, ulong.

    Hinweis

    Sie können den Kleinbuchstaben l als Suffix verwenden. Allerdings erzeugt dies eine Compilerwarnung, weil der Buchstabe l leicht mit der Zahl 1 verwechselt werden kann. Verwenden Sie aus Gründen der Klarheit L.

  • Wenn das Literal das Suffix UL, Ul, uL, ul, LU, Lu, lU oder lu aufweist, ist sein Typ ulong.

Wenn der von einem Integer-Literal dargestellte Wert UInt64.MaxValue überschreitet, tritt der Compilerfehler CS1021 auf.

Wenn der festgelegte Typ eines Integerliterals int lautet, und der vom Literal dargestellte Wert innerhalb des Bereichs des Zieltyps liegt, kann der Wert implizit in sbyte, byte, short, ushort, uint, ulong, nint oder nuint konvertiert werden:

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

Wie das vorherige Beispiel zeigt, tritt der Compilerfehler CS0031 auf, wenn der Wert des Literals nicht innerhalb des Bereichs 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 beliebige ganzzahlige numerische Typen in beliebige andere ganzzahlige numerische Typen konvertieren. Wenn der Zieltyp alle Werte des Quelltyps speichern kann, handelt es sich um eine implizite Konvertierung. Andernfalls müssen Sie einen Cast-Ausdruck verwenden, um eine explizite Konvertierung durchzuführen. Weitere Informationen finden Sie unter Integrierte numerische Konvertierungen (C#-Referenz) (Integrierte numerische Konvertierungen).

Integerwerte mit nativer Größe

Ganzzahltypen mit nativer Größe weisen ein besonderes Verhalten auf, da der Speicher von der natürlichen Ganzzahlgröße auf dem Zielcomputer bestimmt wird.

  • Um die Größe eines Integerwerts mit nativer Größe zur Laufzeit abzurufen, können Sie sizeof() verwenden. 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 den entsprechenden Wert auch aus den statischen Eigenschaften IntPtr.Size und UIntPtr.Size abrufen.

  • Um die Mindest- und Höchstwerte von Integerwerten mit nativer Größe zur Laufzeit abzurufen, 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

  • Sie können konstante Werte in den folgenden Bereichen verwenden:

  • Der Compiler stellt implizite und explizite Konvertierungen in andere numerische Typen bereit. Weitere Informationen finden Sie unter Integrierte numerische Konvertierungen (C#-Referenz) (Integrierte numerische Konvertierungen).

  • Es gibt keine direkte Syntax für Integerliterale mit 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). Sie können stattdessen implizite oder explizite Umwandlungen von anderen Integerwerten verwenden. Beispiel:

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

C#-Sprachspezifikation

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

Siehe auch