Tipos nint y nuint (Referencia de C#)

  • Artículo
  • 2 minutos para leer

A partir de C# 9.0, puede usar las palabras clave 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 diferencia de otros tipos numéricos, las palabras clave no son simplemente alias de los tipos. Las instrucciones siguientes son equivalentes:

nint a = 1;
System.IntPtr a = 1;

El compilador proporciona operaciones y conversiones para nint y nuint que son adecuadas para los tipos enteros.

Tamaño de entero nativo en tiempo de ejecución

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.

MinValue y MaxValue

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

Constantes

Puede usar valores constantes en los rangos siguientes:

Conversiones

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.

Literales

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;

Miembros de IntPtr/UIntPtr no admitidos

Los siguientes miembros de IntPtr y UIntPtr no se admiten para los tipos nint y nuint:

Especificación del lenguaje C#

Para obtener más información, vea la especificación del lenguaje C# y la sección Enteros de tamaño nativo de las notas de propuesta de características de C# 9.0.

Vea también