Integral numeriska typer (C#-referens)

De numeriska heltalstyperna representerar heltalsnummer. Alla integrerade numeriska typer är värdetyper. De är också enkla typer och kan initieras med literaler. Alla integrerade numeriska typer stöder aritmetiska, bitvis logiska operatorer, jämförelse- och likhetsoperatorer .

Egenskaper för de integrerade typerna

C# stöder följande fördefinierade integraltyper:

I alla tabellrader utom de två sista är varje C#-typnyckelord från kolumnen längst till vänster ett alias för motsvarande .NET-typ. Nyckelordet och .NET-typnamnet är utbytbara. Följande deklarationer deklarerar till exempel variabler av samma typ:

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

Typerna nint och nuint i de två sista raderna i tabellen är heltal i nativ storlek. Du kan använda de kontextuella nyckelorden nint och nuint för att definiera heltal i inbyggd storlek. Det här är 32-bitars heltal när de körs i en 32-bitarsprocess eller 64-bitars heltal när de körs i en 64-bitarsprocess. De kan användas för interoperabilitetsscenarier, bibliotek på låg nivå och för att optimera prestanda i situationer där heltalsberäkningar används ofta.

De inbyggda heltalstyperna representeras internt som .NET-typerna System.IntPtr och System.UIntPtr. Från och med C# 11 är typerna nint och nuint alias för de underliggande typerna.

Standardvärdet för varje integraltyp är noll, 0.

Var och en av de integrerade typerna har MinValue och MaxValue egenskaper som ger det lägsta och högsta värdet för den typen. Dessa egenskaper är kompileringstidskonstanter förutom för de inbyggda typerna (nint och nuint). Egenskaperna MinValue och MaxValue beräknas vid körning för typer med inbyggd storlek. Storleken på dessa typer beror på processinställningarna.

System.Numerics.BigInteger Använd strukturen för att representera ett signerat heltal utan övre eller nedre gränser.

Heltalsliteraler

Heltalsliteraler kan vara

• decimal: utan prefix
• hexadecimal: med prefixet 0x eller 0X
• binär: med prefixet 0b eller 0B

Följande kod visar ett exempel på var och en:

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

I föregående exempel visas också användningen av _ som en siffraavgränsare. Du kan använda sifferavgränsaren med alla typer av numeriska literaler.

Typen av en heltalsliteral bestäms av dess suffix på följande sätt:

• Om literalen inte har något suffix är dess typ den första av följande typer där dess värde kan representeras: int, uint, long, ulong.

  Anmärkning

  Literaler tolkas som positiva värden. Till exempel representerar literalen 0xFF_FF_FF_FF antalet 4294967295 av uint typen, även om den har samma bitrepresentation som antalet -1 av int typen. Om du behöver ett värde av en viss typ gjuter du en literal till den typen. Använd operatorn unchecked om ett literalvärde inte kan representeras i måltypen. Till unchecked((int)0xFF_FF_FF_FF) exempel genererar -1.

• Om literalen är suffixerad med U eller u, är dess typ den första av följande typer där dess värde kan representeras: uint, ulong.

• Om literalen är suffixerad med L eller l, är dess typ den första av följande typer där dess värde kan representeras: long, ulong.

  Anmärkning

  Du kan använda den gemena bokstaven l som ett suffix. Detta genererar dock en kompilatorvarning eftersom bokstaven l kan förväxlas med siffran 1. Använd L för tydlighetens skull.

• Om literalen har suffixet UL, Ul, uL, ul, LU, Lu, lU eller lu är dess typ ulong.

Om värdet som representeras av en heltalsliteral överskrider UInt64.MaxValueuppstår ett kompilatorfel CS1021 .

Om den fastställda typen av en heltalsliteral är int och värdet som representeras av literalen ligger inom måltypens intervall, kan värdet implicit konverteras till sbyte, byte, short, ushort, uint, ulongeller nintnuint:

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

Som föregående exempel visar uppstår ett kompilatorfel CS0031 om literalvärdet inte ligger inom måltypens intervall.

Du kan också använda en cast för att konvertera värdet som representeras av en heltalsliteral till en annan typ än den bestämda typen av literalen.

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

Omvandlingar

Du kan konvertera valfri numerisk typ av integral till valfri annan numerisk typ. Om måltypen kan lagra alla värden av källtypen är konverteringen implicit. Annars måste du använda ett cast-uttryck för att utföra en explicit konvertering. För mer information, se inbyggda numeriska konverteringar.

Heltal i naturlig storlek

Inbyggda heltalstyper har ett särskilt beteende eftersom lagringen bestäms av den naturliga heltalsstorleken på måldatorn.

• Om du vill få storleken på ett heltal i inbyggd storlek vid körning kan du använda sizeof(). Koden måste dock kompileras i en osäker kontext. Till exempel:

  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
  

  Du kan också hämta motsvarande värde från statiska IntPtr.Size värden och UIntPtr.Size egenskaper.

• Om du vill få minimivärden och maxvärden för helttal anpassade till processorarkutekturen vid körning, använder du MinValue och MaxValue som statiska egenskaper med nyckelorden nint och nuint, som i följande exempel:

  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
  

• Även om hela intervallet av nint och nuint kan vara större, begränsas kompileringstidskonstanter till ett 32-bitarsintervall:

  • För nint: Int32.MinValue till Int32.MaxValue.
  • För nuint: UInt32.MinValue till UInt32.MaxValue.

• Kompilatorn tillhandahåller implicita och explicita konverteringar till andra numeriska typer. För mer information, se inbyggda numeriska konverteringar.

• Det finns ingen direkt syntax för heltal i intern storlek. Det finns inget suffix som anger att en literal är ett heltal i intern storlek, till exempel L för att ange ett long. Du kan använda implicita eller explicita avgjutningar av andra heltalsvärden i stället. Till exempel:

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

Språkspecifikation för C#

Mer information finns i följande avsnitt i C#-språkspecifikationen:

• Heltalstyper
• Heltalsliteraler
• Inbyggda typer av integraler
• C# 11 – Numeriskt IntPtr och UIntPtr

Se även

• Värdetyper
• flyttalstyper
• Standardnumeriska formatsträngar
• numeriska värden i .NET