Instrucciones (Guía de programación de

C#)
 Artículo
 21/07/2022
 Tiempo de lectura: 6 minutos
 13 colaboradores

Las acciones que realiza un programa se expresan en instrucciones. Entre las acciones
comunes se incluyen declarar variables, asignar valores, llamar a métodos, recorrer
colecciones en bucle y crear una bifurcación a uno u otro bloque de código, en función de
una condición determinada. El orden en el que se ejecutan las instrucciones en un programa
se denomina flujo de control o flujo de ejecución. El flujo de control puede variar cada vez
que se ejecuta un programa, en función de cómo reacciona el programa a la entrada que
recibe en tiempo de ejecución.

Una instrucción puede constar de una sola línea de código que finaliza en un punto y coma
o de una serie de instrucciones de una sola línea en un bloque. Un bloque de instrucciones
se incluye entre llaves {} y puede contener bloques anidados. En el código siguiente se
muestran dos ejemplos de instrucciones de una sola línea y un bloque de instrucciones de
varias líneas:

C#Copiar
static void Main()
{
// Declaration statement.
int counter;

// Assignment statement.
counter = 1;

// Error! This is an expression, not an expression statement.

// counter + 1;

// Declaration statements with initializers are functionally

// equivalent to declaration statement followed by assignment
statement:
int[] radii = { 15, 32, 108, 74, 9 }; // Declare and initialize an
array.
const double pi = 3.14159; // Declare and initialize constant.

// foreach statement block that contains multiple statements.

foreach (int radius in radii)
{
// Declaration statement with initializer.
double circumference = pi * (2 * radius);

// Expression statement (method invocation). A single-line

// statement can span multiple text lines because line breaks
// are treated as white space, which is ignored by the compiler.
 System.Console.WriteLine("Radius of circle #{0} is {1}.
Circumference = {2:N2}",
counter, radius, circumference);

// Expression statement (postfix increment).

counter++;
} // End of foreach statement block
} // End of Main method body.
} // End of SimpleStatements class.
/*
Output:
Radius of circle #1 = 15. Circumference = 94.25
Radius of circle #2 = 32. Circumference = 201.06
Radius of circle #3 = 108. Circumference = 678.58
Radius of circle #4 = 74. Circumference = 464.96
Radius of circle #5 = 9. Circumference = 56.55
*/

Tipos de instrucciones
En la tabla siguiente se muestran los distintos tipos de instrucciones de C# y sus palabras
clave asociadas, con vínculos a temas que incluyen más información:

Categoría Palabras clave de C# / notas

Instrucciones de Una instrucción de declaración introduce una variable o constante nueva.
declaración Una declaración de variable puede asignar opcionalmente un valor a la
variable. En una declaración de constante, se requiere la asignación.
Instrucciones de Las instrucciones de expresión que calculan un valor deben almacenar el
expresión valor en una variable.
Instrucciones de Las instrucciones de selección permiten crear bifurcaciones a diferentes
selección secciones de código, en función de una o varias condiciones especificadas.
Para obtener más información, vea los temas siguientes:
 if
 switch
Instrucciones de Las instrucciones de iteración permiten recorrer en bucle colecciones, como
iteración matrices, o realizar el mismo conjunto de instrucciones repetidas veces hasta
que se cumpla una condición especificada. Para obtener más información,
vea los temas siguientes:
 do
 for
 foreach
 while
Instrucciones de Las instrucciones de salto transfieren el control a otra sección de código.
salto Para obtener más información, vea los temas siguientes:
 break
 continue
 goto
 return
Categoría Palabras clave de C# / notas
 yield
Instrucciones para el Las instrucciones para el control de excepciones permiten recuperarse
control de correctamente de condiciones excepcionales producidas en tiempo de
excepciones ejecución. Para obtener más información, vea los temas siguientes:
 throw
 try-catch
 try-finally
 try-catch-finally
Checked y Las instrucciones checked y unchecked permiten especificar si las
unchecked operaciones numéricas pueden producir un desbordamiento cuando el
resultado se almacena en una variable que es demasiado pequeña para
contener el valor resultante. Para obtener más información,
vea checked y unchecked.
Instrucción await Si marca un método con el modificador async , puede usar el
operador await en el método. Cuando el control alcanza una
expresión await en el método asincrónico, el control se devuelve al autor de
llamada y el progreso del método se suspende hasta que se completa la tarea
esperada. Cuando se completa la tarea, la ejecución puede reanudarse en el
método.

Para obtener un ejemplo sencillo, vea la sección "Métodos asincrónicos"

de Métodos. Para obtener más información, vea Programación asincrónica
con Async y Await.
Instrucción yield Un iterador realiza una iteración personalizada en una colección, como una
return lista o matriz. Un iterador utiliza la instrucción yield return para devolver
cada elemento de uno en uno. Cuando se alcanza una instrucción yield
return, se recuerda la ubicación actual en el código. La ejecución se reinicia
desde esa ubicación la próxima vez que se llama el iterador.

Para obtener más información, consulta Iteradores.

Instrucción fixed La instrucción fixed impide que el recolector de elementos no utilizados
cambie la ubicación de una variable móvil. Para obtener más información,
vea fixed.
Instrucción lock La instrucción lock permite limitar el acceso a bloques de código a un solo
subproceso de cada vez. Para obtener más información, vea lock.
Instrucciones con Puede asignar una etiqueta a una instrucción y, después, usar la palabra
etiqueta clave goto para saltar a la instrucción con etiqueta. (Vea el ejemplo de la
línea siguiente).
Instrucción vacía La instrucción vacía consta únicamente de un punto y coma. No hace nada y
se puede usar en lugares en los que se requiere una instrucción, pero no es
necesario realizar ninguna acción.

Instrucciones de declaración
En el código siguiente se muestran ejemplos de declaraciones de variables con y sin una
asignación inicial, y una declaración constante con la inicialización necesaria.

C#Copiar
// Variable declaration statements.
double area;
double radius = 2;

// Constant declaration statement.

const double pi = 3.14159;

Instrucciones de expresión
En el código siguiente se muestran ejemplos de instrucciones de expresión, que incluyen la
asignación, la creación de objetos con asignación y la invocación de método.

C#Copiar
// Expression statement (assignment).
area = 3.14 * (radius * radius);

// Error. Not statement because no assignment:

//circ * 2;

// Expression statement (method invocation).

System.Console.WriteLine();

// Expression statement (new object creation).

System.Collections.Generic.List<string> strings =
new System.Collections.Generic.List<string>();

Instrucción vacía
En los ejemplos siguientes se muestran dos usos de una instrucción vacía:

C#Copiar
void ProcessMessages()
{
while (ProcessMessage())
; // Statement needed here.
}

void F()
{
//...
if (done) goto exit;
//...
exit:
; // Statement needed here.
}
Instrucciones insertadas
Algunas instrucciones, por ejemplo, las instrucciones de iteración, siempre van seguidas de
una instrucción insertada. Esta instrucción insertada puede ser una sola instrucción o varias
instrucciones incluidas entre llaves {} en un bloque de instrucciones. Las instrucciones
insertadas de una sola línea también pueden ir entre llaves {}, como se muestra en el
siguiente ejemplo:

C#Copiar
// Recommended style. Embedded statement in block.
foreach (string s in System.IO.Directory.GetDirectories(
System.Environment.CurrentDirectory))
{
System.Console.WriteLine(s);
}

// Not recommended.
foreach (string s in System.IO.Directory.GetDirectories(
System.Environment.CurrentDirectory))
System.Console.WriteLine(s);

Una instrucción insertada que no está incluida entre llaves {} no puede ser una instrucción
de declaración o una instrucción con etiqueta. Esto se muestra en el ejemplo siguiente:

C#Copiar
if(pointB == true)
//Error CS1023:
int radius = 5;

Coloque la instrucción insertada en un bloque para solucionar el error:

C#Copiar
if (b == true)
{
// OK:
System.DateTime d = System.DateTime.Now;
System.Console.WriteLine(d.ToLongDateString());
}

Bloques de instrucciones anidadas

Los bloques de instrucciones pueden anidarse, como se muestra en el código siguiente:

C#Copiar
foreach (string s in System.IO.Directory.GetDirectories(
System.Environment.CurrentDirectory))
{
if (s.StartsWith("CSharp"))
{
 if (s.EndsWith("TempFolder"))
{
return s;
}
}
}
return "Not found.";

Instrucciones inaccesibles
Si el compilador determina que el flujo de control no puede alcanzar nunca una instrucción
determinada bajo ninguna circunstancia, producirá una advertencia CS0162, como se
muestra en el ejemplo siguiente:

C#Copiar
// An over-simplified example of unreachable code.
const int val = 5;
if (val < 4)
{
System.Console.WriteLine("I'll never write anything."); //CS0162
}

Especificación del lenguaje C#

Para más información, vea la sección Instrucciones de la especificación del lenguaje C#.

Consulte también
 Guía de programación de C#
 Palabras clave de instrucciones
 Operadores y expresiones de C#

Contenido recomendado

El sistema de tipos de C#

Aprenda a crear tipos en C#, como tuplas, registros, tipos de valor y tipos de
referencia.


Polimorfismo
 Obtenga información sobre el polimorfismo, un concepto clave en lenguajes
de programación orientados a objetos como C#, que describe la relación
entre las clases base y derivadas.


Palabra clave class: Referencia de C#

Palabra clave class: Referencia de C#

Tipos numéricos enteros (referencia de

C#)
 Artículo
 08/07/2022
 Tiempo de lectura: 6 minutos
 4 colaboradores

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 Intervalo Tamaño Tipo de .NET

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

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:

C#Copiar
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. 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 partir de C# 11, los nint tipos
y nuint son alias para los tipos subyacentes.

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

Cada uno de los tipos enteros tiene MinValue propiedades y MaxValue que
proporcionan el valor mínimo y máximo de ese tipo. Estas propiedades son
constantes en tiempo de compilación, excepto para el caso de los tipos de tamaño
nativo (nint y nuint). Las MinValue propiedades 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 (disponible en C# 7.0 y versiones posteriores)

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

C#Copiar
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, que se admite a partir de C# 7.0. 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:

C#Copiar
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 un error del compilador CS0031 .

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:

C#Copiar
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 entero natural 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:

C#Copiar
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:

C#Copiar
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:

o Para nint: entre Int32.MinValue y Int32.MaxValue.
o Para nuint: entre UInt32.MinValue y UInt32.MaxValue.

 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:

C#Copiar
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#:

 Tipos enteros
 Literales enteros

Vea también
 Referencia de C#
 Tipos de valor
 Tipos de punto flotante
 Cadenas con formato numérico estándar
 Valores numéricos en .NET