Compartir a través de

Tipos y literales predefinidos

Sugerencia

¿No está familiarizado con el desarrollo de software? Comience primero con los tutoriales de introducción . Introducen tipos a medida que escribes tus primeros programas.

¿Competente en otro idioma? Los tipos integrados de C# se asignan estrechamente a los tipos de Java, C++y otros lenguajes. Revise la sintaxis literal y inferencia de tipos para detalles específicos de C#.

C# proporciona un conjunto de tipos integrados que puede usar en cualquier programa sin referencias adicionales. Estos tipos cubren los datos más comunes con los que se trabaja: números, valores true/false, caracteres individuales y texto. Para obtener una tabla de referencia completa que asigne las palabras clave de C# a los tipos de .NET, consulte Tipos integrados (referencia de C#).

Tipos numéricos

C# tiene tipos integrados para enteros, números de punto flotante y números decimales. Los tipos más usados son int, doubley decimal:

int population = 67_000_000;
long distance = 384_400_000L;
short temperature = -40;
byte red = 255;

double pi = 3.141592653589793;
float gravity = 9.81f;
decimal price = 19.99m;

Cada tipo numérico tiene un tamaño fijo y un intervalo. int almacena enteros de 32 bits (aproximadamente ±2,100 millones), long almacena enteros de 64 bits y shortbyte almacena valores más pequeños. Para obtener la lista completa de tamaños y rangos, vea Tipos numéricos enteros y tipos numéricos de punto flotante.

Se usa double para matemáticas generales de punto flotante, float cuando se restringe la memoria y decimal cuando se necesita precisión decimal exacta (como cálculos financieros). Anexe el sufijo f para los literales float y m para los literales decimal. Sin un sufijo, el compilador trata un número con punto decimal como double.

Tipos sin signo

Cada tipo entero con signo tiene un homólogo sin signo que almacena solo valores no negativos con dos veces el intervalo positivo:

uint fileSize = 4_294_967_295;
ulong totalBytes = 18_446_744_073_709_551_615;
ushort port = 443;

Puede usar tipos sin firmar cuando los valores negativos no son válidos para los datos, como tamaños de archivo o puertos de red. En la práctica, muchas aplicaciones usan int o long incluso para valores de solo positivos porque los tipos firmados son los predeterminados en todas las API de .NET.

Enteros de tamaño nativo

Los nint tipos y nuint representan enteros cuyo tamaño coincide con el tamaño del puntero nativo de la plataforma: 32 bits en una plataforma de 32 bits, 64 bits en una plataforma de 64 bits:

nint bufferSize = 1024;
nuint elementCount = 256;

Es poco probable que necesite nint o nuint en el código diario. Existen para escenarios de interoperabilidad y operaciones de memoria de bajo nivel en las que es importante ajustarse al tamaño del puntero de la plataforma. Siga usando int o long a menos que tenga una razón específica para usar tipos de tamaño nativo. Para obtener más información, vea nint y nuint.

bool, char y string

Más allá de los números, C# proporciona otros tres tipos integrados usados con frecuencia:

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Almacena true o false. Úselo en condiciones, bucles y expresiones lógicas.
  • char : almacena un único carácter Unicode (unidad de código UTF-16), entre comillas simples.
  • string — Almacena una secuencia de caracteres, entre comillas dobles. Las cadenas son inmutables. Una vez creada una cadena, no se puede cambiar su contenido. Las operaciones que parecen modificar una cadena crean realmente una nueva.

Las cadenas son uno de los tipos más usados en C#. Para obtener una cobertura detallada de las operaciones de cadena, incluida la interpolación, los literales de cadena sin procesar, la búsqueda, la división y la comparación, consulte la sección Cadenas .

Sintaxis literal

Un literal es un valor que se escribe directamente en el código. El compilador asigna cada literal un tipo en función de su formato y cualquier sufijo que proporcione. C# admite los siguientes tipos de literales:

  • Literales enteros : decimal (42), hexadecimal (0x2A) y binario (0b_0010_1010).
  • Literales de punto flotante : double de forma predeterminada (3.14), float con el f sufijo (3.14f) y decimal con m (3.14m).
  • Literales de caracteres — un solo carácter entre comillas simples ('A'), incluidas las secuencias de escape ('\n').
  • Literales de cadena : regular ("hello"), verbatim (@"C:\path"), en bruto (""" ... """) e interpolado ($"value: {x}").
  • Literales booleanos : true y false.
  • El literal null — representa la ausencia de un valor para los tipos de referencia y los tipos de valor que aceptan valores nulos.
  • El literal default — genera el valor predeterminado para cualquier tipo (cubierto en default expresiones).

En las secciones siguientes se tratan los formularios literales más comunes en detalle.

Literales enteros

int dec = 42;
int hex = 0x2A;
int bin = 0b_0010_1010;
long big = 1_000_000_000L;

Use el 0x prefijo para hexadecimal y 0b para binary. Anexe L para long, U para uinto UL para ulong.

Coloque el _ separador de dígitos en cualquier parte de un número para facilitar la lectura. Los patrones comunes incluyen separadores de miles en literales decimales (1_000_000_000), límites de bytes o palabras en hexadecimales (0xFF_FF) y límites de nibble en binario (0b_0010_1010).

Literales de punto flotante

double d = 3.14;
float f = 3.14f;
decimal m = 3.14m;
double scientific = 1.5e6; // 1,500,000

Sin un sufijo, un literal numérico con un punto decimal es double. Anexe f para float y m para decimal. También se admite la notación científica (1.5e6).

Literales de caracteres y cadenas

char newline = '\n';
char unicode = '\u0041'; // 'A'

string message = $"Found {dec} items";            // interpolated string
string path = @"C:\Users\docs\file.txt";        // verbatim string
string json = """
    { "name": "Alice", "age": 30 }
    """;                                           // raw string literal
string raw = $"""
    Found {dec} items in "{greeting}"
    """;                                           // raw + interpolated

Los literales de caracteres usan comillas simples y admiten secuencias de escape (\n, \t, \u). Los literales de cadena usan comillas dobles.

Prefijar cadenas con $ para interpolación. Cuando una cadena contiene comillas, barras diagonales inversas o JSON incrustadas o XML, use un literal de cadena sin formato (delimitado por """) en lugar de escapar de cada carácter. Los literales de cadena sin formato también se combinan con interpolación ($""").

El código anterior usa @ (cadenas textuales) para evitar el procesamiento de escape. Los literales de cadena sin formato son más fáciles de leer y escribir, así que prefieran usarlos para el nuevo código.

default expresiones

La default expresión genera el valor predeterminado de un tipo: 0 para los tipos numéricos, false para booly null para los tipos de referencia:

int defaultInt = default;          // 0
bool defaultBool = default;        // false
string? defaultString = default;   // null

// Use default in a conditional:
var limit = (args.Length > 0) ? int.Parse(args[0]) : default(int);

La default expresión es más útil en el código genérico, donde no conoce el tipo concreto y no puede codificar de forma rígida un valor específico como 0 o null. Escriba default (sin un argumento de tipo) cuando el compilador pueda deducir el tipo del contexto o default(T) cuando el tipo no sea obvio. Para obtener la lista completa de valores predeterminados por tipo, vea Valores predeterminados de tipos de C#.

Variables tipadas implícitamente con var

La var palabra clave indica al compilador que infiera el tipo de una variable local a partir de su inicializador:

var count = 10;              // compiler infers int
var name = "C#";             // compiler infers string
var items = new List<int>(); // compiler infers List<int>

// var requires an initializer — the compiler needs a value to infer the type.
// The following line wouldn't compile:
// var unknown;

La variable sigue siendo fuertemente tipada; var no lo hace dinámico. El compilador determina el tipo en tiempo de compilación y aplica la seguridad de tipos como de costumbre. Use var cuando el tipo sea obvio del lado derecho para reducir el ruido visual. Haga explícito el tipo cuando esto aclare el código. Para obtener más información, consulte Variables locales con tipo implícito.

Expresiones con tipo de destino new

Cuando ya conoce el tipo de destino del contexto, como una declaración de variable o un parámetro de método, puede omitir el nombre de tipo de la new expresión:

List<string> names = new() { "Alice", "Bob", "Charlie" };
Dictionary<string, int> scores = new()
{
    ["Alice"] = 95,
    ["Bob"] = 87
};

El tipo new de destino reduce la repetición cuando el nombre del tipo es largo o aparece en el lado izquierdo de la asignación. Funciona en cualquier lugar donde el compilador pueda determinar el tipo de destino, incluidos los argumentos de método y las instrucciones return. Para obtener más información, consulte new operador — tipo orientado a new.

El tipo dynamic

El dynamic tipo omite la comprobación de tipos en tiempo de compilación. El compilador resuelve las operaciones en una dynamic variable en tiempo de ejecución en su lugar:

dynamic value = 42;
Console.WriteLine(value.GetType()); // System.Int32

value = "Now I'm a string";
Console.WriteLine(value.GetType()); // System.String

// The compiler doesn't check operations on dynamic at compile time.
// Errors surface at run time instead.

Use dynamic al interactuar con las API COM, los lenguajes dinámicos o los escenarios con mucha reflexión en los que los tipos no se conocen en tiempo de compilación. Evite dynamic en la mayoría del código de aplicación porque pierde la seguridad en tiempo de compilación. En su lugar, los errores que detecta el compilador se convierten en excepciones en tiempo de ejecución. Para obtener más información, vea El tipo dinámico.

Consulte también

  • Last updated on