Skip to content

3. Fundamentos del lenguaje C#

3.1. Introducción

Comenzaremos tratando C# como un lenguaje de programación tradicional. Las clases se abordarán en el siguiente capítulo. En un programa hay dos componentes principales:

  • los datos;
  • las instrucciones que los manipulan.

Por lo general, se procura separar los datos de las instrucciones:

Image

Todos los ejemplos de este capítulo son aplicaciones de un solo archivo: un único archivo [.cs], sin archivo de proyecto ([.csproj]), que se ejecuta con el comando [dotnet run basics-01.cs]. Esta característica, introducida con .NET 10, se trató en el capítulo anterior. Los ejemplos se encuentran en la carpeta [03-basics] del código del curso. Se ejecutan con la configuración regional francesa (fr-FR), como en una máquina Windows en francés: los números reales se muestran con coma decimal.

3.2. El programa mínimo

3.2.1. Instrucciones de nivel superior

El programa [basics-01.cs] es el siguiente:

1
2
3
4
5
// programa mínimo escrito con instrucciones de nivel superior (C# 9)
// las instrucciones se escriben directamente en el archivo: sin clase ni método Main
Console.WriteLine("Hello world!");
// el nombre completo de la clase Console es System.Console
System.Console.WriteLine("Number of arguments received: " + args.Length);

Resultados:

1
2
3
> dotnet run basics-01.cs
Hello world!
Number of arguments received: 0

Comentarios:

  • El programa no contiene ni clases ni métodos: las instrucciones se escriben directamente en el archivo. Se denominan instrucciones de nivel superior (C# 9, 2020). Un único archivo del programa puede contenerlas;
  • Línea 3: el método [WriteLine] de la clase [Console] imprime una línea en la pantalla;
  • línea 5: la clase [Console] pertenece al espacio de nombres [System]. Su nombre completo es [System.Console]. Un espacio de nombres agrupa tipos relacionados, del mismo modo que una carpeta agrupa archivos;
  • línea 5: el programa dispone de un arreglo [args] que contiene los argumentos de la línea de comandos. Volveremos sobre esto en la sección “Argumentos del programa principal”. El número de elementos del arreglo es [args.Length]. El operador + concatena aquí una cadena y un número: el número se convierte primero en cadena.

Con dos argumentos en la línea de comandos (todo lo que sigue a [--] se pasa al programa):

1
2
3
> dotnet run basics-01.cs -- a0 a1
Hello world!
Number of arguments received: 2

3.2.2. La forma clásica con un método Main

El curso de 2008 (C# 3.0) no trataba las instrucciones de nivel superior. El mismo programa se escribía así: [basics-02.cs]:

// la forma clásica del mismo programa (la única posible hasta C# 8)
using System;

namespace Basics
{
    class Program
    {
        // el método Main es el punto de entrada del programa
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world!");
            System.Console.WriteLine("Number of arguments received: " + args.Length);
        }
    }
}

Resultados:

1
2
3
> dotnet run basics-02.cs
Hello world!
Number of arguments received: 0

Comentarios:

  • línea 2: la directiva [using] importa el espacio de nombres [System]. Entonces se puede escribir [Console] en lugar de [System.Console];
  • Línea 4: la clase se coloca en el espacio de nombres [Basics]. A partir de C# 10, se puede escribir [namespace Basics;] (espacio de nombres con ámbito de archivo): todo el archivo pertenece entonces a este espacio de nombres, sin llaves ni sangría adicional. Esta es la forma que utilizaremos de ahora en adelante;
  • Línea 6: en C#, todo el código pertenece a una clase. Aquí la clase se llama [Program];
  • Línea 9: el método estático [Main] es el punto de entrada del programa: es el método que el sistema ejecuta al iniciarlo. Su parámetro, [args], recibe los argumentos de la línea de comandos.

Los dos programas son equivalentes. Cuando encuentra instrucciones de nivel superior, el compilador genera una clase y un método llamado [Main] que contienen esas instrucciones, así como el parámetro [string[] args]. Las instrucciones de nivel superior son, por tanto, una simple forma abreviada de la sintaxis estándar. Resultan adecuadas para los programas pequeños de este capítulo; la sintaxis estándar sigue siendo útil cuando se quiere inspeccionar la clase que contiene [Main].

3.2.3. Instrucciones using implícitas

El programa [basics-01.cs] utiliza la clase [Console] sin la directiva [using System;]. Esto es posible porque el SDK de .NET agrega automáticamente a cada programa de consola un archivo generado que contiene directivas [global using] (C# 10), que se aplican a todos los archivos del programa. Para [basics-01.cs], este archivo contiene:

1
2
3
4
5
6
7
8
// <auto-generated/>
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using System.Net.Http;
global using System.Threading;
global using System.Threading.Tasks;

Son las instrucciones using implícitas: los espacios de nombres más utilizados se importan automáticamente. Un espacio de nombres que no figura en esta lista, como [System.Globalization], siempre debe importarse con una directiva [using] al principio del archivo. En el programa [basics-02.cs], la directiva [using System;] es, por tanto, redundante: la dejamos para mostrar el formato de 2008.

3.3. Los datos de C#

C# utiliza los siguientes tipos de datos:

  • enteros;
  • números reales;
  • números decimales;
  • caracteres y cadenas de caracteres;
  • booleanos;
  • objetos.

3.3.1. Tipos de datos predefinidos

Tipo C#
Tipo .NET
Datos representados
Sufijo del literal
Codificación
Rango de valores
[char]
[Char] (S)
carácter
 
2 bytes
carácter Unicode (UTF-16)
[string]
[String] (C)
cadena de caracteres
  
referencia a una secuencia de caracteres Unicode
[int]
[Int32] (S)
entero
 
4 bytes
[-2³¹, 2³¹-1] o [-2147483648, 2147483647]
[uint]
[UInt32] (S)
entero sin signo
U
4 bytes
[0, 2³²-1] o [0, 4294967295]
[long]
[Int64] (S)
entero
L
8 bytes
[-2⁶³, 2⁶³-1] o [-9223372036854775808, 9223372036854775807]
[ulong]
[UInt64] (S)
entero sin signo
UL
8 bytes
[0, 2⁶⁴-1] o [0, 18446744073709551615]
[sbyte]
[SByte] (S)
entero
 
1 byte
[-2⁷, 2⁷-1] o [-128, 127]
[byte]
[Byte] (S)
entero sin signo
 
1 byte
[0, 2⁸-1] o [0, 255]
[short]
[Int16] (S)
entero
 
2 bytes
[-2¹⁵, 2¹⁵-1] o [-32768, 32767]
[ushort]
[UInt16] (S)
entero sin signo
 
2 bytes
[0, 2¹⁶-1] o [0, 65535]
[float]
[Single] (S)
número real
F
4 bytes
[1,5 10⁻⁴⁵, 3,4 10³⁸] en valor absoluto, 7 dígitos significativos
[double]
[Double] (S)
número real
D
8 bytes
[5,0 10⁻³²⁴, 1,7 10³⁰⁸] en valor absoluto, de 15 a 16 dígitos significativos
[decimal]
[Decimal] (S)
número decimal
M
16 bytes
[1,0 10⁻²⁸, 7,9 10²⁸] en valor absoluto, de 28 a 29 dígitos significativos
[bool]
[Boolean] (S)
booleano
 
1 byte
[true], [false]
[object]
[Object] (C)
referencia a un objeto
  
referencia a un objeto de cualquier tipo

Más arriba hemos enumerado los tipos .NET equivalentes a cada tipo de C#, marcados con (S) si el tipo es una estructura y con (C) si es una clase. Vemos que existen dos nombres posibles para un entero de 32 bits: [int] e [Int32]. El tipo [int] es una palabra clave de C#. [Int32] es una estructura que pertenece al espacio de nombres [System]: su nombre completo es [System.Int32]. El tipo [int] es un alias de C# que designa la estructura .NET [System.Int32]. Del mismo modo, el tipo C# [string] es un alias del tipo .NET [System.String]. [System.String] es una clase, no una estructura. Los dos conceptos son similares, pero con la siguiente diferencia fundamental:

  • una variable de tipo estructura contiene directamente su valor: se denomina tipo de valor;
  • una variable de un tipo clase contiene la dirección del objeto (su referencia); se denomina tipo de referencia.

Además, existen dos tipos menos comunes:

  • [nint] y [nuint] (C# 9) son enteros con y sin signo cuyo tamaño es el de una dirección de memoria: 4 bytes en un sistema de 32 bits, 8 bytes en un sistema de 64 bits. Se utilizan principalmente para interactuar con código nativo;
  • [System.Half] (.NET 5) es un número de punto flotante de 2 bytes y baja precisión, utilizado en gráficos por computadora y en aprendizaje automático. No es un tipo predefinido del lenguaje: no tiene una palabra clave de C#.

Una estructura, al igual que una clase, es un tipo complejo con propiedades y métodos. Así, podemos escribir:

string? typeName = 3.GetType().FullName;

El literal 3 es, de forma predeterminada, de tipo C# [int], y por tanto de tipo .NET [System.Int32]. Esta estructura tiene un método [GetType()] que devuelve un objeto que describe el tipo de dato. Entre las propiedades de este objeto, [FullName] es el nombre completo del tipo. El literal 3 es, pues, un objeto más complejo de lo que parece a primera vista. El signo de interrogación de [string?] se explicará un poco más adelante.

El programa [basics-03.cs] ilustra estos diversos puntos:

// los tipos predefinidos: tipo .NET y tamaño en bytes
int integer = 2;
float fl = 10.5F;
double d = -4.6;
string s = "test";
uint ui = 5;
long l = 1000;
ulong ul = 1001;
byte octet = 5;
sbyte so = -5;
short sh = -4;
ushort ush = 10;
decimal dec = 10.67M;
bool b = true;
char c = 'A';
// {0}, {1}, {2} se reemplazan por los parámetros n.º 0, 1, 2 que siguen al formato
Console.WriteLine("Type of integer[{1}] : [{0},{2}]", integer.GetType().FullName, integer, sizeof(int));
Console.WriteLine("Type of fl[{1}] : [{0},{2}]", fl.GetType().FullName, fl, sizeof(float));
Console.WriteLine("Type of d[{1}] : [{0},{2}]", d.GetType().FullName, d, sizeof(double));
Console.WriteLine("Type of s[{1}] : [{0}]", s.GetType().FullName, s);
Console.WriteLine("Type of ui[{1}] : [{0},{2}]", ui.GetType().FullName, ui, sizeof(uint));
Console.WriteLine("Type of l[{1}] : [{0},{2}]", l.GetType().FullName, l, sizeof(long));
Console.WriteLine("Type of ul[{1}] : [{0},{2}]", ul.GetType().FullName, ul, sizeof(ulong));
Console.WriteLine("Type of octet[{1}] : [{0},{2}]", octet.GetType().FullName, octet, sizeof(byte));
Console.WriteLine("Type of so[{1}] : [{0},{2}]", so.GetType().FullName, so, sizeof(sbyte));
Console.WriteLine("Type of sh[{1}] : [{0},{2}]", sh.GetType().FullName, sh, sizeof(short));
Console.WriteLine("Type of ush[{1}] : [{0},{2}]", ush.GetType().FullName, ush, sizeof(ushort));
Console.WriteLine("Type of dec[{1}] : [{0},{2}]", dec.GetType().FullName, dec, sizeof(decimal));
Console.WriteLine("Type of b[{1}] : [{0},{2}]", b.GetType().FullName, b, sizeof(bool));
Console.WriteLine("Type of c[{1}] : [{0},{2}]", c.GetType().FullName, c, sizeof(char));
// entero cuyo tamaño es el de una dirección de memoria (4 u 8 bytes según la máquina)
nint ni = 7;
Console.WriteLine("Type of ni[{1}] : [{0},{2}]", ni.GetType().FullName, ni, nint.Size);
// número real de 2 bytes (.NET 5)
Half h = (Half)1.5;
Console.WriteLine("Type of h[{1}] : [{0}]", h.GetType().FullName, h);
// el literal 3 también es un objeto
Console.WriteLine("Type of the literal 3 : " + 3.GetType().FullName);
// valores extremos
Console.WriteLine("int : [{0}, {1}]", int.MinValue, int.MaxValue);
Console.WriteLine("long : [{0}, {1}]", long.MinValue, long.MaxValue);
Console.WriteLine("decimal : [{0}, {1}]", decimal.MinValue, decimal.MaxValue);

Resultados:

> dotnet run basics-03.cs
Type of integer[2] : [System.Int32,4]
Type of fl[10,5] : [System.Single,4]
Type of d[-4,6] : [System.Double,8]
Type of s[test] : [System.String]
Type of ui[5] : [System.UInt32,4]
Type of l[1000] : [System.Int64,8]
Type of ul[1001] : [System.UInt64,8]
Type of octet[5] : [System.Byte,1]
Type of so[-5] : [System.SByte,1]
Type of sh[-4] : [System.Int16,2]
Type of ush[10] : [System.UInt16,2]
Type of dec[10,67] : [System.Decimal,16]
Type of b[True] : [System.Boolean,1]
Type of c[A] : [System.Char,2]
Type of ni[7] : [System.IntPtr,8]
Type of h[1,5] : [System.Half]
Type of the literal 3 : System.Int32
int : [-2147483648, 2147483647]
long : [-9223372036854775808, 9223372036854775807]
decimal : [-79228162514264337593543950335, 79228162514264337593543950335]

Comentarios:

  • línea 2: declaración de un entero [integer] inicializado en 2;
  • línea 16: la instrucción [Console.WriteLine("... {0} ... {1} ...", param0, param1, ...)] muestra en pantalla el texto especificado como primer parámetro (el formato), reemplazando cada {i} por el valor del i-ésimo parámetro que sigue al formato. Los parámetros se numeran a partir de 0;
  • línea 17: el tipo de una variable [v] se obtiene mediante [v.GetType().FullName]. El tamaño en bytes de un tipo de valor predefinido [T] se obtiene mediante [sizeof(T)];
  • línea 20: como el tipo [string] hace referencia a una clase y no a una estructura, no se puede utilizar el operador [sizeof];
  • línea 33: [sizeof(nint)] no está permitido en el código normal porque el tamaño de [nint] solo se conoce en tiempo de ejecución. La propiedad [nint.Size] indica que es de 8 bytes en la máquina de 64 bits que se utiliza;
  • línea 35: no se puede escribir [Half h = 1.5;]: no existe una conversión implícita de [double] a [Half]. La notación [(Half)] es una conversión explícita (conocida como “cast” en inglés), que examinaremos más adelante;
  • líneas 40–42: las propiedades [MinValue] y [MaxValue] de los tipos numéricos indican los límites de sus dominios de valores.

La salida muestra los nombres de los tipos .NET en lugar de los alias de C#. Observe la coma decimal en los números de punto flotante: los números se convierten en cadenas según la configuración regional del sistema, en este caso la francesa.

3.3.2. Notación de los datos literales

Dato
Ejemplos de literales
[int] entero (32 bits)
145, -7, 0xFF (hexadecimal), 0b1010_1010 (binario)
Entero [long] (64 bits), sufijo L
100000L, 1_000_000_000_000L
entero sin signo, sufijo U o UL
4000000000U, 10UL
real de punto flotante [double]
134.789, -45E-18 (-45 × 10⁻¹⁸)
real [float], sufijo F
134.789F, -45E-18F
real [decimal], sufijo M
100000.50M
carácter [char]
'A', 'b', '\n', '\u00e9'
cadena [string]
"today", "c:\\chap1", @"c:\chap1", $"{name} is {age} years old", """plain text"""
booleano [bool]
[true], [false]
fecha
[new DateTime(1954, 10, 13)] (año, mes, día) para el 13/10/1954

En el código fuente, los números de punto flotante siempre se escriben con punto decimal, sea cual sea la configuración regional del sistema. Desde C# 7, los enteros pueden escribirse en binario (con el prefijo [0b]) y los grupos de dígitos pueden separarse con el carácter _ para mejorar la legibilidad: [1_000_000] es el entero un millón.

Un literal de cadena estándar puede contener secuencias de escape introducidas por el carácter \: "\n" representa el carácter de fin de línea y no la secuencia de los dos caracteres \ y n, "\t" representa una tabulación, "\"" representa unas comillas dobles y "\\" representa el propio carácter \. Para escribir la ruta de Windows c:\chap1\paragraph3, hay que escribir, por tanto, "c:\\chap1\\paragraph3". También se puede escribir @"c:\chap1\paragraph3": la sintaxis @"texto" indica que el texto debe tomarse exactamente tal como está escrito, sin interpretar el carácter \. Esto se denomina cadena textual.

C# ofrece ahora otros dos tipos de cadenas:

  • la cadena interpolada (C# 6) $"...": las expresiones entre llaves se evalúan y sus valores se insertan en la cadena. Una expresión puede ir seguida de un especificador de formato después de los dos puntos: [$"{d1:F2}"] muestra el número de punto flotante [d1] con dos decimales. Es la forma más legible de construir una cadena, y la utilizaremos de ahora en adelante en lugar de los formatos {0}, {1}, ...;
  • La cadena literal sin formato (C# 11) """...""" : comienza y termina con al menos tres comillas. Puede contener comillas y caracteres \ sin escapar, y puede ocupar varias líneas. Los espacios que preceden a las comillas de cierre se eliminan de cada línea, lo que permite sangrar el texto junto con el código. Es muy útil para escribir JSON, SQL o HTML.

El programa [basics-04.cs] muestra estas diferentes notaciones:

// la notación de datos literales
// enteros: decimal, hexadecimal (0x), binario (0b), separador _
int i1 = 145, i2 = -7, i3 = 0xFF, i4 = 0b1010_1010;
long l1 = 100000L, l2 = 1_000_000_000_000L;
Console.WriteLine("integers : {0} {1} {2} {3} {4} {5}", i1, i2, i3, i4, l1, l2);
// números reales
double d1 = 134.789, d2 = -45E-18;
float f1 = 134.789F;
decimal m1 = 100000.50M;
Console.WriteLine("reals : {0} {1} {2} {3}", d1, d2, f1, m1);
// caracteres y booleanos
char c1 = 'A', c2 = '\u00e9';
bool b1 = true;
Console.WriteLine("characters : {0} {1}, boolean : {2}", c1, c2, b1);
// una fecha: (año, mes, día)
DateTime birth = new DateTime(1954, 10, 13);
Console.WriteLine("date : {0}", birth.ToShortDateString());

// cadenas clásicas: el carácter \ introduce una secuencia de escape
string path1 = "c:\\chap1\\paragraph3";
// cadena textual (verbatim): el texto se toma tal cual
string path2 = @"c:\chap1\paragraph3";
Console.WriteLine(path1);
Console.WriteLine(path2);
Console.WriteLine("line 1\nline 2\t[tab]");

// cadena interpolada: se evalúan las expresiones entre llaves
string name = "dupont";
int age = 23;
Console.WriteLine($"{name} is {age} years old, in 10 years he will be {age + 10}");
// con un formato después del carácter :
Console.WriteLine($"d1={d1:F1}, i3 in hexadecimal={i3:X}, i4 in binary={i4:B8}, l2={l2:N0}");
Console.WriteLine($"date={birth:dddd d MMMM yyyy}");

// cadena literal sin procesar (raw string) (C# 11): sin escape, sin duplicar las comillas
string json = """
    {
      "name": "dupont",
      "path": "c:\chap1"
    }
    """;
Console.WriteLine(json);
// cadena sin procesar interpolada: con $$, las expresiones van entre {{ y }}
string json2 = $$"""{ "name": "{{name}}", "age": {{age}} }""";
Console.WriteLine(json2);

Resultados:

> dotnet run basics-04.cs
integers : 145 -7 255 170 100000 1000000000000
reals : 134,789 -4,5E-17 134,789 100000,50
characters : A é, boolean : True
date : 13/10/1954
c:\chap1\paragraph3
c:\chap1\paragraph3
line 1
line 2    [tab]
dupont is 23 years old, in 10 years he will be 33
d1=134,8, i3 in hexadecimal=FF, i4 in binary=10101010, l2=1 000 000 000 000
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }

Comentarios:

  • línea 3: [0xFF] es 255 y [0b1010_1010] es 170;
  • línea 7: -45E-18 se muestra como -4,5E-17: es el mismo valor, normalizado;
  • línea 12: la secuencia \u00e9 designa el carácter Unicode con código hexadecimal 00E9, es decir, é;
  • línea 16: una fecha. El método [ToShortDateString] la muestra en el formato corto utilizado en la cultura francesa. Para una fecha sin hora, .NET 6 agregó el tipo [DateOnly]; volveremos sobre él en el Capítulo 5;
  • líneas 20–22: las dos cadenas son idénticas, como lo muestra la salida;
  • línea 30: una cadena interpolada. Las expresiones [name], [age], y [age + 10] se evalúan y luego se insertan en la cadena;
  • línea 32: algunos formatos: F1 (un decimal), X (hexadecimal), B8 (binario de 8 dígitos, .NET 8), N0 (separador de millares, sin decimales);
  • línea 33: un formato de fecha personalizado: día de la semana, día, mes en letras, año;
  • líneas 36–41: una cadena literal sin formato de varias líneas. Las comillas y el carácter \ se escriben tal cual. Los cuatro espacios que preceden a las comillas de cierre se han eliminado de cada línea;
  • línea 44: una cadena literal sin formato interpolada. Con dos caracteres $, las expresiones se escriben entre llaves dobles {{ y }}: las llaves simples, que aparecen con frecuencia en JSON, siguen siendo texto sin formato.

3.3.3. Declaración de datos

3.3.3.1. Función de las declaraciones

Un programa manipula datos caracterizados por un nombre y un tipo. Estos datos se almacenan en la memoria. Cuando se compila el programa, el compilador asigna a cada dato una ubicación de memoria caracterizada por una dirección y un tamaño. Lo hace a partir de las declaraciones realizadas por el programador. Además, estas declaraciones permiten al compilador detectar errores de programación. Así, la operación [x = x * 2;] se declarará no válida si [x] es una cadena de caracteres.

3.3.3.2. Declaración de constantes

La sintaxis para declarar una constante es la siguiente:

const type name = value;

Por ejemplo:

const double VatRate = 0.2;

¿Por qué declarar constantes?

  • El programa es más fácil de leer si la constante tiene un nombre significativo;
  • es más fácil modificar el programa si hay que cambiar la “constante”. Así, si la tasa de IVA pasa a 0,25, la única modificación necesaria será en la instrucción que define su valor: [const double VatRate = 0.25;]. Si se hubiera utilizado 0,2 de forma explícita en el programa, habría que modificar numerosas instrucciones.

El valor de una constante debe conocerse en tiempo de compilación: un número, una cadena, un booleano o una expresión que pueda calcularse a partir de otras constantes. Por convención, en .NET los nombres de las constantes comienzan con mayúscula.

3.3.3.3. Declaración de variables

Una variable se identifica por un nombre y se asocia a un tipo de datos. C# distingue entre mayúsculas y minúsculas: las variables [END] y [end] son diferentes.

Las variables pueden inicializarse al declararse. La sintaxis para declarar una o varias variables es:

type variable1 = value1, variable2 = value2, ...;

donde [type] es un tipo predefinido o un tipo definido por el programador. La inicialización es opcional; sin embargo, C# no permite el uso de una variable local a la que aún no se le ha asignado un valor.

También se puede omitir el tipo de una variable usando la palabra clave [var] en lugar del tipo:

var variable1 = value1;

La palabra clave [var] no significa que la variable carezca de un tipo específico: tiene el tipo del valor que se le asigna, determinado por el compilador. Aquí la inicialización es obligatoria para que el compilador pueda deducir el tipo. Utilizamos [var] cuando el tipo se deduce con claridad del valor.

El programa [basics-05.cs] es el siguiente:

// constantes y variables
const double VatRate = 0.2;
const string Currency = "euros";
double priceExclTax = 100;
Console.WriteLine($"Price incl. tax : {priceExclTax * (1 + VatRate)} {Currency}");

// un dato con tipo explícito
int i = 2;
Console.WriteLine($"Type of int i=2 : {i.GetType().Name},{i.GetType().FullName}");
// dato con tipo implícito mediante var
var j = 3;
Console.WriteLine($"Type of var j=3 : {j.GetType().Name},{j.GetType().FullName}");
var today = DateTime.Now;
Console.WriteLine($"Type of var today : {today.GetType().Name},{today.GetType().FullName}");
var x = 3.5;
var y = 3.5F;
var z = 10L;
var name = "dupont";
Console.WriteLine($"x : {x.GetType().Name}, y : {y.GetType().Name}, z : {z.GetType().Name}, name : {name.GetType().Name}");
// varias variables declaradas en la misma línea
int a = 1, b, c = 3;
b = a + c;
Console.WriteLine($"a={a}, b={b}, c={c}");

Resultados:

1
2
3
4
5
6
7
> dotnet run basics-05.cs
Price incl. tax : 120 euros
Type of int i=2 : Int32,System.Int32
Type of var j=3 : Int32,System.Int32
Type of var today : DateTime,System.DateTime
x : Double, y : Single, z : Int64, name : String
a=1, b=4, c=3

Comentarios:

  • líneas 2–3: dos constantes;
  • línea 8: un dato con tipo explícito;
  • línea 9: [GetType().Name] es el nombre corto del tipo, [GetType().FullName] es su nombre completo;
  • línea 11: un valor con tipo implícito. Como 3 es de tipo [int], [j] será de tipo [int];
  • línea 13: como [DateTime.Now] (la fecha y hora actuales) es de tipo [DateTime], [today] será de tipo [DateTime];
  • líneas 15–18: el tipo inferido depende de cómo se escribe el literal: 3.5 es un [double], 3.5F es un [float] y 10L es un [long];
  • línea 21: tres variables declaradas en la misma línea; solo [a] y [c] se inicializan. A [b] se le asigna un valor en la línea siguiente.

Una variable con tipo implícito mediante la palabra clave [var] no puede cambiar de tipo después. Así, tras la línea 13, no se podría escribir:

today = "today";

porque [today] es de tipo [DateTime]. Veremos en el Capítulo 5, con LINQ, que es posible crear un tipo “al vuelo” dentro de una expresión: es un tipo anónimo, al que el programador no ha asignado un nombre. Si hay que asignar un dato de tipo anónimo a una variable, la única manera de declarar esa variable es utilizar la palabra clave [var].

3.3.4. Tipos que admiten valores NULL

Una variable de un tipo de valor, como [int], siempre contiene un valor. A veces resulta útil poder expresar la ausencia de valor: una edad desconocida, un campo vacío en una base de datos. El tipo [int?] (C# 2) es el tipo [int] al que se le agrega el valor [null], que significa “sin valor”. Se habla entonces de tipo de valor que admite valores NULL. El principio se aplica a todos los tipos de valor: [double?], [bool?], [DateTime?], ...

Una variable de un tipo de referencia, como [string], siempre puede tener el valor [null]: esto significa que no hace referencia a ningún objeto. Intentar utilizar un miembro de una variable de este tipo (por ejemplo, su propiedad [Length]) provocará un error en tiempo de ejecución ([NullReferenceException]), uno de los errores más comunes en C#. Desde C# 8, el compilador puede ayudar a evitarlo: con los tipos de referencia que admiten valores NULL, habilitados de forma predeterminada en los proyectos creados con el comando [dotnet new] y en las aplicaciones de un solo archivo,

  • el tipo [string] designa una cadena que nunca vale [null];
  • el tipo [string?] designa una cadena que puede ser [null].

El compilador rastrea los valores posibles de las variables y emite una advertencia cuando existe el riesgo de utilizar el valor [null]: asignar [null] a una variable [string], utilizar [Length] en una variable [string?] que no se ha comprobado, etc. A diferencia de [int?], [string?] no crea un nuevo tipo en tiempo de ejecución: es una indicación destinada al compilador.

Nos encontraremos con estos tipos desde los primeros ejemplos, porque el método [Console.ReadLine()], que lee una línea escrita en el teclado, devuelve un [string?]: devuelve [null] cuando ya no queda nada por leer (fin del flujo de entrada). El programa [basics-06.cs] es el siguiente:

// tipos que admiten valores nulos (nullable)
// un tipo de valor nullable (int?) acepta el valor null además de los enteros
int? age = null;
Console.WriteLine($"age.HasValue={age.HasValue}");
age = 23;
Console.WriteLine($"age.HasValue={age.HasValue}, age.Value={age.Value}");
// int? -> int: se necesita una conversión explícita (excepción si age es null)
int n = (int)age;
Console.WriteLine($"n={n}");

// un tipo de referencia nullable (string?) acepta el valor null
string? firstName = null;
Console.WriteLine($"firstName is null : {firstName == null}");
// se asume que el tipo string (sin ?) nunca es null
string name = "dupont";
Console.WriteLine($"name has {name.Length} characters");

// Console.ReadLine devuelve un string?: null si el flujo de entrada se agotó
Console.Write("Type a line: ");
string? line = Console.ReadLine();
if (line == null)
{
    Console.WriteLine();
    Console.WriteLine("No line: the input stream is closed");
}
else
{
    // aquí el compilador sabe que line no es null
    Console.WriteLine($"You typed [{line}] : {line.Length} character(s)");
}

Resultados al escribir texto con el teclado:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: hello
You typed [hello] : 5 character(s)

Resultados cuando el usuario presiona Ctrl-D (Ctrl-Z seguido de Enter en Windows), lo que cierra el flujo de entrada:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: 
No line: the input stream is closed

Comentarios:

  • línea 3: [age] no contiene ningún valor;
  • línea 4: la propiedad [HasValue] indica si la variable contiene un valor; la propiedad [Value] proporciona ese valor;
  • línea 8: un [int?] no se puede asignar directamente a un [int] , ya que puede ser igual a [null]. Se requiere una conversión explícita, que lanza una excepción si [age] es igual a [null]. Más adelante hablaremos del operador [??], más seguro;
  • línea 12: una cadena que puede ser igual a [null];
  • línea 15: una cadena que nunca es igual a [null]. Escribir [name = null;] provocaría una advertencia del compilador;
  • línea 20: [Console.ReadLine()] se evalúa como [string?]. Declarar [line] de tipo [string] provocaría una advertencia;
  • línea 21: se comprueba el valor [null];
  • línea 29: en la rama [else], el compilador sabe que [line] no es igual a [null]: no emite ninguna advertencia por el uso de [line.Length].

3.3.5. Conversiones entre números y cadenas

Conversión
Método
número -> cadena
[number.ToString()] o una cadena interpolada [$"{number}"]
cadena -> int
[int.Parse(str)] o [int.TryParse(str, out int number)]
cadena -> long
[long.Parse(str)] o [long.TryParse(str, out long number)]
cadena -> double
[double.Parse(str)] o [double.TryParse(str, out double number)]
cadena -> float
[float.Parse(str)] o [float.TryParse(str, out float number)]
cadena -> decimal
[decimal.Parse(str)] o [decimal.TryParse(str, out decimal number)]

La conversión de una cadena en un número puede fallar si la cadena no representa un número válido. El método [Parse] genera entonces un error fatal llamado excepción. Este error puede tratarse mediante la siguiente cláusula [try / catch]:

1
2
3
4
5
6
7
8
9
try
{
    call the function likely to throw the exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

Si la función no lanza una excepción, la ejecución continúa con la siguiente instrucción; en caso contrario, pasa al cuerpo de la cláusula [catch] y luego a la siguiente instrucción. Volveremos sobre el manejo de excepciones en la sección dedicada a ellas.

El método [TryParse] (.NET 2.0) evita la excepción: devuelve el booleano [true] si la conversión tiene éxito y [false] en caso contrario, y almacena el número resultante en una variable pasada con la palabra clave [out]. Desde C# 7, esta variable puede declararse en la propia llamada: [int.TryParse(str, out var number)]. El modo de paso [out] se explicará en la sección sobre el paso de parámetros. Cuando se esperan entradas incorrectas (por ejemplo, desde un teclado), es preferible [TryParse] a [Parse]: un error de entrada no es una situación excepcional.

El programa [basics-07.cs] muestra varias técnicas de conversión entre números y cadenas de caracteres. La función [Display] muestra en pantalla el valor de su parámetro:

// conversiones entre números y cadenas de caracteres
using System.Globalization;

// datos
const int i = 10;
const long l = 100000;
const float f = 45.78F;
double d = -14.98;

// número --> cadena
Display(i.ToString());
Display(l.ToString());
Display(f.ToString());
Display(d.ToString());

// booleano --> cadena
const bool b = false;
Display(b.ToString());

// cadena --> int
int i1 = int.Parse("10");
Display(i1.ToString());
try
{
    i1 = int.Parse("10.67");
    Display(i1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// cadena --> long
long l1 = long.Parse("100");
Display(l1.ToString());
try
{
    l1 = long.Parse("10.675");
    Display(l1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// cadena --> double
double d1 = double.Parse("100,87");
Display(d1.ToString());
try
{
    d1 = double.Parse("abcd");
    Display(d1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// cadena --> float
float f1 = float.Parse("100,87");
Display(f1.ToString());
try
{
    f1 = float.Parse("abcd");
    Display(f1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// TryParse: devuelve false en lugar de lanzar una excepción
if (int.TryParse("123", out int i2))
{
    Display($"TryParse(\"123\") succeeded : {i2}");
}
if (!int.TryParse("12x", out var i3))
{
    Display($"TryParse(\"12x\") failed, i3={i3}");
}

// la cultura: separador decimal de la cultura actual
Display($"Current culture : {CultureInfo.CurrentCulture.Name}");
try
{
    d1 = double.Parse("100.87");
    Display(d1.ToString());
}
catch (FormatException e)
{
    Display("Error : " + e.Message);
}
// la cultura invariante usa el punto decimal
double d2 = double.Parse("100.87", CultureInfo.InvariantCulture);
Display(d2.ToString());
Display(d2.ToString(CultureInfo.InvariantCulture));
if (double.TryParse("3.14", CultureInfo.InvariantCulture, out double pi))
{
    Display($"pi={pi}");
}

// una función local (ver más adelante) que muestra su parámetro
static void Display(string s)
{
    Console.WriteLine($"S={s}");
}

Resultados:

> dotnet run basics-07.cs
S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Error : The input string '10.67' was not in a correct format.
S=100
S=Error : The input string '10.675' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=TryParse("123") succeeded : 123
S=TryParse("12x") failed, i3=0
S=Current culture : fr-FR
S=Error : The input string '100.87' was not in a correct format.
S=100,87
S=100.87
S=pi=3,14

Comentarios:

  • línea 2: el espacio de nombres [System.Globalization], que contiene la clase [CultureInfo], no está incluido en las instrucciones using implícitas;
  • líneas 5–8: los datos que se van a convertir;
  • líneas 11–14: todo objeto tiene un método [ToString()] que lo convierte en una cadena;
  • líneas 25–30: se maneja la excepción que [int.Parse] puede lanzar. [e.Message] es el mensaje de error asociado a la excepción [e]. Los mensajes de excepción de .NET están en inglés: .NET 10 no ofrece una traducción al francés;
  • línea 47: la cadena utiliza una coma decimal, de acuerdo con la configuración regional francesa del sistema;
  • línea 73: [TryParse] tiene éxito y almacena 123 en la variable [i2], declarada en la llamada;
  • línea 77: [TryParse] falla y devuelve [false]; a la variable [i3] se le asigna entonces el valor 0;
  • línea 83: la configuración regional actual del programa es fr-FR;
  • línea 86: en la configuración regional francesa, el punto no es un separador decimal: la conversión falla;
  • línea 94: la configuración regional invariante [CultureInfo.InvariantCulture] utiliza el punto decimal, sea cual sea la máquina. Se utiliza para leer y escribir números en archivos o en intercambios entre programas, que no deben depender del idioma del usuario;
  • líneas 95–96: el mismo número convertido en cadena según la configuración regional actual (100,87) y según la configuración regional invariante (100.87);
  • línea 97: [TryParse] también acepta una configuración regional;
  • líneas 103–105: una función local. En un programa con instrucciones de nivel superior no se pueden escribir métodos, ya que no hay clases; en su lugar, se escriben funciones locales, que pueden llamarse antes de ser definidas. Se tratan en la sección “Funciones locales y tuplas”.

El curso de 2008 afirmaba que los números reales en forma de cadena deben usar una coma: esto solo es cierto en la cultura francesa. Un programa que lee números siempre debe saber en qué cultura se escribieron.

3.3.6. Arreglos de datos

Un arreglo de C# es un objeto que permite agrupar datos del mismo tipo bajo un único identificador. Se declara así:

Type[] array = new Type[n];

[n] es el número de elementos de datos que puede contener el arreglo. La sintaxis [array[i]] hace referencia al elemento de datos número i, donde i pertenece al intervalo [0, n-1]. Cualquier referencia al elemento [array[i]] con i fuera del intervalo [0, n-1] provoca una excepción. Al crearse, a cada elemento del arreglo se le asigna el valor predeterminado de su tipo: 0 para los números, [false] para los booleanos y [null] para los tipos de referencia. Un arreglo puede inicializarse al mismo tiempo que se declara:

int[] integers = new int[] { 0, 10, 20, 30 };

o, de forma más sencilla:

int[] integers = { 0, 10, 20, 30 };

o, desde C# 12, mediante una expresión de colección:

int[] integers = [0, 10, 20, 30];

De ahora en adelante utilizaremos esta última forma. Los arreglos tienen una propiedad [Length], que representa el número de elementos que contienen.

Un arreglo bidimensional se declara así:

Type[,] array = new Type[n, m];

donde [n] es el número de filas y [m] es el número de columnas. La sintaxis [array[i, j]] hace referencia al elemento j de la fila i. El arreglo bidimensional también puede inicializarse al mismo tiempo que se declara:

double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };

El número de elementos de cada dimensión se obtiene con el método [GetLength(i)], donde i=0 representa la dimensión correspondiente al primer índice, i=1 la dimensión correspondiente al segundo índice, y así sucesivamente. El número de dimensiones se obtiene con la propiedad [Rank] y el número total de elementos con la propiedad [Length].

Un arreglo de arreglos (también llamado arreglo escalonado) se declara así:

Type[][] array = new Type[n][];

La declaración anterior crea un arreglo de n elementos. Cada elemento, [array[i]], es una referencia a un arreglo unidimensional. Estas referencias no se inicializan con la declaración anterior; tienen el valor [null]. A diferencia de un arreglo bidimensional, cada fila puede tener una longitud distinta.

C# 8 introdujo dos notaciones prácticas:

  • la indexación inversa: [array[^1]] es el último elemento, [array[^2]] es el penúltimo, y así sucesivamente. [array[^1]] equivale a [array[array.Length - 1]];
  • el rango: [array[1..3]] es un nuevo arreglo formado por los elementos de índices 1 y 2. El índice inicial se incluye y el índice final se excluye. Los límites pueden omitirse: [array[2..]] va del índice 2 hasta el final, y [array[..^1]] va desde el principio hasta el penúltimo elemento, inclusive.

El programa [basics-08.cs] combina estos diferentes arreglos:

// arreglos
// un arreglo unidimensional inicializado
int[] integers = new int[] { 0, 10, 20, 30 };
for (int i = 0; i < integers.Length; i++)
{
    Console.WriteLine($"integers[{i}]={integers[i]}");
}

// un arreglo bidimensional inicializado
double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };
for (int i = 0; i < reals.GetLength(0); i++)
{
    for (int j = 0; j < reals.GetLength(1); j++)
    {
        Console.WriteLine($"reals[{i},{j}]={reals[i, j]}");
    }
}
Console.WriteLine($"reals : Rank={reals.Rank}, Length={reals.Length}");

// un arreglo de arreglos (jagged array)
string[][] names = new string[3][];
for (int i = 0; i < names.Length; i++)
{
    names[i] = new string[i + 1];
}
// inicialización
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        names[i][j] = "name" + i + j;
    }
}
// visualización
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        Console.WriteLine($"names[{i}][{j}]={names[i][j]}");
    }
}

// un arreglo creado sin valores iniciales: elementos con el valor predeterminado del tipo
bool[] flags = new bool[3];
string?[] strings = new string?[2];
Console.WriteLine($"flags[0]={flags[0]}, strings[0] is null : {strings[0] == null}");

// expresión de colección (C# 12)
int[] values = [0, 10, 20, 30, 40];
// string.Join une los elementos de un arreglo con un separador
Console.WriteLine($"values=[{string.Join(", ", values)}]");
// índice desde el final (C# 8): ^1 designa el último elemento
Console.WriteLine($"values[^1]={values[^1]}, values[^2]={values[^2]}");
// rango (C# 8): los elementos en los índices 1 y 2 (el límite final se excluye)
int[] slice = values[1..3];
Console.WriteLine($"values[1..3]=[{string.Join(", ", slice)}]");
Console.WriteLine($"values[2..]=[{string.Join(", ", values[2..])}]");
Console.WriteLine($"values[..^1]=[{string.Join(", ", values[..^1])}]");
// el segmento es una copia: el arreglo original no se modifica
slice[0] = 100;
Console.WriteLine($"slice[0]={slice[0]}, values[1]={values[1]}");

Resultados:

> dotnet run basics-08.cs
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0,0]=0,5
reals[0,1]=1,7
reals[1,0]=8,4
reals[1,1]=-6
reals : Rank=2, Length=4
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=False, strings[0] is null : True
values=[0, 10, 20, 30, 40]
values[^1]=40, values[^2]=30
values[1..3]=[10, 20]
values[2..]=[20, 30, 40]
values[..^1]=[0, 10, 20, 30]
slice[0]=100, values[1]=10

Comentarios:

  • línea 3: se inicializa un arreglo unidimensional;
  • línea 4: un bucle [for] recorre los índices de 0 a [integers.Length - 1]. El bucle [for] se presenta más adelante;
  • línea 10: un arreglo bidimensional (2 filas, 2 columnas);
  • líneas 11–13: [GetLength(0)] es el número de filas, [GetLength(1)] es el número de columnas;
  • línea 21: un arreglo [names] de 3 elementos. Cada elemento es una referencia a un arreglo de tipo [string[]], actualmente [null];
  • línea 24: se inicializan los 3 elementos del arreglo [names] . [names[i]] hace referencia ahora a un arreglo de i+1 cadenas;
  • línea 31: [names[i][j]] es el j-ésimo elemento del arreglo al que hace referencia [names[i]]. Como [names[i]] es un arreglo, [names[i].Length] es el número de sus elementos. La expresión “name” + i + j se evalúa de izquierda a derecha: “name” + i da una cadena, a la que se concatena j;
  • líneas 44–45: arreglos creados sin valores iniciales. El tipo [string?[]] es un arreglo cuyos elementos pueden ser [null];
  • línea 49: una expresión de colección;
  • línea 51: el método [string.Join] construye una cadena con los elementos del arreglo, separados por la cadena pasada como primer parámetro;
  • línea 53: el último y el penúltimo elemento;
  • línea 55: los elementos de índices 1 y 2;
  • líneas 60–61: un rango crea una copia: modificar [slice] no modifica [values].

3.4. Instrucciones básicas de C#

Existen:

  • instrucciones básicas que ejecuta la computadora;
  • instrucciones que controlan el flujo del programa.

Las instrucciones básicas se entienden bien al considerar la estructura de una microcomputadora y sus periféricos:

Image

  • 1: lectura de información desde el teclado;
  • 2: procesamiento de la información;
  • 3: escritura de información en la pantalla.

3.4.1. Escritura en la pantalla

Existen diversas instrucciones para escribir en la pantalla:

1
2
3
Console.Out.WriteLine(expression);
Console.WriteLine(expression);
Console.Error.WriteLine(expression);

donde [expression] es cualquier dato que pueda convertirse en una cadena de caracteres para mostrarse en la pantalla. Todos los objetos de C# o .NET tienen un método [ToString()] que se utiliza para realizar esta conversión. El método [Write] hace lo mismo que [WriteLine] sin pasar a la línea siguiente.

La clase [System.Console] da acceso a las operaciones de escritura en pantalla ([Write], [WriteLine]). Tiene dos propiedades, [Out] y [Error], que son flujos de escritura de tipo [TextWriter]:

  • [Console.WriteLine()] equivale a [Console.Out.WriteLine()] y escribe en el flujo [Out], que normalmente está asociado a la pantalla;
  • [Console.Error.WriteLine()] escribe en el flujo [Error], que también suele estar asociado a la pantalla.

Los flujos [Out] y [Error] pueden redirigirse a archivos en tiempo de ejecución, como veremos en breve.

3.4.2. Lectura de datos escritos en el teclado

El flujo de datos del teclado está representado por el objeto [Console.In] de tipo [TextReader]. Este tipo de objeto permite leer una línea de texto con el método [ReadLine]:

string? line = Console.In.ReadLine();

La clase [Console] ofrece un método, [ReadLine], que está asociado de forma predeterminada al flujo [In]. Por lo tanto, se puede escribir:

string? line = Console.ReadLine();

La línea escrita en el teclado, sin el carácter de fin de línea, se almacena en la variable [line] y el programa puede procesarla a continuación. Como hemos visto, [ReadLine] devuelve [null] cuando se agota el flujo de entrada: por eso la variable es de tipo [string?]. El flujo [In] puede redirigirse a un archivo, igual que los flujos [Out] y [Error].

3.4.3. Ejemplo de entrada/salida

El programa [basics-09.cs] ilustra las operaciones de entrada y salida con teclado y pantalla:

// entrada-salida por teclado / pantalla

// escritura en el flujo Out
object obj = new object();
Console.Out.WriteLine(obj);

// escritura en el flujo Error
int i = 10;
Console.Error.WriteLine("i=" + i);
Console.Error.WriteLine("i={0}", i);

// lectura de una línea escrita en el teclado
Console.Write("Type a line: ");
string? line = Console.ReadLine();
Console.WriteLine($"line={line}");

Resultados:

1
2
3
4
5
6
> dotnet run basics-09.cs
System.Object
i=10
i=10
Type a line: here I am
line=here I am

Comentarios:

  • Línea 4: [obj] es una referencia a un objeto;
  • Línea 5: [obj] se muestra en la pantalla. Se llama al método [obj.ToString()] para obtener el texto que se mostrará;
  • línea 9: el texto se escribe en el flujo [Error];
  • línea 10: lo mismo, pero con un formato. El primer parámetro, "i={0}", es el formato de visualización; los demás parámetros son las expresiones que se mostrarán. Los elementos {n} son parámetros posicionales: en tiempo de ejecución, {n} se reemplaza por el valor de la n-ésima expresión;
  • líneas 13–14: se muestra un indicador sin salto de línea y luego se lee la línea escrita en el teclado;
  • línea 15: en una cadena interpolada, un valor como [null] produciría una cadena vacía: no se emite ninguna advertencia.

En los resultados:

  • línea 2: la salida generada por la línea 5 del código. El método *[obj.ToString()] mostró el nombre del tipo de la variable *[obj]*: *[System.Object]*. El tipo [object] es un alias de C# del tipo .NET [System.Object]*;
  • Líneas 3–4: las dos entradas del flujo [Error] aparecen en la pantalla igual que las del flujo [Out].

3.4.4. Redirección de entrada/salida

Windows, Linux y macOS reconocen tres dispositivos estándar:

  • el dispositivo de entrada estándar, que por defecto corresponde al teclado y lleva el número 0;
  • el dispositivo de salida estándar, que por defecto corresponde a la pantalla y lleva el número 1;
  • el dispositivo de error estándar, que por defecto está asignado a la pantalla y lleva el número 2.

En C#, el flujo de escritura [Console.Out] escribe en el dispositivo 1, el flujo de escritura [Console.Error] escribe en el dispositivo 2 y el flujo de lectura [Console.In] lee los datos del dispositivo 0.

Al ejecutar un programa en una ventana de comandos, se puede especificar qué dispositivos serán el 0, el 1 y el 2 para el programa en ejecución. Después de los argumentos del programa, se pueden redirigir los dispositivos estándar de entrada y salida a archivos:

Redirección
Significado
0<in.txt o <in.txt
El flujo de entrada estándar n.º 0 se redirige al archivo in.txt. En el programa, el flujo [Console.In] leerá, por tanto, sus datos del archivo in.txt
1>out.txt o >out.txt
redirige la salida n.º 1 al archivo out.txt. En el programa, el flujo [Console.Out] escribirá, por tanto, sus datos en el archivo out.txt
1>>out.txt o >>out.txt
Igual que lo anterior, pero los datos escritos se añaden al contenido actual del archivo out.txt
2>err.txt
redirige la salida n.º 2 al archivo err.txt. En el programa, el flujo [Console.Error] escribirá entonces sus datos en el archivo err.txt
2>>err.txt
Igual que lo anterior, pero los datos escritos se añaden al contenido actual del archivo err.txt
1>out.txt 2>err.txt
Los dispositivos 1 y 2 se redirigen ambos a archivos

Observe que, para redirigir los flujos de entrada/salida de un programa a archivos, no es necesario modificar el programa: es el sistema operativo el que determina la naturaleza de los dispositivos 0, 1 y 2. Considere el siguiente programa, [basics-10.cs]:

1
2
3
4
5
6
7
// redirecciones de los flujos de entrada-salida
// lectura del flujo In
string? data = Console.In.ReadLine();
// escritura en el flujo Out
Console.Out.WriteLine("writing to the Out stream : " + data);
// escritura en el flujo Error
Console.Error.WriteLine("writing to the Error stream : " + data);

El curso de 2008 generaba un ejecutable con Visual Studio y luego lo ejecutaba en una ventana de DOS. Hoy basta con el comando [dotnet run] : las redirecciones se aplican al programa lanzado. Esta es una sesión en un terminal de Linux (bash):

> echo test > in.txt
> cat in.txt
test
> dotnet run basics-10.cs < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the Out stream : test
> cat err.txt
writing to the Error stream : test
> dotnet run basics-10.cs < in.txt 2> err.txt
writing to the Out stream : test
> dotnet run basics-10.cs < in.txt > out.txt
writing to the Error stream : test

Comentarios:

  • línea 1: la cadena "test" se coloca en el archivo in.txt;
  • línea 2: se muestra el contenido del archivo in.txt para verificarlo;
  • línea 4: se ejecuta el programa. El flujo [In] se redirige al archivo in.txt, el flujo [Out] al archivo out.txt y el flujo [Error] al archivo err.txt. La ejecución no produce ninguna salida;
  • líneas 5–6: el contenido del archivo out.txt muestra que se leyó el archivo in.txt y que la escritura en el flujo [Out] se redirigió a out.txt;
  • líneas 7–8: verificación similar para el archivo err.txt;
  • líneas 9–10: solo se redirige el flujo [Error]: la pantalla muestra únicamente la operación de escritura en el flujo [Out];
  • líneas 11–12: solo se redirige el flujo [Out]: la pantalla muestra únicamente la operación de escritura en el flujo [Error].

Es evidente que los flujos [Out] y [Error] no escriben en los mismos dispositivos, ya que pudieron redirigirse por separado. El flujo [Error] está destinado a los mensajes de error: esto permite redirigir la salida de un programa a un archivo y seguir viendo sus mensajes de error en la pantalla.

Los operadores >, >> y 2> se escriben igual en el símbolo del sistema de Windows ([cmd]), en PowerShell y en bash. El operador < lo reconocen [cmd] y bash, pero no PowerShell, que lo reserva para un uso futuro: en PowerShell se usa una canalización (|) para enviar un archivo a la entrada estándar de un programa. Los siguientes comandos, dados a modo ilustrativo (no se ejecutaron para este curso), hacen en Windows lo que hace la sesión de bash anterior:

rem Windows command prompt (cmd)
echo test>in.txt
dotnet run basics-10.cs <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | dotnet run basics-10.cs > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

3.4.5. Asignación del valor de una expresión a una variable

Aquí nos interesa la operación [variable = expression;]. La expresión puede ser aritmética, relacional, booleana, de cadena, etc.

3.4.5.1. Interpretación de la operación de asignación

La operación [variable = expression;] es en sí misma una expresión que se evalúa de la siguiente manera:

  • se evalúa el lado derecho de la asignación: el resultado es un valor V;
  • el valor V se asigna a la variable;
  • el valor V es también el valor de la asignación, considerada ahora como una expresión.

Así, la operación [V1 = V2 = expression] es válida. Como el operador = se evalúa de derecha a izquierda, se obtiene [V1 = (V2 = expression)]. Se evalúa la expresión [V2 = expression] y esta tiene el valor V. Su evaluación provocó que V se asignara a V2. A continuación, el siguiente operador = se evalúa como [V1 = V]. El valor de esta expresión sigue siendo V; su evaluación hace que V se asigne a V1. Así, la operación [V1 = V2 = expression] es una expresión cuya evaluación:

  • hace que el valor de [expression] se asigne a las variables V1 y V2;
  • devuelve el valor de [expression].

Esto se puede generalizar a una expresión de la forma [V1 = V2 = ... = Vn = expression].

3.4.5.2. Expresiones aritméticas

Los operadores utilizados en las expresiones aritméticas son los siguientes:

Operador
Función
+
suma
-
resta
*
multiplicación
/
división: el resultado es el cociente exacto si al menos uno de los operandos es un número real. Si ambos operandos son enteros, el resultado es el cociente entero. Así, 5/2 es igual a 2 y 5.0/2 es igual a 2.5
%
resto de la división (módulo), sea cual sea la naturaleza de los operandos. El resto tiene el mismo signo que el dividendo: -5 % 2 es igual a -1

Existen diversas funciones matemáticas. Estas son algunas:

Función
Función
[double Sqrt(double x)]
raíz cuadrada
[double Cos(double x)], [Sin], [Tan]
coseno, seno, tangente (ángulo en radianes)
[double Pow(double x, double y)]
x elevado a la potencia y
[double Exp(double x)]
exponencial
[double Log(double x)], [Log10], [Log2]
logaritmo natural, logaritmo decimal, logaritmo en base 2
[Abs(x)], [Max(x, y)], [Min(x, y)]
valor absoluto, máximo, mínimo (para todos los tipos numéricos)
[Floor(x)], [Ceiling(x)], [Truncate(x)]
parte entera inferior, parte entera superior, truncamiento
[Round(x)], [Round(x, n)]
redondeo al entero más cercano, a n decimales
[Math.PI], [Math.E]
las constantes π y e

Todas estas funciones están definidas en una clase de .NET llamada Math. Al usarlas, hay que anteponerles el nombre de la clase en la que están definidas. Así, se escribiría:

double x, y = 4;
x = Math.Sqrt(y);

El curso de 2008 incluía aquí la definición completa de la clase [Math]: hoy se puede consultar en la documentación en línea de .NET, learn.microsoft.com/dotnet/api/system.math.

El programa [basics-11.cs] es el siguiente:

// expresiones aritméticas
// división entera y división real
Console.WriteLine($"5 / 2 = {5 / 2}, 5.0 / 2 = {5.0 / 2}, 5 / 2.0 = {5 / 2.0}");
// resto de la división (módulo)
Console.WriteLine($"5 % 2 = {5 % 2}, -5 % 2 = {-5 % 2}, 5.5 % 2 = {5.5 % 2}");
// división real entre cero: sin error, infinito o NaN (Not a Number)
double zero = 0;
Console.WriteLine($"1 / 0.0 = {1 / zero}, 0 / 0.0 = {0 / zero}");

// algunas funciones de la clase Math
double x, y = 4;
x = Math.Sqrt(y);
Console.WriteLine($"Math.Sqrt(4) = {x}");
Console.WriteLine($"Math.Pow(2, 10) = {Math.Pow(2, 10)}");
Console.WriteLine($"Math.Abs(-3.5) = {Math.Abs(-3.5)}, Math.Max(3, 7) = {Math.Max(3, 7)}");
Console.WriteLine($"Math.PI = {Math.PI}, Math.Cos(Math.PI) = {Math.Cos(Math.PI)}");
Console.WriteLine($"Math.Exp(1) = {Math.Exp(1)}, Math.Log(Math.E) = {Math.Log(Math.E)}");
Console.WriteLine($"Math.Floor(-2.5) = {Math.Floor(-2.5)}, Math.Ceiling(-2.5) = {Math.Ceiling(-2.5)}, Math.Truncate(-2.5) = {Math.Truncate(-2.5)}");
// por defecto Math.Round redondea al número par más cercano
Console.WriteLine($"Math.Round(2.5) = {Math.Round(2.5)}, Math.Round(3.5) = {Math.Round(3.5)}");
Console.WriteLine($"Math.Round(2.5, MidpointRounding.AwayFromZero) = {Math.Round(2.5, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"Math.Round(2.567, 2) = {Math.Round(2.567, 2)}");

// precedencia: * / % antes que + -
Console.WriteLine($"2 + 3 * 4 = {2 + 3 * 4}, (2 + 3) * 4 = {(2 + 3) * 4}, 10 - 4 - 3 = {10 - 4 - 3}");

// la asignación es una expresión: asignación múltiple
int v1, v2;
v1 = v2 = 7 * 6;
Console.WriteLine($"v1={v1}, v2={v2}");

Resultados:

> dotnet run basics-11.cs
5 / 2 = 2, 5.0 / 2 = 2,5, 5 / 2.0 = 2,5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1,5
1 / 0.0 = ∞, 0 / 0.0 = NaN
Math.Sqrt(4) = 2
Math.Pow(2, 10) = 1024
Math.Abs(-3.5) = 3,5, Math.Max(3, 7) = 7
Math.PI = 3,141592653589793, Math.Cos(Math.PI) = -1
Math.Exp(1) = 2,718281828459045, Math.Log(Math.E) = 1
Math.Floor(-2.5) = -3, Math.Ceiling(-2.5) = -2, Math.Truncate(-2.5) = -2
Math.Round(2.5) = 2, Math.Round(3.5) = 4
Math.Round(2.5, MidpointRounding.AwayFromZero) = 3
Math.Round(2.567, 2) = 2,57
2 + 3 * 4 = 14, (2 + 3) * 4 = 20, 10 - 4 - 3 = 3
v1=42, v2=42

Comentarios:

  • línea 3: la división de dos enteros es una división entera;
  • línea 5: el resto tiene el mismo signo que el dividendo; el operador % también se aplica a los números reales;
  • línea 8: dividir un número real entre cero no provoca un error; devuelve infinito (se muestra como ∞) o el valor especial NaN (“Not a Number”) para 0/0. En cambio, dividir un entero entre cero lanza una excepción [DivideByZeroException];
  • líneas 11–12: el ejemplo anterior;
  • línea 18: [Floor] redondea hacia abajo, [Ceiling] redondea hacia arriba y [Truncate] redondea hacia cero;
  • línea 20: por defecto, [Math.Round] redondea un valor que está exactamente a la mitad al número par más cercano (redondeo “bancario”): 2.5 pasa a 2 y 3.5 pasa a 4;
  • línea 21: para el método de redondeo que se enseña en la escuela (2.5 pasa a 3), se especifica el modo de redondeo;
  • línea 25: precedencia de los operadores, como se muestra a continuación;
  • línea 29: una asignación múltiple.

3.4.5.3. Orden de las operaciones en la evaluación de expresiones aritméticas

El orden de las operaciones al evaluar una expresión aritmética es el siguiente (de mayor a menor prioridad):

[functions], [( )], [*, /, %], [+, -]

Los operadores dentro de un mismo bloque [ ] tienen la misma precedencia. Cuando la precedencia es igual, la evaluación se realiza de izquierda a derecha: 10 - 4 - 3 se evalúa como (10 - 4) - 3 = 3.

3.4.5.4. Expresiones relacionales

Los operadores son los siguientes: <, <=, ==, !=, >, >=. Su precedencia es:

  • >, >=, <, <=;
  • ==, !=.

El resultado de una expresión relacional es el valor booleano [false] si la expresión es falsa y [true] en caso contrario.

1
2
3
bool end;
int x = 5;
end = x > 4;

Comparación de dos caracteres

Sean C1 y C2 dos caracteres. Se pueden comparar mediante los operadores <, <=, ==, !=, >, >=. En este caso, lo que se compara son sus códigos Unicode, que son números. Según el orden de Unicode, se cumplen las siguientes relaciones:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

Comparación de dos cadenas

Se comparan carácter por carácter. La primera desigualdad encontrada entre dos caracteres produce una desigualdad en el mismo sentido entre las cadenas. Consideremos la comparación de las cadenas "Cart" y "Cat":

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

Esta última desigualdad permite concluir que "Cart" < "Cat". Consideremos ahora la comparación de las cadenas "Cat" y "Catkin". Son iguales hasta que se agota la cadena "Cat". En este caso, la cadena agotada se declara la "menor". Por lo tanto, se cumple la relación "Cat" < "Catkin."

Funciones para comparar dos cadenas

Se pueden usar los operadores relacionales == y != para comprobar si dos cadenas son iguales, o el método [Equals] de la clase [System.String]. Para las relaciones <, <=, > y >=, los operadores no se aplican a las cadenas: hay que usar el método [CompareTo] de la clase [System.String] o el método estático [string.Compare]. Estos devuelven un entero:

  • cero si las dos cadenas son iguales;
  • positivo si la cadena n.º 1 es mayor que la cadena n.º 2;
  • negativo si la cadena n.º 1 es menor que la cadena n.º 2.

Hay una sutileza: [CompareTo] y [string.Compare] no se limitan a comparar códigos Unicode. Siguen las reglas de ordenación de la cultura actual, como en un diccionario: en francés, “élan” va antes que “face”, aunque el código de ‘é’ (233) sea mayor que el de ‘f’ (102). Para elegir el modo de comparación, [string.Compare] y [Equals] aceptan un parámetro de tipo [StringComparison]:

  • [StringComparison.Ordinal]: comparación carácter por carácter de los códigos Unicode. Es la comparación más rápida y debe usarse para identificadores, palabras clave y nombres de archivo;
  • [StringComparison.OrdinalIgnoreCase]: igual que la anterior, pero ignorando las mayúsculas y minúsculas;
  • [StringComparison.CurrentCulture] (el valor predeterminado de [CompareTo]): sigue las convenciones culturales habituales para ordenar texto destinado a los usuarios.

El operador == y el método [Equals] sin parámetros realizan una comparación ordinal.

El programa [basics-12.cs] es el siguiente:

// expresiones relacionales y comparación de cadenas
int x = 5;
bool end = x > 4;
Console.WriteLine($"x > 4 : {end}, x == 5 : {x == 5}, x != 5 : {x != 5}");

// comparación de caracteres: se comparan sus códigos Unicode
Console.WriteLine($"'a' < 'b' : {'a' < 'b'}, 'Z' < 'a' : {'Z' < 'a'}, '9' < 'A' : {'9' < 'A'}");
Console.WriteLine($"codes : 'A'={(int)'A'}, 'a'={(int)'a'}, 'é'={(int)'é'}");

// comparación de cadenas
string string1 = "cat", string2 = "dog";
int n = string1.CompareTo(string2);
bool equal = string1.Equals(string2);
Console.WriteLine($"n={n}, equal={equal}");
Console.WriteLine($"\"dog\"==string1 : {"dog" == string1}, \"dog\"!=string2 : {"dog" != string2}");
Console.WriteLine($"\"Cat\".CompareTo(\"Catkin\") : {"Cat".CompareTo("Catkin")}");

// CompareTo y string.Compare siguen las reglas de la cultura actual (fr-FR)
Console.WriteLine($"\"élan\".CompareTo(\"face\") : {"élan".CompareTo("face")}");
Console.WriteLine($"string.Compare(\"Cat\", \"cat\") : {string.Compare("Cat", "cat")}");
// StringComparison.Ordinal: comparación de los códigos Unicode, carácter por carácter
Console.WriteLine($"Ordinal(\"élan\", \"face\") : {string.Compare("élan", "face", StringComparison.Ordinal)}");
Console.WriteLine($"Ordinal(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.Ordinal)}");
// sin distinguir mayúsculas y minúsculas
Console.WriteLine($"OrdinalIgnoreCase(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.OrdinalIgnoreCase)}");
Console.WriteLine($"\"Cat\".Equals(\"cat\") : {"Cat".Equals("cat")}");
Console.WriteLine($"\"Cat\".Equals(\"cat\", OrdinalIgnoreCase) : {"Cat".Equals("cat", StringComparison.OrdinalIgnoreCase)}");

Resultados:

> dotnet run basics-12.cs
x > 4 : True, x == 5 : True, x != 5 : False
'a' < 'b' : True, 'Z' < 'a' : True, '9' < 'A' : True
codes : 'A'=65, 'a'=97, 'é'=233
n=-1, equal=False
"dog"==string1 : False, "dog"!=string2 : False
"Cat".CompareTo("Catkin") : -1
"élan".CompareTo("face") : -1
string.Compare("Cat", "cat") : 1
Ordinal("élan", "face") : 131
Ordinal("Cat", "cat") : -32
OrdinalIgnoreCase("Cat", "cat") : 0
"Cat".Equals("cat") : False
"Cat".Equals("cat", OrdinalIgnoreCase) : True

Comentarios:

  • línea 3: una expresión relacional;
  • línea 7: comparación de caracteres;
  • línea 8: la conversión [(int)] de un carácter devuelve su código Unicode;
  • línea 12: a la variable [n] se le asigna un entero negativo porque "cat" < "dog";
  • línea 13: la variable [equal] tiene el valor [true] si las dos cadenas son iguales y [false] en caso contrario;
  • Línea 15: los operadores == y != se usan para comprobar si dos cadenas son iguales. En una interpolación de cadenas, \" representa unas comillas;
  • línea 16: la cadena que se agota primero es la más corta;
  • Líneas 19–20: comparaciones basadas en las convenciones del francés: “élan” va antes que “face”, y “Cat” va después de “cat” (cuando el número de letras es el mismo, las minúsculas van antes que las mayúsculas);
  • líneas 22–23: comparaciones ordinales: el resultado es aquí la diferencia entre los códigos de los primeros caracteres distintos: 233 – 102 = 131 y 67 – 99 = –32;
  • líneas 25–27: cuando se ignora la distinción entre mayúsculas y minúsculas, “Cat” y “cat” son iguales.

3.4.5.5. Expresiones booleanas

Los operadores que se pueden utilizar son AND (&&), OR (||) y NOT (!). El resultado de una expresión booleana es un valor booleano. Precedencia de los operadores:

  • ! ;
  • && ;
  • ||.
double x = 3.5;
bool valid = x > 2 && x < 4;

Los operadores relacionales tienen mayor precedencia que los operadores && y ||. Estos dos operadores evalúan su operando derecho solo si es necesario: en [a && b], b no se evalúa si a es falso; en [a || b], b no se evalúa si a es verdadero. Esto se denomina “evaluación en cortocircuito”. Por lo tanto, es seguro escribir [text != null && text.Length > 0].

3.4.5.6. Operaciones bit a bit

Sean [i] y [j] dos enteros:

Operación
Función
i << n
Desplaza i n bits a la izquierda. Los bits que entran son ceros
i >> n
Desplaza i n bits a la derecha. Si i es un entero con signo ([sbyte], [short], [int], [long]), se conserva el bit de signo
i >>> n
desplazamiento a la derecha sin signo (C# 11): los bits que entran son ceros, aunque i tenga signo
i & j
realiza el AND lógico bit a bit de i y j
i | j
realiza el OR lógico bit a bit de i y j
~i
complementa i a 1
i ^ j
realiza la operación OR EXCLUSIVO entre i y j bit a bit

El programa [basics-13.cs] es el siguiente:

// manipulación de bits
short i = 100, j = -13;
ushort k = 0xF123;
Console.WriteLine("i=0x{0:x4}, j=0x{1:x4}, k=0x{2:x4}", i, j, k);
Console.WriteLine("i<<4=0x{0:x4}, i>>4=0x{1:x4}, k>>4=0x{2:x4}", i << 4, i >> 4, k >> 4);
Console.WriteLine("i&j=0x{0:x4}, i|j=0x{1:x4}, i^j=0x{2:x4}, ~i=0x{3:x4}",
    (short)(i & j), (short)(i | j), (short)(i ^ j), (short)~i);
Console.WriteLine("j<<2=0x{0:x4}, j>>2=0x{1:x4}", (short)(j << 2), (short)(j >> 2));
// los mismos valores en binario (formato B, .NET 8)
Console.WriteLine($"i={i:B16}, j={j:B16}, i&j={(short)(i & j):B16}");
// desplazamiento a la derecha sin signo >>> (C# 11): los bits que entran son ceros
int m = -16;
Console.WriteLine($"m={m:B32}, m>>2={m >> 2:B32}, m>>>2={m >>> 2:B32}");

Resultados:

1
2
3
4
5
6
7
> dotnet run basics-13.cs
i=0x0064, j=0xfff3, k=0xf123
i<<4=0x0640, i>>4=0x0006, k>>4=0x0f12
i&j=0x0060, i|j=0xfff7, i^j=0xff97, ~i=0xff9b
j<<2=0xffcc, j>>2=0xfffc
i=0000000001100100, j=1111111111110011, i&j=0000000001100000
m=11111111111111111111111111110000, m>>2=11111111111111111111111111111100, m>>>2=00111111111111111111111111111100

Comentarios:

  • línea 4: el formato {0:x4} muestra el parámetro n.º 0 en hexadecimal (x) con 4 dígitos (4);
  • línea 7: las operaciones sobre los bits de un [short] dan como resultado un [int]; estos se vuelven a convertir en [short] para mostrar 4 dígitos hexadecimales. Sin la conversión, ~i se mostraría con 8 dígitos (ffffff9b);
  • línea 10: el formato B16 muestra un entero binario de 16 dígitos. Se verifica, bit a bit, el AND lógico de i y j;
  • línea 13: el desplazamiento [>>] conserva el bit de signo de m, que es negativo; el desplazamiento [>>>] rellena con ceros.

3.4.5.7. Combinación de operadores

[a = a + b] se puede escribir como [a += b]; [a = a - b] se puede escribir como [a -= b]. Lo mismo se aplica a los operadores /, %, *, <<, >>, >>>, &, |, ^. Así, [a = a / 2;] se puede escribir como [a /= 2;].

3.4.5.8. Operadores de incremento y decremento

La notación [variable++] significa [variable = variable + 1] o [variable += 1]. La notación [variable--] significa [variable = variable - 1] o [variable -= 1]. Cuando se usan en una expresión, estos operadores tienen dos formas:

  • [i++] (posfija): el valor de la expresión es el valor de i antes del incremento;
  • [++i] (prefija): el valor de la expresión es el valor de i después del incremento.

3.4.5.9. El operador ternario ?:

La expresión [expr_cond ? expr1 : expr2] se evalúa de la siguiente manera:

  • Se evalúa la expresión [expr_cond] . Esta es una expresión booleana;
  • si es verdadera, el valor de la expresión es el de [expr1] y [expr2] no se evalúa;
  • si es falsa, ocurre lo contrario: el valor de la expresión es el de [expr2] y [expr1] no se evalúa.

La operación [i = (j > 4 ? j + 1 : j - 1);] asignará j+1 a la variable i si j > 4, y j-1 en caso contrario. Es lo mismo que escribir [if (j > 4) i = j + 1; else i = j - 1;], pero más conciso.

3.4.5.10. Los operadores ??, ??= y ?.

Estos operadores facilitan el trabajo con valores [null]:

  • [a ?? b] (C# 2) se evalúa como a si a no es igual a [null], y como b en caso contrario. Se utiliza para proporcionar un valor de reserva: [string name = Console.ReadLine() ?? "";]. El resultado ya no admite valores nulos;
  • [a ??= b] (C# 8) asigna b a a solo si a es igual a [null];
  • [a?.Member] (C# 6) es [null] si a es [null] y, en caso contrario, [a.Member]. Así, [text?.Length] no provoca un error cuando [text] es igual a [null]; el resultado es de tipo [int?].

El programa [basics-14.cs] combina estos distintos operadores:

// otros operadores
// expresiones booleanas
double x = 3.5;
bool valid = x > 2 && x < 4;
Console.WriteLine($"valid={valid}, !valid={!valid}, valid || x > 10 : {valid || x > 10}");

// operadores compuestos
int a = 10;
a += 5;
Console.Write($"a += 5 : {a}");
a *= 2;
Console.Write($", a *= 2 : {a}");
a /= 4;
Console.Write($", a /= 4 : {a}");
a %= 4;
Console.Write($", a %= 4 : {a}");
a <<= 2;
Console.WriteLine($", a <<= 2 : {a}");

// incremento y decremento
int i = 5;
int j = i++;    // j recibe el valor anterior de i, luego i se incrementa
int k = ++i;    // i se incrementa, luego k recibe el nuevo valor de i
Console.WriteLine($"i={i}, j={j}, k={k}");
i--;
Console.WriteLine($"i={i}");

// operador ternario
int n = 5;
int p = n > 4 ? n + 1 : n - 1;
string parity = n % 2 == 0 ? "even" : "odd";
Console.WriteLine($"p={p}, {n} is {parity}");

// operador ??: valor de reemplazo si el operando izquierdo es null
string? input = null;
string name = input ?? "unknown";
int? age = null;
int displayedAge = age ?? -1;
Console.WriteLine($"name={name}, displayedAge={displayedAge}");
// operador ??=: asignación solo si la variable es null
string? title = null;
title ??= "Untitled";
title ??= "Other title";
Console.WriteLine($"title={title}");
// operador ?.: acceso a un miembro solo si el objeto no es null
string? text = null;
int? length = text?.Length;
Console.WriteLine($"length={length?.ToString() ?? "null"}");
text = "hello";
Console.WriteLine($"length={text?.Length}");

Resultados:

> dotnet run basics-14.cs
valid=True, !valid=False, valid || x > 10 : True
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a <<= 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=5

Comentarios:

  • línea 4: una expresión booleana;
  • líneas 9–17: operadores combinados: 10+5=15, 15*2=30, 30/4=7 (división entera), 7%4=3, 3<<2=12;
  • línea 22: a [j] se le asigna 5 y luego [i] pasa a valer 6;
  • línea 23: [i] pasa a 7 y luego [k] recibe 7;
  • líneas 30–31: dos operadores ternarios;
  • línea 36: [input] es igual a [null]: [name] recibe "unknown". El tipo de [name] es [string], no [string?];
  • línea 38: el operador ?? permite convertir un [int?] en un [int] sin riesgo de excepción;
  • Líneas 42–43: la primera asignación se realiza porque [title] es igual a [null]; la segunda asignación no se realiza;
  • línea 47: [text] es igual a [null], por lo que [length] también lo es;
  • línea 48: se combinan los operadores: si [length] es igual a [null], se muestra la cadena "null".

3.4.5.11. Precedencia general de los operadores

La siguiente tabla enumera la precedencia de los operadores, de mayor a menor:

Operadores
Asociatividad
[x.y] [x?.y] [f(x)] [a[i]] [x++] [x--] [new] [typeof] [checked] [nameof]
lr
[+x] [-x] [!x] [~x] [++x] [--x] [^x] [(T)x] (cambio de tipo)
rl
[x..y] (rango)
lr
[switch] (expresión switch)
lr
[*] [/] [%]
lr
[+] [-]
lr
[<<] [>>] [>>>]
lr
[<] [<=] [>] [>=] [is] [as]
lr
[==] [!=]
lr
[&]
lr
[^]
lr
[|]
lr
[&&]
lr
[||]
lr
[??]
rl
[? :] (ternario)
rl
[=] [+=] [-=] [??=] etc., [=>]
rl

lr indica que, cuando los operadores tienen la misma precedencia, se aplica la asociatividad de izquierda a derecha: cuando una expresión contiene operadores de igual precedencia, se evalúa primero el operador situado más a la izquierda. rl indica la asociatividad de derecha a izquierda. En caso de duda, no dude en usar paréntesis: también hacen la expresión más legible.

3.4.5.12. Conversión de tipos

En una expresión, es posible cambiar temporalmente la representación de un valor. Esto se denomina “conversión de tipos” (type casting). La sintaxis para cambiar el tipo de un valor en una expresión es la siguiente:

(type) value

El valor adopta entonces el tipo especificado. Esto produce un cambio en la representación del valor. Se distinguen:

  • Las conversiones implícitas, que realiza automáticamente el compilador cuando no implican ninguna pérdida de información: de un [int] a un [long], de un [int] a un [double], de un [char] a un [int], etc. La conversión de un [long] a un [double] también es implícita, aunque puede perder precisión más allá de 2⁵³;
  • Las conversiones explícitas, que pueden producir una pérdida de información y que el programador debe solicitar explícitamente mediante la notación (tipo): de un [double] a un [int] (se pierde la parte decimal), de un [long] a un [int] (se pierden los bits más significativos), etc.

De manera predeterminada, un desbordamiento en un cálculo con enteros o en una conversión de enteros no se notifica: el resultado simplemente es incorrecto. En cambio, la palabra clave [checked], hace que un desbordamiento lance una excepción [OverflowException]. Se aplica a una expresión, [checked(expression)], o a un bloque de instrucciones, [checked { ... }].

El programa [basics-15.cs] es el siguiente:

// cambios de tipo
int i = 3, j = 4;
float f1 = i / j;
float f2 = (float)i / j;
Console.WriteLine($"f1={f1}, f2={f2}");

// conversiones implícitas: sin pérdida de información
long l = i;
double d = l;
Console.WriteLine($"l={l}, d={d}");

// conversiones explícitas (cast): posible pérdida de información
double real = 3.99;
int truncated = (int)real;
int rounded = (int)Math.Round(real);
Console.WriteLine($"(int)3.99={truncated}, (int)Math.Round(3.99)={rounded}");
long large = 3_000_000_000;
int overflowed = (int)large;
Console.WriteLine($"(int)3000000000={overflowed}");

// caracteres y enteros
char c = (char)65;
int code = 'é';
Console.WriteLine($"(char)65={c}, code of 'é'={code}");

// desbordamiento: silencioso por defecto
int max = int.MaxValue;
int next = max + 1;
Console.WriteLine($"int.MaxValue + 1 = {next}");
// checked: el desbordamiento provoca una excepción
try
{
    int verified = checked(max + 1);
    Console.WriteLine($"verified={verified}");
}
catch (OverflowException e)
{
    Console.WriteLine($"checked(max + 1) : {e.GetType().Name} - {e.Message}");
}
try
{
    checked
    {
        int conversion = (int)large;
        Console.WriteLine($"conversion={conversion}");
    }
}
catch (OverflowException e)
{
    Console.WriteLine($"checked((int)large) : {e.GetType().Name} - {e.Message}");
}

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run basics-15.cs
f1=0, f2=0,75
l=3, d=3
(int)3.99=3, (int)Math.Round(3.99)=4
(int)3000000000=-1294967296
(char)65=A, code of 'é'=233
int.MaxValue + 1 = -2147483648
checked(max + 1) : OverflowException - Arithmetic operation resulted in an overflow.
checked((int)large) : OverflowException - Arithmetic operation resulted in an overflow.

Comentarios:

  • Línea 3: [f1] tendrá el valor 0. La división 3/4 es una división entera, ya que ambos operandos son de tipo [int]; su resultado, 0, se convierte luego a [float];
  • Línea 4: [(float)i] es el valor de [i] convertido a [float]. Ahora tenemos una división entre un número real de tipo [float] y un entero de tipo [int]: el valor de [j] también se transforma en [float] y luego se dividen los dos números reales. [f2] tiene un valor de 0.75. En la operación [(float)i], [i] es un valor codificado de manera exacta como un número de 4 bytes, mientras que [(float)i] es el mismo valor codificado como un número real aproximado de 4 bytes. Esta transcodificación solo se produce durante el cálculo: la variable [i] conserva siempre su tipo [int];
  • líneas 8–9: conversiones implícitas;
  • línea 14: convertir un número de punto flotante en un entero trunca la parte decimal;
  • línea 15: para redondear, se usa [Math.Round], que produce un [double], y luego se convierte;
  • línea 18: 3000 millones no caben en un [int]: solo se conservan los 32 bits menos significativos y el resultado deja de tener sentido;
  • Líneas 22–23: conversiones entre caracteres y códigos Unicode; la segunda es implícita;
  • línea 28: el desbordamiento de capacidad pasa inadvertido: se obtiene el menor [int] posible;
  • línea 33: con [checked], el desbordamiento lanza una excepción [OverflowException];
  • líneas 42–45: un bloque [checked]: la conversión de [large] a [int] también lanza una excepción.

Si el desbordamiento ocurre en una expresión compuesta únicamente por constantes, como [int.MaxValue + 1], el compilador lo detecta y rechaza el programa.

3.5. Instrucciones de control de flujo del programa

3.5.1. Detención

El método [Exit] de la clase [Environment] permite detener la ejecución de un programa:

Environment.Exit(int status);

[Exit] finaliza el proceso actual y devuelve el control al proceso que lo llamó, que normalmente es el intérprete de comandos. El valor de [status], conocido como código de retorno, puede ser utilizado por el intérprete de comandos. Por convención, 0 indica que el programa terminó correctamente, mientras que cualquier otro valor indica un error. En Windows, el código de retorno está disponible en la variable [%ERRORLEVEL%] en el símbolo del sistema y en la variable [$LASTEXITCODE] dentro de PowerShell; en Linux y macOS, está disponible en la variable [$?] del shell. Así:

Environment.Exit(0);

terminará el programa con un código de retorno 0. Con las instrucciones de nivel superior, una instrucción [return] también termina el programa (código de retorno 0), a menos que se encuentre dentro de una función.

El programa [basics-16.cs] recibe su código de retorno como argumento:

// detención del programa con un código de salida
Console.WriteLine("Start of the program");
// el código de salida se pasa como argumento (ver la sección sobre los argumentos del programa)
if (args.Length == 0 || !int.TryParse(args[0], out int code))
{
    Console.Error.WriteLine("Syntax : dotnet run basics-16.cs -- exit_code");
    Environment.Exit(1);
    return;
}
Console.WriteLine($"Stopping with exit code {code}");
Environment.Exit(code);
Console.WriteLine("This line is never executed");

Resultados en un terminal bash:

> dotnet run basics-16.cs -- 3
Start of the program
Stopping with exit code 3
> echo $?
3
> dotnet run basics-16.cs
Start of the program
Syntax : dotnet run basics-16.cs -- exit_code
> echo $?
1

Comentarios:

  • línea 4: se verifica que se haya pasado un argumento y que sea un entero. Los argumentos del programa se describen más adelante;
  • línea 7: si no es así, el programa termina con un código de retorno 1;
  • línea 8: esta instrucción nunca se ejecutará, pero el compilador no sabe que [Environment.Exit] nunca devuelve el control. Sin ella, el compilador supondría que se podría llegar a la línea siguiente con una variable [code] sin inicializar y rechazaría el programa;
  • línea 11: termina con el código de retorno pasado como argumento. La línea siguiente no se ejecuta;
  • líneas 4–9: el comando [echo $?] muestra el código de retorno del último programa ejecutado: 3 y luego 1.

3.5.2. Estructura de decisión simple

1
2
3
4
5
6
7
8
if (condition)
{
    actions_condition_true;
}
else
{
    actions_condition_false;
}

Notas:

  • la condición va entre paréntesis;
  • cada acción termina con un punto y coma;
  • las llaves no van seguidas de un punto y coma;
  • las llaves solo son obligatorias si hay más de una acción; sin embargo, a menudo se incluyen incluso para una sola acción, para mejorar la legibilidad y evitar errores al agregar una acción;
  • la cláusula [else] puede omitirse;
  • no existe la palabra clave [then].

El equivalente algorítmico de esta estructura es la estructura si...entonces...si no:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

Ejemplo:

if (x > 0) { nx = nx + 1; sx = sx + x; } else dx = dx - x;

Las estructuras de elección pueden anidarse. Esto lleva a veces al problema que ilustra el programa [basics-17.cs]:

// estructura de decisión simple if
int n = 5;
// un else siempre pertenece al if más cercano
if (n > 1)
    if (n > 6)
        Console.WriteLine(">6");
    else
        Console.WriteLine("<=6");

// con llaves, el else se asocia al primer if
int n2 = 0;
if (n2 > 1)
{
    if (n2 > 6)
    {
        Console.WriteLine(">6");
    }
}
else
{
    Console.WriteLine("<=1");
}

// una secuencia de decisiones: else if
int grade = 13;
string honours;
if (grade < 10)
{
    honours = "failed";
}
else if (grade < 12)
{
    honours = "pass";
}
else if (grade < 14)
{
    honours = "fairly good";
}
else
{
    honours = "good";
}
Console.WriteLine($"grade={grade}, honours={honours}");

Resultados:

1
2
3
4
> dotnet run basics-17.cs
<=6
<=1
grade=13, honours=fairly good

Comentarios:

  • Líneas 4–8: ¿a qué [if] se refiere el [else] de la línea 7? La regla es que un [else] siempre se refiere al [if] más cercano: [if (n > 6)], línea 5. La sangría del código, que no tiene ningún efecto en el compilador, se eligió para ilustrarlo;
  • líneas 12–21: aquí se quería colocar un [else] junto a [if (n2 > 1)], y no un [else] junto a [if (n2 > 6)]. Debido a la regla anterior, es necesario encerrar [if (n2 > 1) { ... }] entre llaves;
  • líneas 27–41: una secuencia de elecciones mutuamente excluyentes se escribe mediante [else if] sucesivos. Las condiciones se evalúan en orden; la primera condición verdadera determina la acción que se ejecutará.

3.5.3. Estructura de casos

3.5.3.1. La instrucción switch

La sintaxis es la siguiente:

switch (expression)
{
    case v1:
        actions1;
        break;
    case v2:
        actions2;
        break;
    ...
    default:
        actions_otherwise;
        break;
}

Notas:

  • El valor de la expresión de control en [switch] puede ser un entero, un carácter, una cadena de caracteres, un valor de enumeración, etc.;
  • la expresión de control va entre paréntesis;
  • la cláusula [default] puede estar ausente;
  • los valores vi son valores posibles de la expresión. Si la expresión se evalúa como vi, se ejecutan las acciones que siguen a la cláusula [case vi] ;
  • la instrucción [break] sale de la estructura de casos;
  • Cada bloque de instrucciones asociado a un valor vi debe terminar con una instrucción de salto ([break], [return], [throw], ...); de lo contrario, el compilador informa un error. Sin embargo, varias cláusulas [case] pueden sucederse sin instrucciones entre ellas: en ese caso, comparten las mismas acciones.

Ejemplo en algoritmia:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

3.5.3.2. La expresión switch

Muy a menudo, una estructura de casos se usa únicamente para seleccionar un valor. C# 8 introdujo la expresión switch con este fin:

1
2
3
4
5
6
7
result = expression switch
{
    pattern1 => value1,
    pattern2 => value2,
    ...
    _ => value_otherwise
};

La expresión se compara sucesivamente con los patrones; el valor asociado al primer patrón que coincide es el resultado. El patrón \_ coincide con todos los valores: actúa como un comodín. Un patrón puede ser:

  • una constante: [0], ["saturday"];
  • un patrón relacional (C# 9): [< 0], [>= 18];
  • una combinación de patrones con [and], [or], y [not] (C# 9): [> 0 and <= 10], ["saturday" or "sunday"].

Estos mismos patrones se usan con el operador [is]: [day is "saturday" or "sunday"] es verdadero si [day] es "saturday" o "sunday". Veremos otras formas de estos patrones en los capítulos siguientes.

El programa [basics-18.cs] es el siguiente:

// estructura de casos: instrucción switch y expresión switch
int choice = 2;
bool error = false;
switch (choice)
{
    case 0:
        return;
    case 1:
        M1();
        break;
    case 2:
        M2();
        break;
    default:
        error = true;
        break;
}
Console.WriteLine($"error={error}");

// varios valores para el mismo case, expresión de tipo string
string day = "saturday";
switch (day)
{
    case "saturday":
    case "sunday":
        Console.WriteLine($"{day} : weekend");
        break;
    default:
        Console.WriteLine($"{day} : weekday");
        break;
}

// expresión switch (C# 8): devuelve un valor
string dayType = day switch
{
    "saturday" or "sunday" => "weekend",
    "monday" or "tuesday" or "wednesday" or "thursday" or "friday" => "weekday",
    _ => "unknown day"
};
Console.WriteLine($"{day} : {dayType}");

// patrones relacionales (<, <=, >, >=) y patrones lógicos (and, or, not) (C# 9)
Console.WriteLine($"-5 : {Classify(-5)}");
Console.WriteLine($"0 : {Classify(0)}");
Console.WriteLine($"7 : {Classify(7)}");
Console.WriteLine($"42 : {Classify(42)}");
Console.WriteLine($"1000 : {Classify(1000)}");
// el patrón not
bool workingDay = day is not ("saturday" or "sunday");
Console.WriteLine($"{day} working day : {workingDay}");

// funciones locales usadas arriba
static void M1()
{
    Console.WriteLine("M1");
}

static void M2()
{
    Console.WriteLine("M2");
}

static string Classify(int n) => n switch
{
    < 0 => "negative",
    0 => "zero",
    > 0 and <= 10 => "small",
    > 10 and < 100 => "medium",
    _ => "large"
};

Resultados:

> dotnet run basics-18.cs
M2
error=False
saturday : weekend
saturday : weekend
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
saturday working day : False

Comentarios:

  • líneas 4–15: la implementación en C# del algoritmo anterior;
  • línea 7: en las instrucciones de nivel superior, [return] termina el programa;
  • líneas 24–25: dos valores para las mismas acciones;
  • líneas 34–38: una expresión switch sobre una cadena. Los patrones se combinan con [or];
  • línea 49: el patrón [not] con el operador [is];
  • líneas 53–60: dos funciones locales;
  • líneas 63–69: una función local cuyo cuerpo es una expresión switch. La notación => reemplaza el cuerpo encerrado entre llaves y la instrucción [return]; esto se denomina cuerpo de expresión. Los patrones relacionales clasifican el entero [n].

3.5.4. Estructuras de repetición

3.5.4.1. Número conocido de repeticiones

Estructura for

La sintaxis es la siguiente:

1
2
3
4
for (i = id; i <= if; i = i + ip)
{
    actions;
}

Notas:

  • Los tres argumentos de [for] van entre paréntesis y separados por punto y coma;
  • Cada acción de [for] termina con un punto y coma;
  • las llaves solo son obligatorias si hay más de una acción;
  • la llave no va seguida de un punto y coma.

El equivalente algorítmico es la estructura para:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

que puede traducirse a una estructura mientras:

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

Estructura foreach

La sintaxis es la siguiente:

1
2
3
4
foreach (Type variable in collection)
{
    instructions;
}

Notas:

  • [collection] es una colección enumerable de objetos. La colección enumerable que ya conocemos es el arreglo; veremos otras ([List<T>], [Dictionary<K, V>], ...) en el capítulo 5;
  • [Type] es el tipo de los objetos de la colección. Para un arreglo, sería el tipo de los elementos del arreglo. Se puede escribir [var] en su lugar;
  • [variable] es una variable local del bucle que tomará sucesivamente todos los valores de la colección. No se puede modificar dentro del bucle.

3.5.4.2. Número desconocido de iteraciones

Bucle while

1
2
3
4
while (condition)
{
    actions;
}

El bucle continúa mientras la condición sea verdadera. Es posible que el bucle nunca se ejecute. Las notas son las mismas que para [for]. La estructura algorítmica correspondiente es la estructura mientras:

1
2
3
while condition
    actions
endwhile

Bucle “do while”

La sintaxis es la siguiente:

1
2
3
4
do
{
    instructions;
} while (condition);

El bucle continúa hasta que la condición se vuelve falsa. Aquí, el bucle se ejecuta al menos una vez. La estructura algorítmica correspondiente es la estructura “repetir … hasta que”:

1
2
3
repeat
    actions
until not condition

Estructura general de bucle (for)

La sintaxis es la siguiente:

1
2
3
4
for (start_instructions; condition; end_of_loop_instructions)
{
    instructions;
}

El bucle continúa mientras la condición sea verdadera (se evalúa antes de cada iteración). Las instrucciones [start_instructions] se ejecutan antes de entrar en el bucle por primera vez. Las instrucciones [end_of_loop_instructions] se ejecutan después de cada iteración del bucle. Las distintas instrucciones de [start_instructions] y de [end_of_loop_instructions] se separan con comas. La estructura algorítmica correspondiente es la siguiente:

1
2
3
4
5
start_instructions
while condition
    actions
    end_of_loop_instructions
endwhile

3.5.4.3. Instrucciones de control de bucles

Instrucción
Función
[break]
Sale del bucle [for], [foreach], [while], [do ... while]
[continue]
pasa a la siguiente iteración de los bucles [for], [foreach], [while], [do ... while]

3.5.4.4. Ejemplos

El programa [basics-19.cs] es el siguiente:

// estructuras de repetición
// cuatro formas de calcular la suma de los 10 primeros enteros
int i, sum, n = 10;
for (i = 1, sum = 0; i <= n; i = i + 1)
{
    sum = sum + i;
}
Console.WriteLine($"for (1) : sum={sum}");

for (i = 1, sum = 0; i <= n; sum = sum + i, i = i + 1)
{
}
Console.WriteLine($"for (2) : sum={sum}");

i = 1;
sum = 0;
while (i <= n)
{
    sum += i;
    i++;
}
Console.WriteLine($"while : sum={sum}");

i = 1;
sum = 0;
do
{
    sum += i++;
} while (i <= n);
Console.WriteLine($"do while : sum={sum}");

// la variable de bucle se puede declarar en el for: solo existe dentro del bucle
int product = 1;
for (int k = 1; k <= 5; k++)
{
    product *= k;
}
Console.WriteLine($"5! = {product}");

// foreach: recorrido de todos los elementos de una colección
string[] friends = ["paul", "hélène", "jacques", "sylvie"];
foreach (string name in friends)
{
    Console.WriteLine(name);
}

// break y continue
for (int k = 1; k <= 10; k++)
{
    // los números pares se omiten
    if (k % 2 == 0)
    {
        continue;
    }
    // nos detenemos después del 7
    if (k > 7)
    {
        break;
    }
    Console.Write($"{k} ");
}
Console.WriteLine();

// bucle infinito del que se sale con break: el primer múltiplo de 7 mayor que 50
int multiple = 50;
while (true)
{
    multiple++;
    if (multiple % 7 == 0)
    {
        break;
    }
}
Console.WriteLine($"first multiple of 7 greater than 50 : {multiple}");

Resultados:

> dotnet run basics-19.cs
for (1) : sum=55
for (2) : sum=55
while : sum=55
do while : sum=55
5! = 120
paul
hélène
jacques
sylvie
1 3 5 7 
first multiple of 7 greater than 50 : 56

Comentarios:

  • líneas 3–30: cuatro maneras de calcular la suma de los primeros 10 enteros;
  • líneas 4–8: un [for] clásico;
  • líneas 10–13: todo el trabajo se realiza en las instrucciones de fin de bucle; el cuerpo del bucle está vacío. El curso de 2008 usaba [for (...) ;]: C# acepta esta instrucción vacía, pero el compilador emite una advertencia (“possible invalid empty statement”), porque un punto y coma colocado por error después de un [for] es un error clásico. Un bloque vacío { } expresa lo mismo sin ambigüedad;
  • línea 28: [i++] devuelve el valor de [i] antes de incrementarlo: [i] se suma a [sum] y luego [i] se incrementa;
  • línea 34: la forma más habitual de [for]: la variable del bucle se declara en [for] y existe solo dentro del bucle;
  • líneas 41–42: el bucle [foreach] recorre los elementos del arreglo [friends];
  • líneas 51–58: [continue] pasa a la siguiente iteración para los números pares; [break] termina el bucle en cuanto [k] supera 7;
  • Líneas 66–74: un bucle infinito [while (true)] que se abandona mediante [break]. Esta forma resulta cómoda cuando la condición de terminación se calcula en medio del bucle. La usaremos para la entrada por teclado.

3.6. Manejo de excepciones

Muchos métodos de .NET pueden lanzar excepciones, es decir, errores. Cuando un método puede lanzar una excepción, el programador debe manejarla para que los programas toleren mejor los errores: siempre se debe evitar la terminación repentina de una aplicación.

3.6.1. La estructura try/catch/finally

El manejo de excepciones sigue este esquema:

1
2
3
4
5
6
7
8
9
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

Si el código del bloque [try] no lanza ninguna excepción, la ejecución continúa con la instrucción siguiente; de lo contrario, pasa al cuerpo del bloque [catch] y luego a la instrucción siguiente. Observe los siguientes puntos:

  • [e] es un objeto de tipo [Exception] o de un tipo derivado. Existen muchos tipos de excepciones: [IndexOutOfRangeException], [FormatException], [OverflowException], [ArgumentException], etc. Al escribir [catch (Exception e)], se indica que se quieren manejar todos los tipos de excepciones. Si el código de la cláusula [try] puede generar varios tipos de excepciones, conviene ser más específico y manejar la excepción con varias cláusulas [catch]:
try
{
    code likely to throw the exceptions
}
catch (IndexOutOfRangeException e1)
{
    handle the exception e1
}
catch (FormatException e2)
{
    handle the exception e2
}
next statement

Las cláusulas [catch] se evalúan en orden; se ejecuta la primera cuyo tipo coincide con la excepción. Por lo tanto, una cláusula [catch (Exception e)] debe colocarse al final;

  • se puede añadir una cláusula [finally] a las cláusulas [try / catch]:
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
finally
{
    code executed after try or catch
}
next statement

Ocurra o no una excepción, el código de la cláusula [finally] siempre se ejecuta. Por ejemplo, se puede usar para cerrar un archivo;

  • en la cláusula [catch], es posible que no se quiera usar el objeto [Exception] disponible. En lugar de escribir [catch (Exception e) { ... }], se escribiría entonces [catch (Exception) { ... }] o, más simplemente, [catch { ... }];
  • la clase [Exception] tiene una propiedad [Message] que detalla el error ocurrido. Para mostrarla, se escribe:
1
2
3
4
5
catch (Exception ex)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
    ...
}
  • La clase [Exception] tiene un método [ToString] que devuelve una cadena que indica el tipo de la excepción, el valor de la propiedad [Message] y la pila de llamadas, es decir, la lista de métodos que se estaban ejecutando en el momento del error, junto con el nombre del archivo fuente y el número de línea. Esta es la información más útil para el desarrollador, pero no está pensada para el usuario. En este curso, lo más habitual será mostrar el nombre del tipo de la excepción, [ex.GetType().Name], y su mensaje.

3.6.2. Un primer ejemplo

El programa [basics-20.cs] muestra una excepción generada al acceder a un elemento inexistente de un arreglo:

// una excepción causada por un índice de arreglo incorrecto
int[] tab = [0, 1, 2, 3];
// visualización del arreglo con un for
for (int i = 0; i < tab.Length; i++)
{
    Console.WriteLine($"tab[{i}]={tab[i]}");
}
// visualización del arreglo con un foreach
foreach (int elmt in tab)
{
    Console.WriteLine(elmt);
}
// generación de una excepción
try
{
    tab[100] = 6;
}
catch (Exception e)
{
    Console.Error.WriteLine($"The following error occurred: {e.GetType().FullName} - {e.Message}");
    return;
}
finally
{
    Console.WriteLine("finally ...");
}
Console.WriteLine("This line is not executed");

Resultados:

> dotnet run basics-20.cs
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: System.IndexOutOfRangeException - Index was outside the bounds of the array.
finally ...

Comentarios:

  • línea 16: esta instrucción lanza una excepción porque el arreglo [tab] no tiene ningún elemento en el índice 100;
  • línea 20: la excepción es de tipo [System.IndexOutOfRangeException] (línea 10 de los resultados);
  • línea 21: el programa termina;
  • Líneas 23–25: la cláusula [finally] se ejecutó (línea 11 de los resultados), aunque la cláusula [catch] contenía una instrucción [return]. Observe que la cláusula [finally] siempre se ejecuta;
  • línea 27: debido a [return], esta línea no se ejecuta.

3.6.3. Una entrada controlada

Este es otro ejemplo, [basics-21.cs], en el que manejamos la excepción causada al convertir en entero una cadena que no representa un entero:

// ingreso de una edad con manejo de la excepción de conversión
// se pide el nombre
Console.Write("Name: ");
string name = Console.ReadLine() ?? "";
// se pide la edad
int age = 0;
bool ageOK = false;
while (!ageOK)
{
    // pregunta
    Console.Write("age: ");
    // lectura y verificación de la respuesta
    try
    {
        age = int.Parse(Console.ReadLine() ?? "");
        ageOK = age >= 1;
    }
    catch (FormatException)
    {
    }
    if (!ageOK)
    {
        Console.WriteLine("Incorrect age, try again...");
    }
}
// visualización final
Console.WriteLine($"Your name is {name} and you are {age} year(s) old");

Resultados:

1
2
3
4
> dotnet run basics-21.cs
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
1
2
3
4
5
6
7
8
> dotnet run basics-21.cs
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old

Comentarios:

  • línea 4: si el flujo de entrada está cerrado, [ReadLine] devuelve [null]: se reemplaza por una cadena vacía. Por lo tanto, la variable [name] puede ser de tipo [string];
  • Líneas 8–23: el bucle de entrada de la edad;
  • línea 15: la línea ingresada por teclado se convierte en entero mediante el método [int.Parse]. Este método lanza una excepción si la conversión no es posible. Por eso la operación se colocó dentro de un [try / catch];
  • línea 16: si se llega a esta línea, significa que la conversión se realizó correctamente. Sin embargo, se verifica que el entero obtenido sea mayor o igual que 1;
  • línea 18: si se lanza una excepción [FormatException], el control pasa a [catch], donde no se realiza ninguna acción. Así, la variable booleana [ageOK], inicializada en [false], permanece en [false]. El código del curso de 2008 escribía [catch { }], que captura todas las excepciones: esto no se recomienda, porque también enmascara errores que no se habían previsto;
  • líneas 21–23: se muestra un mensaje de error si la edad es incorrecta.

Este programa tiene una debilidad: una edad como 99999999999 provoca una excepción [OverflowException] que no se captura y hace que el programa termine. Se podría añadir una cláusula [catch]; sin embargo, es más simple usar [int.TryParse], como hará la aplicación de ejemplo más adelante. Reservaremos las excepciones para situaciones verdaderamente excepcionales.

3.6.4. Varias cláusulas catch, filtros y lanzamiento de excepciones

El propio programa puede lanzar una excepción mediante la instrucción [throw]:

throw new ArgumentException("error message");

La ejecución del método actual se detiene y la excepción se propaga a través de los métodos llamadores hasta que una cláusula [catch] la maneja; si ninguna lo hace, el programa termina y muestra la excepción. En una cláusula [catch], la instrucción [throw;] (sin parámetros) vuelve a lanzar la excepción actual, por ejemplo, después de registrarla.

A partir de C# 6, una cláusula [catch] puede ir seguida de un [when (condition)] filtro: la cláusula solo se ejecuta si la condición es verdadera. A partir de C# 7, [throw] también puede usarse como expresión, a la derecha del operador ?? o dentro de un operador ternario.

El programa [basics-22.cs] ilustra estas posibilidades:

// varias cláusulas catch, filtros when, lanzamiento de excepciones
string[] inputs = ["12", "abc", "", "99999999999", "-3", "150"];
foreach (string input in inputs)
{
    try
    {
        int age = ReadAge(input);
        Console.WriteLine($"[{input}] : age={age}");
    }
    // filtro when: la cláusula solo se selecciona si la condición es verdadera
    catch (FormatException) when (input.Length == 0)
    {
        Console.WriteLine($"[{input}] : empty input");
    }
    catch (FormatException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (OverflowException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
}

// expresión throw (C# 7): a la derecha de ?? o en un operador ternario
string?[] names = ["dupont", null];
foreach (string? name in names)
{
    try
    {
        string valid = name ?? throw new ArgumentNullException(nameof(name), "the name is mandatory");
        Console.WriteLine($"name={valid}");
    }
    catch (ArgumentNullException e)
    {
        Console.WriteLine($"{e.GetType().Name} - {e.Message}");
    }
}

// una función local que lanza excepciones
static int ReadAge(string text)
{
    // int.Parse lanza FormatException u OverflowException
    int age = int.Parse(text);
    // lanzamos nosotros mismos una excepción si la edad está fuera de los límites
    if (age < 0 || age > 130)
    {
        throw new ArgumentException($"age out of bounds [0,130] : {age}");
    }
    return age;
}

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run basics-22.cs
[12] : age=12
[abc] : FormatException - The input string 'abc' was not in a correct format.
[] : empty input
[99999999999] : OverflowException - Value was either too large or too small for an Int32.
[-3] : ArgumentException - age out of bounds [0,130] : -3
[150] : ArgumentException - age out of bounds [0,130] : 150
name=dupont
ArgumentNullException - the name is mandatory (Parameter 'name')

Comentarios:

  • línea 2: entradas simuladas, algunas válidas y otras no;
  • línea 7: la función local [ReadAge] puede lanzar varios tipos de excepciones;
  • línea 11: esta cláusula solo maneja una [FormatException] si la entrada está vacía;
  • línea 15: la otra [FormatException];
  • línea 19: un número demasiado grande para un [int];
  • línea 23: la excepción lanzada por la propia función [ReadAge];
  • línea 35: una expresión [throw]: si [name] es igual a [null], se lanza una excepción [ArgumentNullException]. El operador [nameof] (C# 6) devuelve el nombre de una variable como cadena; [ArgumentNullException] lo agrega a su mensaje (línea 9 de los resultados);
  • Línea 52: la función [ReadAge] lanza una excepción si la edad está fuera de los límites.

3.7. Aplicación de ejemplo - V1

Queremos escribir un programa para calcular el impuesto de un contribuyente. Consideraremos el caso simplificado de un contribuyente que solo tiene un salario que declarar. Las cifras provienen del baremo fiscal de 2004 para los ingresos de 2003 y se utilizan tal cual: se trata de un ejercicio de programación, no de un cálculo de impuestos vigentes. Esta aplicación nos servirá de hilo conductor: volveremos a ella en los capítulos siguientes, incorporando clases, archivos, una base de datos y luego funcionalidades de red.

  • Se calcula el número de partes del empleado: partes = nbChildren/2 + 1 si es soltero, nbChildren/2 + 2 si es casado, donde nbChildren es el número de hijos;
  • si tiene al menos tres hijos, recibe media parte adicional;
  • su ingreso imponible R se calcula como R = 0.72 * S, donde S es su salario anual;
  • su cociente familiar se calcula como QF = R / partes;
  • su impuesto I se calcula con la siguiente tabla:
umbral
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada fila tiene 3 campos. Para calcular el impuesto I, se busca la primera fila en la que QF es menor o igual que el límite. Por ejemplo, si QF = 5,000, la fila encontrada será:

8382    0.068    291.09

El impuesto I es entonces igual a 0.068 * R - 291.09 * partes, truncado al euro. Si QF es tal que la condición QF ≤ límite nunca se cumple, se usan los coeficientes de la última fila: I = 0.481 * R - 9505.54 * partes. Por lo tanto, el límite 0 de la última fila nunca se utiliza.

El programa correspondiente en C# [tax-v1.cs] es el siguiente:

// cálculo del impuesto - versión 1
// tabla de impuestos de 2004 (ingresos de 2003): es un ejercicio, no la tabla de impuestos vigente

// arreglos de datos necesarios para el cálculo del impuesto
decimal[] limits = [4962M, 8382M, 14753M, 23888M, 38868M, 47932M, 0M];
decimal[] coeffR = [0M, 0.068M, 0.191M, 0.283M, 0.374M, 0.426M, 0.481M];
decimal[] coeffN = [0M, 291.09M, 1322.92M, 2668.39M, 4846.98M, 6883.66M, 9505.54M];

// estado civil
string answer;
while (true)
{
    Console.Write("Are you married (Y/N)? ");
    answer = (Console.ReadLine() ?? "").Trim().ToLower();
    if (answer is "y" or "n")
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}
bool married = answer == "y";

// número de hijos
int nbChildren;
while (true)
{
    Console.Write("Number of children: ");
    if (int.TryParse(Console.ReadLine(), out nbChildren) && nbChildren >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// salario anual
int salary;
while (true)
{
    Console.Write("Annual salary: ");
    if (int.TryParse(Console.ReadLine(), out salary) && salary >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// número de partes
decimal shares = married ? nbChildren / 2M + 2 : nbChildren / 2M + 1;
if (nbChildren >= 3)
{
    shares += 0.5M;
}

// ingreso gravable
decimal income = 0.72M * salary;

// cociente familiar
decimal quotient = income / shares;

// búsqueda del tramo del impuesto: el primero tal que cociente <= límite,
// el último si ninguno se ajusta
int i = 0;
while (i < limits.Length - 1 && quotient > limits[i])
{
    i++;
}

// el impuesto (truncado al euro)
int tax = (int)(coeffR[i] * income - coeffN[i] * shares);

// visualización del resultado
Console.WriteLine($"Tax to pay: {tax} euros");

Comentarios:

  • Líneas 5–7: los valores numéricos llevan el sufijo M para ser de tipo [decimal]. El tipo [decimal] codifica con exactitud los números decimales, como 0.068; es el tipo que se utiliza en los cálculos financieros. Con un [double], 0.068 sería solo una aproximación binaria;
  • líneas 10–21: entrada del estado civil, dentro de un bucle [while (true)] que se abandona mediante [break] cuando la respuesta es correcta;
  • línea 14: [Console.ReadLine()] devuelve la cadena C1 tal como se escribió en el teclado, o [null] (reemplazado por ""); [C1.Trim()] elimina los espacios iniciales y finales de C1 y devuelve la cadena C2; [C2.ToLower()] devuelve la cadena C2 convertida a minúsculas. Así se aceptan tanto Y como y;
  • línea 15: un patrón combinado con [or];
  • línea 19: los mensajes de error se escriben en el flujo [Error];
  • línea 21: el booleano [married] recibe el valor [true] o [false] de la relación [answer == "y"];
  • línea 28: [TryParse] devuelve [false] si la entrada no es un entero; la condición [nbChildren >= 0] no se evalúa entonces (el operador && se evalúa en cortocircuito). [TryParse] acepta una cadena [null]: en ese caso devuelve [false]. A diferencia de la versión de 2008, no se usan excepciones;
  • línea 40: lo mismo se aplica al salario;
  • Línea 48: no se puede escribir simplemente nbChildren / 2: si nbChildren es igual a 3, se obtendría 3/2, una división entera que daría 1, no 1.5. Como el divisor 2M es de tipo [decimal], la división se realiza como [decimal]. El material del curso de 2008 usaba [(decimal)nbChildren / 2], que equivale a lo mismo;
  • Líneas 62–65: determinación del tramo del impuesto. El cálculo se detiene en el primer umbral que es mayor o igual que el cociente familiar, y a más tardar en el último tramo. La versión de 2008 escribía inicialmente QF en la última celda de la tabla de límites para asegurar que se detuviera: esto alteraba los datos del baremo; la condición [i < limits.Length - 1] evita este efecto secundario;
  • Línea 69: el impuesto se trunca al euro convirtiéndolo a [int].

Estos son algunos ejemplos de la salida:

1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> dotnet run tax-v1.cs
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

Son los mismos resultados que en el curso de 2008: 4,282 euros para un contribuyente casado con 2 hijos y 2,959 euros con 3 hijos, para un salario anual de 60,000 euros. Una persona soltera sin hijos y con el mismo salario paga 11,519 euros. En la segunda ejecución, la entrada “60000 euros” se rechaza: [int.TryParse] solo acepta cadenas que representen un entero exacto (se permiten espacios al principio y al final).

3.8. Argumentos del programa principal

La función principal [Main] puede aceptar como parámetro un arreglo de cadenas [string[]]. Este arreglo contiene los argumentos de la línea de comandos con los que se lanzó la aplicación. Así, si el programa P se lanza con el comando:

P arg0 arg1 ... argn

y si la función [Main] se declara de la siguiente manera:

        static void Main(string[] args)

entonces tendremos args[0]="arg0", args[1]="arg1", y así sucesivamente. Con las instrucciones de nivel superior no hay ningún método [Main] escrito por el programador, pero el arreglo [args] está disponible de la misma manera: es el parámetro del método [Main] generado por el compilador.

Con [dotnet run], los argumentos del programa se colocan después de dos guiones ([--]), que los separan de las opciones del propio comando [dotnet run]:

dotnet run prog.cs -- a0 a1 a2

El curso de 2008 especificaba los argumentos en las propiedades del proyecto de Visual Studio; hoy basta con la línea de comandos. Este es un ejemplo, [basics-23.cs]:

1
2
3
4
5
6
7
// los argumentos de la línea de comandos
// con instrucciones de nivel superior, el arreglo args está predefinido
Console.WriteLine($"There are {args.Length} argument(s)");
for (int i = 0; i < args.Length; i++)
{
    Console.WriteLine($"args[{i}]={args[i]}");
}

Resultados:

1
2
3
4
5
6
> dotnet run basics-23.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Un argumento que contiene espacios debe ir entre comillas:

1
2
3
4
> dotnet run basics-23.cs -- "jean dupont" 23
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

El mismo programa escrito con un método [Main] tradicional: [basics-24.cs]:

// los argumentos de la línea de comandos con un método Main clásico
namespace Basics;

public static class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine($"There are {args.Length} argument(s)");
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine($"args[{i}]={args[i]}");
        }
    }
}

Resultados:

1
2
3
4
5
6
> dotnet run basics-24.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Comentarios:

  • línea 2: un espacio de nombres de ámbito de archivo (C# 10);
  • línea 4: una clase estática contiene solo miembros estáticos;
  • línea 6: el punto de entrada del programa. Como este archivo no contiene instrucciones de nivel superior, el compilador busca un método estático llamado [Main];
  • línea 8: el resto es idéntico a [basics-23.cs].

La firma [static void Main()] es válida si la función [Main] no recibe parámetros. [Main] también puede devolver un [int], que es entonces el código de retorno del programa: [static int Main(string[] args)].

3.9. Enumeraciones

Una enumeración es un tipo de datos cuyo dominio de valores consiste en un conjunto de constantes enteras con nombre. Consideremos un programa que debe manejar las calificaciones de un examen. Hay cinco calificaciones posibles: Pass, FairlyGood, Good, VeryGood y Excellent. Podemos entonces definir una enumeración para estas cinco constantes:

enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

Internamente, estas cinco constantes se codifican como enteros consecutivos que empiezan en 0 para la primera constante, 1 para la siguiente, y así sucesivamente. También podemos fijar estos valores explícitamente: [enum Honours { Pass = 10, FairlyGood = 12, ... }]. Se puede declarar una variable para que tome sus valores de la enumeración:

Honours myHonours = Honours.Pass;

Una variable se puede comparar con los distintos valores posibles de la enumeración:

1
2
3
4
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}

Así como el tipo simple [int] equivale a la estructura [System.Int32], toda enumeración deriva de la clase [System.Enum]. Esta clase tiene métodos estáticos que permiten obtener los valores y los nombres de un tipo enumerado:

  • [Enum.GetValues<Honours>()] (.NET 5) devuelve el arreglo de valores de la enumeración [Honours];
  • [Enum.GetNames<Honours>()] devuelve el arreglo de sus nombres;
  • [Enum.TryParse(str, out Honours m)] convierte una cadena en un valor de la enumeración.

El curso de 2008 describía [Enum.GetValues(typeof(Honours))]: esta forma, que sigue siendo válida, devuelve un arreglo sin tipo que luego hay que convertir. La forma genérica [GetValues<Honours>()] devuelve directamente un arreglo de tipo [Honours[]].

El programa [basics-25.cs] ilustra lo que se acaba de describir:

// enumeraciones
// una variable que toma sus valores de la enumeración Honours
Honours myHonours = Honours.Pass;
// visualización del valor de la variable
Console.WriteLine($"honours={myHonours}");
// prueba con un valor de la enumeración
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}
// lista de menciones: nombre y valor entero
foreach (Honours m in Enum.GetValues<Honours>())
{
    Console.WriteLine($"{m} = {(int)m}");
}
// lista de nombres
Console.WriteLine(string.Join(", ", Enum.GetNames<Honours>()));
// entero --> enumeración
Honours m3 = (Honours)3;
Console.WriteLine($"(Honours)3 = {m3}");
// cadena --> enumeración
if (Enum.TryParse("Good", out Honours m2))
{
    Console.WriteLine($"m2={m2}, m2 > Pass : {m2 > Honours.Pass}");
}
// una enumeración en una expresión switch
string assessment = myHonours switch
{
    Honours.Pass or Honours.FairlyGood => "correct",
    Honours.Good or Honours.VeryGood => "very correct",
    _ => "remarkable"
};
Console.WriteLine($"assessment : {assessment}");
Console.WriteLine($"type : {typeof(Honours).FullName}, underlying type : {Enum.GetUnderlyingType(typeof(Honours)).Name}");

// la declaración de un tipo se coloca después de las instrucciones de nivel superior
enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

Resultados:

> dotnet run basics-25.cs
honours=Pass
Could do better
Pass = 0
FairlyGood = 1
Good = 2
VeryGood = 3
Excellent = 4
Pass, FairlyGood, Good, VeryGood, Excellent
(Honours)3 = VeryGood
m2=Good, m2 > Pass : True
assessment : correct
type : Honours, underlying type : Int32

Comentarios:

  • línea 3: una variable de tipo [Honours];
  • línea 5: un valor de enumeración se muestra por su nombre;
  • líneas 12–14: la lista de valores. La conversión [(int)m] devuelve el valor entero de la constante;
  • línea 17: la lista de nombres;
  • línea 19: la conversión inversa, de un entero a la enumeración;
  • línea 22: la conversión de una cadena a un valor de la enumeración. Los valores de una enumeración se comparan como los enteros que los codifican;
  • líneas 27–31: las enumeraciones se combinan bien con las instrucciones switch;
  • línea 34: el tipo entero subyacente es [int] de manera predeterminada;
  • línea 37: la declaración de la enumeración. En un archivo que contiene instrucciones de nivel superior, las declaraciones de tipos (enumeraciones, clases, etc.) se colocan después de las instrucciones.

A una enumeración cuyos valores son potencias de 2 (1, 2, 4, 8, ...) se le puede asignar el atributo [Flags]: sus valores se combinan entonces con el operador | (OR bit a bit) para representar un conjunto de opciones, por ejemplo los derechos de acceso a un archivo (lectura | escritura).

3.10. Paso de parámetros a una función

Aquí nos centramos en cómo se pasan los parámetros a una función. Consideremos la siguiente función:

1
2
3
4
5
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

En la definición de la función, en la línea 1, [a] se denomina parámetro formal. Se incluye únicamente para definir la función [ChangeInt]. Podría haberse llamado igualmente [b]. Consideremos ahora un ejemplo de uso de esta función:

1
2
3
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

Aquí, en la instrucción de la línea 2, [age] es el parámetro real que pasará su valor al parámetro formal [a]. Nos interesa cómo un parámetro formal obtiene el valor de un parámetro real.

3.10.1. Modos de paso

C# admite los siguientes modos de paso:

  • por valor (el modo predeterminado): el valor del parámetro real se copia en el parámetro formal correspondiente. Son dos entidades distintas: si la función modifica el parámetro formal, el parámetro real permanece sin cambios. Este modo es adecuado para los parámetros de entrada de una función;
  • por referencia con [ref]: el parámetro real y el parámetro formal son una misma entidad. Si la función modifica el parámetro formal, el parámetro real también se modifica. La palabra clave [ref] debe aparecer tanto en la definición de la función como en la llamada. El parámetro real debe tener un valor antes de la llamada. Este modo es adecuado para los parámetros de entrada y salida;
  • por referencia con [out]: igual que [ref], pero el parámetro es solo de salida: el parámetro real no necesita un valor inicial y la función debe asignar un valor al parámetro formal. Este es el modo que usan los métodos [TryParse]. A partir de C# 7, la variable se puede declarar en la llamada: [out var x] o [out int x];
  • por referencia de solo lectura con [in] (C# 7.2): el parámetro se pasa por referencia, lo que evita la copia, pero la función no puede modificarlo. Este modo solo es útil para estructuras grandes; para los tipos predefinidos, el paso por valor es igual de eficiente.

El programa [basics-26.cs] ilustra estos distintos modos:

// modos de paso de parámetros
// 1 - paso por valor
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

// 2 - paso por referencia con ref
int age2 = 20;
ChangeInt2(ref age2);
Console.WriteLine($"Actual parameter age2={age2}");

// 3 - paso por referencia con out: no es necesario inicializar la variable
int age3;
ChangeInt3(out age3);
Console.WriteLine($"Actual parameter age3={age3}");
// out var (C# 7): la variable se declara en la llamada
ChangeInt3(out var age4);
Console.WriteLine($"Actual parameter age4={age4}");

// 4 - un intercambio de valores con ref
int x = 1, y = 2;
Swap(ref x, ref y);
Console.WriteLine($"after swap : x={x}, y={y}");

// 5 - paso por referencia de solo lectura con in
decimal price = 100M;
Console.WriteLine($"InclTax({price})={InclTax(in price)}");

// 6 - un arreglo pasado por valor: lo que se copia es su referencia
int[] array = [1, 2, 3];
ModifyArray(array);
Console.WriteLine($"array=[{string.Join(", ", array)}]");

// las funciones locales
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

static void ChangeInt2(ref int a2)
{
    a2 = 30;
    Console.WriteLine($"Formal parameter a2={a2}");
}

static void ChangeInt3(out int a3)
{
    a3 = 30;
    Console.WriteLine($"Formal parameter a3={a3}");
}

static void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

static decimal InclTax(in decimal amount)
{
    // amount = 0; sería rechazado: un parámetro in no puede modificarse
    return amount * 1.2M;
}

static void ModifyArray(int[] t)
{
    // modificamos el arreglo referenciado: el llamador ve la modificación
    t[0] = 100;
    // hacemos que t apunte a otro arreglo: el llamador no lo ve
    t = [7, 8, 9];
    Console.WriteLine($"in ModifyArray : t=[{string.Join(", ", t)}]");
}

Resultados:

> dotnet run basics-26.cs
Formal parameter a=30
Actual parameter age=20
Formal parameter a2=30
Actual parameter age2=30
Formal parameter a3=30
Actual parameter age3=30
Formal parameter a3=30
Actual parameter age4=30
after swap : x=2, y=1
InclTax(100)=120,0
in ModifyArray : t=[7, 8, 9]
array=[100, 2, 3]

Comentarios:

  • Líneas 3–5: el valor 20 del parámetro real [age] se copió en el parámetro formal [a] (línea 35). Luego este parámetro se modificó (línea 37). El parámetro real permaneció sin cambios;
  • líneas 8–10: con [ref], el parámetro real [age2] siguió la modificación del parámetro formal [a2];
  • líneas 13–15: la variable [age3] no se inicializa antes de la llamada; esto es posible con [out];
  • línea 17: la variable [age4] se declara en la llamada;
  • líneas 21–22: intercambiar dos valores requiere el paso por referencia; con el paso por valor, la función intercambiaría copias;
  • línea 27: un paso de solo lectura. La palabra clave [in] es opcional en la llamada. El resultado 120.0 tiene un decimal porque el producto de dos valores [decimal] conserva los decimales de sus operandos: 100 × 1.2 = 120.0;
  • Líneas 30–32: un arreglo es un tipo por referencia; lo que se pasa por valor es la referencia del arreglo. Por lo tanto, la función [ModifyArray] opera sobre el mismo arreglo que el llamador: la modificación realizada por [t[0]] (línea 69) es visible para el llamador. Sin embargo, hacer que [t] apunte a otro arreglo (línea 71) solo modifica la copia local de la referencia.

Si se reemplaza la línea 8 por [int age2;], el compilador rechaza el programa:

error CS0165: Use of unassigned local variable 'age2'

Este problema se puede sortear asignando un valor inicial a [age2], o reemplazando la palabra clave [ref] por la palabra clave [out]: esto indica que el parámetro es únicamente de salida. De manera similar, si la función [InclTax] intenta modificar su parámetro [in]:

error CS8331: Cannot assign to variable 'amount' or use it as the right hand side of a ref assignment because it is a readonly variable

3.10.2. Parámetros opcionales, argumentos con nombre, número variable de parámetros

C# 4 introdujo los parámetros opcionales: a un parámetro se le puede dar un valor predeterminado en la definición de la función; el llamador puede entonces omitirlo. Los parámetros opcionales se colocan después de los parámetros obligatorios. También introdujo los argumentos con nombre: al llamar a la función, un parámetro real puede ir precedido del nombre del parámetro formal seguido de dos puntos. Esto permite omitir un parámetro opcional que precede a otros parámetros, o proporcionar los parámetros en cualquier orden.

La palabra clave [params] permite escribir una función con un número variable de parámetros: el último parámetro formal es un arreglo, y el llamador puede pasar un arreglo o una lista de valores (que puede estar vacía), que el compilador organiza en un arreglo. A partir de C# 13, el parámetro [params] también puede ser de otro tipo de colección, como [List<T>] o [ReadOnlySpan<T>].

El programa [basics-27.cs] es el siguiente:

// parámetros opcionales, argumentos con nombre, número variable de parámetros
// parámetros opcionales (C# 4): tienen un valor predeterminado
Console.WriteLine(Greet("Pierre"));
Console.WriteLine(Greet("Pierre", "Good evening"));
// argumentos con nombre (C# 4): se puede omitir un parámetro opcional o cambiar el orden
Console.WriteLine(Greet("Pierre", uppercase: true));
Console.WriteLine(Greet(uppercase: true, greeting: "Hi", name: "Paul"));

// params: número variable de parámetros
Console.WriteLine($"Sum()={Sum()}");
Console.WriteLine($"Sum(1, 2, 3)={Sum(1, 2, 3)}");
int[] values = [10, 20, 30];
Console.WriteLine($"Sum(values)={Sum(values)}");
// un método del framework con un número variable de parámetros
Console.WriteLine(string.Join(" - ", "a", "b", "c"));

static string Greet(string name, string greeting = "Hello", bool uppercase = false)
{
    string message = $"{greeting} {name}";
    return uppercase ? message.ToUpper() : message;
}

static int Sum(params int[] numbers)
{
    // numbers es un arreglo
    int sum = 0;
    foreach (int number in numbers)
    {
        sum += number;
    }
    return sum;
}

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run basics-27.cs
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
Sum()=0
Sum(1, 2, 3)=6
Sum(values)=60
a - b - c

Comentarios:

  • Línea 17: la función [Greet] tiene un parámetro obligatorio, [name], y dos parámetros opcionales, [greeting] y [uppercase];
  • Línea 3: ambos parámetros opcionales toman sus valores predeterminados;
  • línea 4: solo [uppercase] toma su valor predeterminado;
  • línea 6: mediante el argumento con nombre, pasamos [uppercase] sin pasar [greeting];
  • línea 7: con argumentos con nombre, el orden es arbitrario;
  • línea 23: [Sum] acepta cualquier cantidad de enteros;
  • líneas 10–13: se llama a [Sum] sin ningún parámetro, con tres enteros y luego con un arreglo;
  • Línea 15: muchos métodos de .NET, como [string.Join] o [Console.WriteLine] con un formato, tienen un parámetro [params].

3.11. Funciones locales y tuplas

3.11.1. Funciones locales

Una función local (C# 7) es una función definida dentro de un método o, como en nuestros ejemplos, entre instrucciones de nivel superior. Solo puede usarse en ese lugar. Como nuestros programas ya no tienen clases, las funciones locales reemplazan a los métodos estáticos de los ejemplos de 2008. Una función local:

  • puede llamarse antes de ser definida;
  • puede usar las variables locales que la rodean, a menos que se declare como [static]: la palabra clave [static] (C# 8) garantiza que dependa únicamente de sus parámetros, lo que facilita su comprensión. Declaramos nuestras funciones locales [static] siempre que es posible;
  • puede tener un cuerpo de expresión: [static int Square(int x) => x * x;] equivale a un cuerpo como [{ return x * x; }].

En un programa más grande, escribimos clases y métodos: este es el tema del próximo capítulo.

3.11.2. Tuplas

Una tupla (C# 7) agrupa varios valores, que pueden ser de tipos distintos, en una sola entidad. El tipo [(int, string)] designa un par formado por un entero y una cadena; sus elementos se llaman [Item1] y [Item2]. Se les puede dar nombre: [(int Number, string Name)]. Una tupla se puede deconstruir: [var (number, name) = t;] asigna sus elementos a dos variables.

Las tuplas permiten que una función devuelva varios valores sin usar parámetros [out]: esto suele ser más legible.

El programa [basics-28.cs] es el siguiente:

// funciones locales y tuplas
// una función local con cuerpo de expresión
static int Square(int x) => x * x;
Console.WriteLine($"Square(7)={Square(7)}");

// una función local no estática puede usar las variables del programa
int counter = 0;
void Increment() => counter++;
Increment();
Increment();
Console.WriteLine($"counter={counter}");

// una tupla agrupa varios valores
(int, string) t1 = (1, "one");
Console.WriteLine($"t1={t1}, t1.Item1={t1.Item1}, t1.Item2={t1.Item2}");
// los elementos de una tupla pueden tener nombre
(int Number, string Name) t2 = (2, "two");
var t3 = (Number: 3, Name: "three");
Console.WriteLine($"t2.Number={t2.Number}, t3.Name={t3.Name}");
// deconstrucción: una tupla se divide en varias variables
var (number, name) = t3;
Console.WriteLine($"number={number}, name={name}");

// una función que devuelve varios valores sin parámetros out
var (quotient, remainder) = Divide(17, 5);
Console.WriteLine($"17 = 5 * {quotient} + {remainder}");
var mm = MinMax([12, -4, 35, 7]);
Console.WriteLine($"min={mm.Min}, max={mm.Max}");
// el framework también usa tuplas
var (q, r) = Math.DivRem(23, 4);
Console.WriteLine($"Math.DivRem(23, 4) : quotient={q}, remainder={r}");

// intercambio de dos variables con una tupla
int a = 1, b = 2;
(a, b) = (b, a);
Console.WriteLine($"a={a}, b={b}");

static (int Quotient, int Remainder) Divide(int a, int b) => (a / b, a % b);

static (int Min, int Max) MinMax(int[] values)
{
    int min = values[0], max = values[0];
    foreach (int v in values)
    {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return (min, max);
}

Resultados:

> dotnet run basics-28.cs
Square(7)=49
counter=2
t1=(1, one), t1.Item1=1, t1.Item2=one
t2.Number=2, t3.Name=three
number=3, name=three
17 = 5 * 3 + 2
min=-4, max=35
Math.DivRem(23, 4) : quotient=5, remainder=3
a=2, b=1

Comentarios:

  • línea 3: una función local estática con cuerpo de expresión;
  • líneas 7–8: una función local no estática: modifica la variable del programa [counter];
  • línea 14: una tupla cuyos elementos no tienen nombre. Cuando se imprime una tupla, sus elementos aparecen entre paréntesis;
  • líneas 17–18: dos tuplas con elementos con nombre: la primera por su tipo, la segunda por los nombres dados en la expresión;
  • línea 21: la descomposición de la tupla [t3];
  • línea 25: la función [Divide] devuelve el cociente y el resto de la división entera; el resultado se descompone directamente;
  • línea 27: aquí se conserva la tupla y se usan los nombres de sus elementos, [Min] y [Max];
  • línea 30: desde .NET 6, [Math.DivRem] también devuelve una tupla (cociente, resto);
  • línea 35: intercambiar dos variables puede escribirse en una sola línea mediante una tupla, sin variable temporal;
  • línea 38: el tipo devuelto por la función es una tupla con nombre;
  • líneas 40–48: una función que calcula el mínimo y el máximo de un arreglo en una sola pasada.