Tipos numéricos enteros (referencia de C#)

  • Artículo

Los tipos numéricos integrales representan números enteros. Todos los tipos numéricos integrales son tipos de valor. También son tipos simples y se pueden inicializar con literales. Todos los tipos numéricos enteros admiten operadores aritméticos, lógicos bit a bit, de comparación y de igualdad.

Características de los tipos enteros

C# admite los siguientes tipos enteros predefinidos:

Palabra clave/tipo de C# Intervalo Tamaño Tipo de .NET
sbyte De -128 a 127 Entero de 8 bits con signo System.SByte
byte De 0 a 255 Entero de 8 bits sin signo System.Byte
short De -32 768 a 32 767 Entero de 16 bits con signo System.Int16
ushort De 0 a 65.535 Entero de 16 bits sin signo System.UInt16
int De -2.147.483.648 a 2.147.483.647 Entero de 32 bits con signo System.Int32
uint De 0 a 4.294.967.295 Entero de 32 bits sin signo System.UInt32
long De -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 Entero de 64 bits con signo System.Int64
ulong De 0 a 18.446.744.073.709.551.615 Entero de 64 bits sin signo System.UInt64
nint Depende de la plataforma (calculada en tiempo de ejecución) Entero de 64 bits o 32 bits con signo System.IntPtr
nuint Depende de la plataforma (calculada en tiempo de ejecución) Entero de 64 bits o 32 bits sin signo System.UIntPtr

En todas las filas de la tabla, excepto en las dos últimas, cada palabra clave de tipo de C# de la columna situada más a la izquierda es un alias del tipo de .NET correspondiente. La palabra clave y el nombre de tipo de .NET son intercambiables. Por ejemplo, en las declaraciones siguientes se declaran variables del mismo tipo:

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

Los tipos nint y nuint de las dos últimas filas de la tabla son enteros de tamaño nativo. Puede usar las palabras clave contextuales nint y nuint para definir enteros de tamaño nativo. Son enteros de 32 bits cuando se ejecutan en un proceso de 32 bits, o bien enteros de 64 bits cuando se ejecutan en un proceso de 64 bits. Se pueden usar para escenarios de interoperabilidad, bibliotecas de bajo nivel y para optimizar el rendimiento en escenarios en los que se utilice la aritmética de enteros.

Los tipos enteros de tamaño nativo se representan internamente como los tipos System.IntPtr y System.UIntPtr de .NET. A partir de C# 11, los tipos nint y nuint son alias de los tipos subyacentes.

El valor predeterminado de cada tipo entero es cero, 0.

Cada uno de los tipos enteros tiene las constantes MinValue y MaxValue que proporcionan el valor mínimo y máximo de ese tipo. Estas propiedades son constantes en tiempo de compilación, excepto en el caso de los tipos de tamaño nativo (nint y nuint). Las propiedades MinValue y MaxValue se calculan en tiempo de ejecución para los tipos de tamaño nativo. Los tamaños de esos tipos dependen de la configuración del proceso.

Use la estructura System.Numerics.BigInteger para representar un entero con signo sin límite superior ni inferior.

Literales enteros

Los literales enteros pueden ser

  • decimales: sin ningún prefijo
  • hexadecimales: con el prefijo de 0x o 0X
  • binarios: con el prefijo 0b o 0B

En el código siguiente se muestra un ejemplo de cada uno de ellos:

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

En el ejemplo anterior también se muestra el uso de _ como un separador de dígitos. Puede usar el separador de dígitos con todos los tipos de literales numéricos.

El tipo de un literal entero viene determinado por su sufijo, como se indica a continuación:

  • Si el literal no tiene sufijo, su tipo es el primero de los siguientes tipos en el que se puede representar su valor: int, uint, long, ulong.

    Nota

    Los literales se interpretan como valores positivos. Por ejemplo, el literal 0xFF_FF_FF_FF representa el número 4294967295 del tipo uint, aunque tiene la misma representación de bits que el número -1 del tipo int. Si necesita un valor de un tipo determinado, convierta un literal en ese tipo. Use el operador unchecked si un valor literal no se puede representar en el tipo de destino. Por ejemplo, unchecked((int)0xFF_FF_FF_FF) genera -1.

  • Si un literal entero tiene el sufijo U o u, su tipo es el primero de los siguientes tipos en el que se puede representar su valor: uint, ulong.

  • Si un literal entero tiene el sufijo L o l, su tipo es el primero de los siguientes tipos en el que se puede representar su valor: long, ulong.

    Nota

    Puede usar la letra minúscula l como sufijo. Sin embargo, esto genera una advertencia del compilador porque la letra l se confunde fácilmente con el dígito 1. Use L para mayor claridad.

  • Si el literal tiene como sufijo UL, Ul, uL, ul, LU, Lu, lU o lu, su tipo es ulong.

Si el valor que representa un literal entero supera UInt64.MaxValue, se produce un error de compilación CS1021.

Si el tipo determinado de un literal entero es int y el valor que representa el literal está dentro del rango del tipo de destino, el valor se puede convertir de forma implícita en sbyte, byte, short, ushort, uint, ulong, nint o nuint:

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

Como se muestra en el ejemplo anterior, si el valor del literal no está dentro del intervalo del tipo de destino, se produce el error CS0031 del compilador.

También puede usar una conversión para convertir el valor representado por un literal entero en un tipo que no sea el determinado del literal:

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

Conversiones

Puede convertir un tipo numérico entero en cualquier otro tipo numérico entero. Si el tipo de destino puede almacenar todos los valores del tipo de origen, la conversión es implícita. De lo contrario, debe usar una expresión Cast para realizar una conversión explícita. Para obtener más información, consulte Conversiones numéricas integradas.

Enteros con tamaño nativos

Los tipos enteros de tamaño nativo tienen un comportamiento especial porque el almacenamiento viene determinado por el tamaño natural del entero en la máquina de destino.

  • Para obtener el tamaño de un entero de tamaño nativo en tiempo de ejecución, puede usar sizeof(). Pero el código se debe compilar en un contexto no seguro. Por ejemplo:

    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

    También puede obtener el valor equivalente de las propiedades estáticas IntPtr.Size y UIntPtr.Size.

  • Para obtener los valores mínimo y máximo de los enteros de tamaño nativo en tiempo de ejecución, use MinValue y MaxValue como propiedades estáticas con las palabras clave nint y nuint, como en el ejemplo siguiente:

    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

  • Puede usar valores constantes en los rangos siguientes:

  • El compilador proporciona conversiones implícitas y explícitas a otros tipos numéricos. Para obtener más información, consulte Conversiones numéricas integradas.

  • No hay ninguna sintaxis directa para los literales de entero de tamaño nativo. No hay ningún sufijo para indicar que un literal es un entero de tamaño nativo, como L para indicar long. En su lugar, puede usar conversiones implícitas o explícitas de otros valores enteros. Por ejemplo:

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

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

Vea también