Skip to content

4. Clases, estructuras, interfaces

4.1. Objetos mediante ejemplos

4.1.1. Descripción general

Vamos a explorar ahora la programación orientada a objetos mediante ejemplos. Un objeto es una entidad que contiene datos que definen su estado (llamados campos, atributos, etc.) y funciones (llamadas métodos). Un objeto se crea a partir de una plantilla llamada clase:

public class C1
{
    Type1 p1;          // campo p1
    Type2 p2;          // campo p2
    ...
    Type3 M3(...)      // método M3
    {
        ...
    }
    Type4 M4(...)      // método M4
    {
        ...
    }
    ...
}

A partir de la clase anterior [C1], se pueden crear muchos objetos como [O1], [O2], … Todos tendrán los campos [p1], [p2], … y los métodos [M3], [M4], … Sin embargo, tendrán valores diferentes en sus campos [pi], de modo que cada uno tiene su propio estado. Si [o1] es un objeto de tipo [C1], [o1.p1] se refiere al campo [p1] de [o1], y [o1.M3] se refiere al método [M3] de [o1].

Consideremos un primer modelo de objetos: la clase [Person].

4.1.2. Creación del proyecto de C#

En los ejemplos del capítulo anterior, un programa cabía en un solo archivo fuente. A partir de ahora, un programa puede constar de varios archivos fuente: una clase por archivo, más el programa principal. Estos archivos se agrupan en un proyecto. El curso de 2008 creaba los proyectos con los asistentes de Visual Studio 2008; aquí usamos la herramienta de línea de comandos [dotnet], que funciona igual en Windows, Linux y macOS. El capítulo 2 mostró cómo abrir el mismo proyecto en VS Code o Visual Studio.

En un terminal, vaya a la carpeta [04-classes] y cree un proyecto de consola llamado [Persons]:

1
2
3
4
5
6
7
8
> dotnet new console -n Persons
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring .../04-classes/Persons/Persons.csproj:
  Determining projects to restore...
  Restored .../04-classes/Persons/Persons.csproj (in 126 ms).
Restore succeeded.

El comando crea una carpeta llamada [Persons] que contiene dos archivos. El archivo [Persons.csproj] describe el proyecto:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>
  • Línea 4: el proyecto produce un ejecutable;
  • línea 5: el programa de destino es .NET 10;
  • línea 6: un conjunto de espacios de nombres comunes ([System], [System.IO], [System.Collections.Generic], [System.Linq], …) se importa implícitamente en todos los archivos fuente del proyecto. Por eso podemos escribir *[Console.WriteLine] sin la cláusula ***[using System;]** ;
  • Línea 7: los tipos de referencia que admiten valores nulos están habilitados. El compilador emite una advertencia para toda variable de tipo por referencia (una cadena, un objeto) que pueda tomar el valor [null] sin que el programa lo espere. Volveremos sobre esto en la sección dedicada a estos tipos; por ahora, basta con recordar que nuestros programas deben compilar sin ninguna advertencia.

El segundo archivo, [Program.cs], contiene el programa principal. Todos los archivos [*.cs] de la carpeta del proyecto (y de sus subcarpetas) forman parte del proyecto: para agregar una clase [Person], basta con crear el archivo [Person.cs] en la carpeta [Persons]. Para ejecutar el proyecto, escriba [dotnet run] en su carpeta: el comando compila el proyecto, si ha cambiado, y luego lo ejecuta.

Todos los proyectos de este capítulo se agrupan en una solución, un archivo que hace referencia a un conjunto de proyectos y que VS Code o Visual Studio pueden abrir de una sola vez. El formato [.slnx] (XML), compatible con el comando [dotnet] desde .NET 9 y formato predeterminado desde .NET 10, reemplaza al antiguo formato [.sln]:

1
2
3
4
5
> dotnet new sln --format slnx -n 04-classes
The template "Solution File" was created successfully.

> dotnet sln 04-classes.slnx add Persons/Persons.csproj
Project `Persons/Persons.csproj` added to the solution.

El comando [dotnet build 04-classes.slnx] compila entonces todos los proyectos de la solución.

4.1.3. Definición de la clase Person

La definición de la clase [Person] en el archivo fuente [Person.cs] será la siguiente:

namespace Persons;

public class Person
{
    // atributos (campos)
    private string firstName = "";
    private string lastName = "";
    private int age;

    // método
    public void Initialize(string p, string n, int age)
    {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // método
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • Línea 1: la clase pertenece al espacio de nombres [Persons] (el nombre del proyecto). Esta forma, [namespace Persons;], conocida como “ámbito de archivo”, coloca todos los tipos del archivo dentro del espacio de nombres. Los espacios de nombres se tratan al final del capítulo;
  • Líneas 6–8: los tres campos de la clase. Las dos cadenas se inicializan con la cadena vacía; de lo contrario, valdrían [null] al crearse el objeto, y el compilador, que tiene habilitados los tipos que admiten valores nulos, emitiría una advertencia;
  • líneas 11–15: un método que establece el estado del objeto;
  • líneas 19–21: un método que muestra el estado del objeto.

Aquí tenemos la definición de una clase y, por lo tanto, de un tipo de datos. Cuando creamos variables de este tipo, las llamamos objetos o instancias de la clase. Una clase es, por lo tanto, una plantilla a partir de la cual se construyen objetos.

Los miembros de una clase pueden ser datos (campos), métodos (funciones) o propiedades. Las propiedades son métodos especiales que sirven para obtener o establecer el valor de los campos de un objeto. Estos miembros pueden ir acompañados de una de las siguientes palabras clave:

Palabra clave
Acceso
[private]
Un miembro privado solo es accesible por los métodos internos de la clase. Este es el nivel de acceso predeterminado
[public]
Un miembro público es accesible por cualquier método, esté o no definido dentro de la clase
[protected]
Un miembro protegido solo es accesible por los métodos internos de la clase o de una clase derivada (véase más abajo el concepto de herencia)
[internal]
Un miembro interno es accesible por cualquier método dentro del mismo ensamblado (el mismo proyecto)

En general, los datos de una clase se declaran privados, mientras que sus métodos y propiedades se declaran públicos. Esto significa que el usuario de un objeto (el programador):

  • no tendrá acceso directo a los datos privados del objeto;
  • puede llamar a los métodos públicos del objeto, incluidos aquellos que dan acceso a sus datos privados.

La sintaxis para declarar una clase [C] es la siguiente:

1
2
3
4
5
6
public class C
{
    private private data, method or property;
    public public data, method or property;
    protected protected data, method or property;
}

El orden en que se declaran los miembros [private], [protected] y [public] es arbitrario.

4.1.4. El método Initialize

¿Cuál es el propósito del método [Initialize]? Dado que [lastName], [firstName] y [age] son miembros privados de la clase [Person], las instrucciones:

1
2
3
4
Person p1;
p1.firstName = "Jean";
p1.lastName = "Dupont";
p1.age = 30;

no son válidas. Necesitamos inicializar un objeto de tipo [Person] mediante un método público. Este es el propósito del método [Initialize]. Escribiremos:

Person p1;
p1.Initialize("Jean", "Dupont", 30);

La notación [p1.Initialize] es válida porque [Initialize] es de acceso público.

4.1.5. El operador new

Sin embargo, la secuencia de instrucciones anterior es incorrecta. La instrucción

Person p1;

declara [p1] como una referencia a un objeto de tipo [Person]. Este objeto aún no existe y, por lo tanto, [p1] no está inicializado. Cuando escribimos a continuación [p1.Initialize("Jean", "Dupont", 30)], llamamos al método [Initialize] del objeto al que hace referencia [p1]. Sin embargo, este objeto no existe y el compilador informa el error: la variable local [p1] no tiene un valor asignado. Si escribimos:

Person? p1 = null;
p1.Initialize("Jean", "Dupont", 30);

indicamos explícitamente con la palabra clave [null] que la variable [p1] aún no hace referencia a ningún objeto (el signo de interrogación en [Person?] indica que a la variable se le puede asignar [null]). El compilador emite entonces solo una advertencia (desreferenciación de una referencia nula) y, en tiempo de ejecución, la llamada al método lanza una excepción [NullReferenceException]. Para que [p1] haga referencia a un objeto, hay que escribir:

Person p1 = new Person();

Esto crea un objeto de tipo [Person] que aún no ha sido inicializado: sus campos tienen los valores predeterminados, en este caso la cadena vacía para [lastName] y [firstName], y 0 para [age] (un campo numérico sin valor inicial explícito vale 0; un campo de tipo referencia vale [null]). Ahora que [p1] hace referencia a un objeto, la instrucción de inicialización de ese objeto, [p1.Initialize("Jean", "Dupont", 30)], es válida.

4.1.6. La palabra clave this

Veamos el código del método [Initialize]:

    public void Initialize(string p, string n, int age)
    {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

La instrucción [this.firstName = p] significa que al campo [firstName] del objeto actual ([this]) se le asigna el valor [p]. La palabra clave [this] hace referencia al objeto actual, aquel sobre el cual se ejecuta el método. ¿Cómo lo sabemos? Veamos cómo se inicializa el objeto referenciado por [p1] en el programa que lo llama:

p1.Initialize("Jean", "Dupont", 30);

Se llama al método [Initialize] del objeto [p1]. Cuando, dentro de este método, se hace referencia al objeto [this], en realidad se trata del objeto [p1]. El método [Initialize] también podría haberse escrito así:

1
2
3
4
5
6
    public void Initialize(string p, string n, int age)
    {
        firstName = p;
        lastName = n;
        this.age = age;
    }

Cuando un método de un objeto hace referencia a un campo [A] de ese objeto, se sobrentiende la notación [this.A]. Debe usarse explícitamente cuando hay un conflicto de identificadores. Es el caso de la instrucción [this.age = age;], donde [age] designa a la vez un campo del objeto actual y el parámetro [age] recibido por el método. En ese caso, la ambigüedad debe resolverse haciendo referencia al campo [age] como [this.age].

4.1.7. Un programa de prueba

Este es un breve programa de prueba. Está escrito en el archivo fuente [Program.cs] del proyecto:

1
2
3
4
5
6
using Persons;

// un objeto Person
Person p1 = new Person();
p1.Initialize("Jean", "Dupont", 30);
p1.Identify();
  • Línea 1: el programa principal se escribe con instrucciones de nivel superior que no pertenecen a ningún espacio de nombres. Para hacer referencia a la clase [Person] solo por su nombre, es necesario importar su espacio de nombres [Persons] mediante la cláusula [using];
  • Línea 4: creación de un objeto [Person] referenciado por [p1];
  • Línea 5: inicialización del objeto;
  • Línea 6: visualización de su estado.

Resultados:

> dotnet run
[Jean, Dupont, 30]

4.1.8. Aplicaciones de un solo archivo

Para un ejemplo corto, un proyecto resulta innecesariamente pesado. Desde la versión 10, .NET puede ejecutar directamente un archivo fuente independiente, sin un archivo [.csproj]: es una aplicación de un solo archivo, que utilizamos en el capítulo anterior. Las opciones del proyecto (tipos que admiten valores NULL habilitados, [using] implícitos) son las mismas que las de un proyecto de consola. Usaremos este formato siempre que el ejemplo contenga solo una o dos clases.

El archivo contiene entonces las instrucciones de nivel superior seguidas de las declaraciones de clases: el compilador impone este orden, ya que las instrucciones de nivel superior deben preceder a cualquier declaración de tipo (clase, estructura, interfaz, etc.) en el archivo. Las clases declaradas de este modo no pertenecen a ningún espacio de nombres, lo cual es irrelevante en un programa de un solo archivo.

4.1.9. Otro método: la sobrecarga

Continuemos con la clase *[Person] y agreguémosle un segundo método, *[Initialize]. El programa *[classes-01.cs]* es el siguiente:

// sobrecarga del método Initialize
Person p1 = new Person();
p1.Initialize("Jean", "Dupont", 30);
p1.Identify();
Person p2 = new Person();
p2.Initialize(p1);
p2.Identify();

// la clase Person se declara después de las instrucciones de nivel superior
public class Person
{
    // atributos
    private string firstName = "";
    private string lastName = "";
    private int age;

    // inicialización a partir de tres valores
    public void Initialize(string p, string n, int age)
    {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // inicialización a partir de otra persona
    public void Initialize(Person p)
    {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidad de la persona
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • líneas 2–7: las instrucciones de nivel superior, es decir, el programa principal;
  • Línea 10: la clase [Person] se declara después de las instrucciones de nivel superior;
  • líneas 18–22: el método [Initialize] del párrafo anterior;
  • líneas 26–30: un segundo método, [Initialize].

Ahora tenemos dos métodos llamados [Initialize]: esto es válido siempre que acepten parámetros diferentes (en número o tipo). Se dice que el método [Initialize] está sobrecargado. El compilador elige qué método llamar según los parámetros reales: [p1.Initialize("Jean", "Dupont", 30)] (línea 3) llama al primero, y [p2.Initialize(p1)] (línea 6) llama al segundo.

El parámetro del segundo método es una referencia ([p]) a una persona. Los campos de la persona ([p]) se asignan entonces al objeto actual ([this]). Observe que el método [Initialize] tiene acceso directo a los campos del objeto [p] aunque sean privados (líneas 28–30). Esto siempre se cumple: un método de una clase [C] tiene acceso a los miembros privados de todos los objetos de la misma clase [C].

Resultados:

1
2
3
> dotnet run classes-01.cs
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Constructores de la clase Person

Un constructor es un método que lleva el nombre de la clase y se llama cuando se crea el objeto. Generalmente se usa para inicializar el objeto. Es un método que puede aceptar parámetros pero no devuelve ningún valor. Su declaración no va precedida de ningún tipo (ni siquiera [void]).

Si una clase [C] tiene un constructor que acepta n parámetros, la declaración e inicialización de un objeto de esta clase puede hacerse de la siguiente manera:

C obj = new C(arg1, arg2, ... argn);

o

1
2
3
C obj;
...
obj = new C(arg1, arg2, ... argn);

Cuando una clase [C] tiene uno o más constructores, debe usarse uno de ellos para crear un objeto de esa clase. Si una clase [C] no tiene constructores, tiene un constructor predeterminado, que es el constructor sin parámetros [public C()]. Los campos del objeto conservan entonces sus valores iniciales. Esto es lo que ocurrió en los programas anteriores, donde habíamos escrito [new Person()].

El programa [classes-02.cs] proporciona tres constructores para la clase [Person]:

// constructores de la clase Person
Person p1 = new Person("Jean", "Dupont", 30);
p1.Identify();
Person p2 = new Person(p1);
p2.Identify();
Person p3 = new Person();
p3.Identify();

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // constructor principal
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // constructor de copia: llama al constructor principal
    public Person(Person p) : this(p.firstName, p.lastName, p.age)
    {
    }

    // constructor sin parámetros: también llama al constructor principal
    public Person() : this("?", "?", 0)
    {
    }

    // identidad de la persona
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • líneas 17–21: el constructor “principal” inicializa los tres campos. Como sus parámetros tienen los mismos nombres que los campos, estos se distinguen mediante [this];
  • línea 25: el constructor de copia. La notación [: this(p.firstName, p.lastName, p.age)] significa que, antes de ejecutar el cuerpo (vacío) del constructor, se ejecuta el constructor de la misma clase que acepta tres parámetros: [string], [string], [int]. Esto se denomina encadenamiento de constructores. De este modo, el código de inicialización se escribe una sola vez;
  • línea 30: el constructor sin parámetros, que también está encadenado al constructor principal. Como la clase ha declarado constructores, ya no tiene un constructor predeterminado: si queremos poder escribir [new Person()], debemos declararlo;
  • Líneas 11–14: las dos cadenas ya no se inicializan en la declaración. Ya no es necesario: todos los constructores, ya sea directamente o por encadenamiento, les asignan un valor, y el compilador lo verifica.

El curso de 2008 hacía que los constructores llamaran al método [Initialize]. El encadenamiento con [this(...)] es preferible: con los tipos que admiten valores NULL habilitados, el compilador no inspecciona el contenido de los métodos llamados por un constructor y señalaría que los campos [firstName] y [lastName] podrían quedar con el valor [null] al final de la construcción.

Resultados:

1
2
3
4
> dotnet run classes-02.cs
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referencias a objetos

Usamos la clase [Person] del programa anterior, omitiendo su constructor sin parámetros pero incluyendo el método [Initialize(string, string, int)] del inicio del capítulo. El programa de prueba queda así [classes-03.cs] (no reproducimos la clase):

// referencias de objetos
// p1
Person p1 = new Person("Jean", "Dupont", 30);
Console.Write("p1="); p1.Identify();
// p2 referencia el mismo objeto que p1
Person p2 = p1;
Console.Write("p2="); p2.Identify();
// p3 referencia un objeto que es una copia del objeto referenciado por p1
Person p3 = new Person(p1);
Console.Write("p3="); p3.Identify();
// cambiamos el estado del objeto referenciado por p1
p1.Initialize("Micheline", "Benoît", 67);
Console.Write("p1="); p1.Identify();
// como p2 = p1, el objeto referenciado por p2 cambió de estado
Console.Write("p2="); p2.Identify();
// p3 no referencia el mismo objeto que p1: el objeto referenciado por p3 no cambió
Console.Write("p3="); p3.Identify();
// ¿son p1 y p2 la misma referencia? ¿y p1 y p3?
Console.WriteLine($"p1 == p2 : {p1 == p2}, p1 == p3 : {p1 == p3}");

Resultados:

1
2
3
4
5
6
7
8
> dotnet run classes-03.cs
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : True, p1 == p3 : False

Cuando se declara la variable [p1] como [Person p1 = new Person("Jean", "Dupont", 30);] (línea 3), [p1] hace referencia al objeto [Person("Jean", "Dupont", 30)] pero no es el objeto en sí. En C se hablaría de un puntero, es decir, la dirección del objeto creado. Si luego escribimos [p1 = null;], no se modifica el objeto [Person("Jean", "Dupont", 30)] sino que es la referencia [p1] la que cambia de valor. El objeto se “perderá” si ninguna otra variable lo referencia: la memoria que ocupa será recuperada posteriormente por el recolector de basura de .NET.

Cuando escribimos [Person p2 = p1;] (línea 6), inicializamos la referencia [p2]: esta “apunta” al mismo objeto (hace referencia al mismo objeto) que la referencia [p1]. Así, si se modifica el objeto “apuntado” (o referenciado) por [p1], también se modifica el objeto referenciado por [p2] (líneas 5–6 de los resultados).

Cuando se escribe [Person p3 = new Person(p1);] (línea 9), se crea un nuevo objeto [Person]. Este nuevo objeto será referenciado por [p3]. Si se modifica el objeto referenciado por [p1], el objeto referenciado por [p3] (línea 7) permanece sin cambios.

Por último, en la línea 19, el operador [==], aplicado a dos referencias a objetos, indica si estas hacen referencia al mismo objeto: [p1] y [p2] hacen referencia al mismo objeto, mientras que [p1] y [p3] hacen referencia a dos objetos distintos, aunque tienen el mismo contenido (línea 8).

4.1.12. Paso de parámetros que son referencias a objetos

En el capítulo anterior examinamos cómo se pasan los parámetros de las funciones cuando son de tipos simples ([int], [double], …). Veamos qué ocurre cuando el parámetro es una referencia a un objeto. Para ello, usaremos la clase [StringBuilder] de .NET. Un objeto [string] no se puede modificar: una operación como [s.ToUpper()] devuelve un nuevo objeto [string]. Un objeto [StringBuilder], en cambio, es una cadena mutable: su método [Append] agrega caracteres a la cadena sin crear un nuevo objeto.

El programa [classes-04.cs] es el siguiente:

using System.Text;

// paso de parámetros de tipo referencia a objeto
StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1"), sb2 = new StringBuilder("test2");
Console.WriteLine($"In calling function before call: sb0={sb0}, sb1={sb1}, sb2={sb2}");
ChangeStringBuilder(sb0, sb1, ref sb2, out StringBuilder sb3);
Console.WriteLine($"In calling function after call: sb0={sb0}, sb1={sb1}, sb2={sb2}, sb3={sb3}");

// la función llamada
static void ChangeStringBuilder(StringBuilder sbf0, StringBuilder sbf1, ref StringBuilder sbf2, out StringBuilder sbf3)
{
    Console.WriteLine($"Start of called function: sbf0={sbf0}, sbf1={sbf1}, sbf2={sbf2}");
    sbf0.Append("*****");
    sbf1 = new StringBuilder("test1*****");
    sbf2 = new StringBuilder("test2*****");
    sbf3 = new StringBuilder("test3*****");
    Console.WriteLine($"End of called function: sbf0={sbf0}, sbf1={sbf1}, sbf2={sbf2}, sbf3={sbf3}");
}
  • línea 1: la clase [StringBuilder] pertenece al espacio de nombres [System.Text], que no forma parte de los espacios de nombres importados implícitamente;
  • línea 4: tres [sb0, sb1, sb2] referencias a objetos de tipo [StringBuilder];
  • línea 6: se pasan a la función [ChangeStringBuilder] con modos diferentes: [sb0] y [sb1] con el modo predeterminado, [sb2] con la palabra clave [ref], y una cuarta referencia, [sb3], declarada en la propia llamada ([out StringBuilder sb3]), con la palabra clave [out];
  • líneas 10–17: una función local con los parámetros formales [sbf0, sbf1, sbf2, sbf3]. Las relaciones entre los parámetros formales [sbfi] y los parámetros reales [sbi] son las siguientes:
    • [sbf0] y [sb0] son, al iniciar la función, dos referencias distintas que apuntan al mismo objeto (las referencias se pasan por valor);
    • lo mismo ocurre con [sbf1] y [sb1];
    • [sbf2] y [sb2] son una sola y misma referencia (palabra clave [ref]);
    • [sbf3] y [sb3] también son la misma referencia (palabra clave [out]), que la función debe inicializar.

Resultados:

1
2
3
4
5
> dotnet run classes-04.cs
In calling function before call: sb0=test0, sb1=test1, sb2=test2
Start of called function: sbf0=test0, sbf1=test1, sbf2=test2
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****, sbf3=test3*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****, sb3=test3*****

Explicaciones:

  • [sb0] y [sbf0] son dos referencias distintas al mismo objeto. Este objeto fue modificado mediante [sbf0] (línea 13). Esta modificación es visible mediante [sb0] (línea 5);
  • [sb1] y [sbf1] son dos referencias distintas al mismo objeto. [sbf1] recibe un nuevo valor dentro de la función y ahora apunta a un nuevo objeto (línea 14). Esto no cambia el valor de [sb1], que sigue apuntando al objeto original, sin modificar;
  • [sb2] y [sbf2] son la misma referencia. [sbf2] ahora apunta a un nuevo objeto (línea 15). Dado que [sbf2] y [sb2] son una sola y misma entidad, [sb2] también apunta a este nuevo objeto;
  • antes de la llamada a la función, [sb3] no tenía valor. Después de la llamada, [sb3] hace referencia al objeto creado por la función (línea 16).

4.1.13. Objetos temporales

En una expresión, se puede llamar explícitamente al constructor de un objeto: el objeto se crea, pero no hay ninguna variable para acceder a él posteriormente (por ejemplo, para modificarlo). Este objeto temporal se crea para evaluar la expresión y luego se descarta. El espacio de memoria que ocupaba será recuperado automáticamente más adelante por el recolector de basura, cuya función es recuperar el espacio de memoria ocupado por objetos que ya no están referenciados por los datos del programa.

Consideremos el siguiente programa, [classes-05.cs], donde los constructores de la clase [Person] muestran un mensaje:

// objetos temporales
new Person(new Person("Jean", "Dupont", 30)).Identify();

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // constructores
    public Person(string firstName, string lastName, int age)
    {
        Console.WriteLine("Constructor Person(string, string, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p)
    {
        Console.WriteLine("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidad de la persona
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • Línea 2: el objeto [Person("Jean", "Dupont", 30)] se construye y luego se pasa al constructor de copia, que construye un segundo objeto; a continuación se llama al método [Identify] sobre ese objeto. Ninguno de los dos objetos está referenciado por una variable.

Resultados:

1
2
3
4
> dotnet run classes-05.cs
Constructor Person(string, string, int)
Constructor Person(Person)
[Jean, Dupont, 30]

Los resultados muestran la creación sucesiva de los dos objetos temporales.

4.1.14. Métodos para leer y escribir campos privados

Agregamos los métodos necesarios a la clase [Person] para leer o modificar el estado de los campos de los objetos ([classes-06.cs]):

// métodos de lectura (getters) y de escritura (setters) de atributos privados
Person p = new Person("Jean", "Michelin", 34);
Console.WriteLine("p=(" + p.GetFirstName() + "," + p.GetLastName() + "," + p.GetAge() + ")");
p.SetAge(56);
Console.WriteLine("p=(" + p.GetFirstName() + "," + p.GetLastName() + "," + p.GetAge() + ")");

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // constructor
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getters
    public string GetFirstName()
    {
        return firstName;
    }

    public string GetLastName()
    {
        return lastName;
    }

    public int GetAge()
    {
        return age;
    }

    // setters
    public void SetFirstName(string firstName)
    {
        this.firstName = firstName;
    }

    public void SetLastName(string lastName)
    {
        this.lastName = lastName;
    }

    public void SetAge(int age)
    {
        this.age = age;
    }
}
  • líneas 22–35: los métodos de lectura, llamados getters;
  • líneas 38–51: los métodos de escritura, llamados setters.

Resultados:

1
2
3
> dotnet run classes-06.cs
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

Este enfoque es típico del lenguaje Java. C# ofrece un mecanismo más elegante: las propiedades.

4.1.15. Propiedades

Existe otra forma de acceder a los campos de una clase: crear propiedades. Estas permiten manipular campos privados como si fueran públicos.

Una propiedad permite leer ([get]) o asignar ([set]) el valor de un campo. Una propiedad se declara de la siguiente manera:

1
2
3
4
5
public Type Property
{
    get { ... }
    set { ... }
}

donde [Type] es generalmente el tipo del campo gestionado por la propiedad. Puede tener dos métodos llamados [get] y [set]. El método [get] suele encargarse de devolver el valor del campo que gestiona (podría devolver otra cosa; nada lo impide). El método [set] recibe un parámetro llamado [value], que normalmente asigna al campo que gestiona. Puede aprovechar la ocasión para verificar la validez del valor recibido y, si es necesario, lanzar una excepción si el valor no es válido.

Consideremos el programa [classes-07.cs], donde los accesores y mutadores anteriores se han reemplazado por propiedades de lectura y escritura:

// propiedades
Person p = new Person("Jean", "Michelin", 34);
Console.WriteLine("p=(" + p.FirstName + "," + p.LastName + "," + p.Age + ")");
p.Age = 56;
Console.WriteLine("p=(" + p.FirstName + "," + p.LastName + "," + p.Age + ")");
try
{
    p.Age = -4;
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
// inicializador de objeto: constructor sin parámetros y luego asignación de las propiedades
Person p2 = new Person { Age = 7, FirstName = "Arthur", LastName = "Martin" };
Console.WriteLine($"p2=({p2.FirstName},{p2.LastName},{p2.Age})");
try
{
    Person p3 = new Person { FirstName = "Paul", LastName = " " };
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}

public class Person
{
    // atributos
    private string firstName = "";
    private string lastName = "";
    private int age;

    // constructores
    public Person(string firstName, string lastName, int age)
    {
        // pasamos por las propiedades para aprovechar sus validaciones
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public Person()
    {
    }

    // propiedades
    public string FirstName
    {
        get { return firstName; }
        set
        {
            // ¿nombre válido?
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException($"invalid first name ({value})");
            }
            firstName = value;
        }
    }

    public string LastName
    {
        get { return lastName; }
        set
        {
            // ¿apellido válido?
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException($"invalid last name ({value})");
            }
            lastName = value;
        }
    }

    public int Age
    {
        get { return age; }
        set
        {
            // ¿edad válida?
            if (value < 0)
            {
                throw new ArgumentException($"invalid age ({value})");
            }
            age = value;
        }
    }
}

Los métodos [set] de las tres propiedades validan el valor recibido (líneas 52–57, 66–71, 80–85).

  • Líneas 53–55: el método [string.IsNullOrWhiteSpace] devuelve [true] si la cadena es [null], está vacía o consta solo de espacios. La excepción lanzada es de tipo [ArgumentException], la excepción definida por .NET para señalar un parámetro no válido. La versión de 2008 lanzaba una excepción del tipo general [Exception], lo que obliga al código que llama a capturar todas las excepciones;
  • líneas 34–39: el constructor inicializa el objeto mediante propiedades en lugar de campos. Esto le permite aprovechar las validaciones realizadas por los métodos [set], que se implementan en un solo lugar.

¿Cómo se llaman los métodos [get] y [set] ? En la instrucción de la línea 3, el programa intenta obtener los valores de las propiedades [FirstName], [LastName] y [Age] de la persona [p]. Se llama entonces al método [get] de estas propiedades, que devuelve el valor del campo que gestionan. En la instrucción [p.Age = 56;] (línea 4), queremos asignar el valor de la propiedad [Age]. Se llama entonces al método [set] de esta propiedad. Este recibe 56 como parámetro [value].

Se dice que una propiedad [P] de una clase [C] que define únicamente el método [get] es de solo lectura. Si [c] es un objeto de la clase [C], el compilador rechazará la operación [c.P = value].

Resultados:

1
2
3
4
5
6
> dotnet run classes-07.cs
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
invalid age (-4)
p2=(Arthur,Martin,7)
invalid last name ( )

La línea 4 de los resultados muestra que la asignación [p.Age = -4] (línea 8) fue rechazada por el método [set] de la propiedad [Age].

4.1.16. Inicializadores de objeto

Las propiedades pueden usarse junto con un constructor mediante la siguiente sintaxis:

Class obj = new Class(...) { Property1 = val1, Property2 = val2, ... };

Esta sintaxis, conocida como inicializador de objeto, equivale al siguiente código:

1
2
3
4
Class obj = new Class(...);
obj.Property1 = val1;
obj.Property2 = val2;
...

El orden de las propiedades no importa. En el programa anterior [classes-07.cs], la clase [Person] tiene un constructor sin parámetros que no inicializa nada. Volvamos al final del programa principal:

// inicializador de objeto: constructor sin parámetros y luego asignación de las propiedades
Person p2 = new Person { Age = 7, FirstName = "Arthur", LastName = "Martin" };
Console.WriteLine($"p2=({p2.FirstName},{p2.LastName},{p2.Age})");
try
{
    Person p3 = new Person { FirstName = "Paul", LastName = " " };
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}

Línea 15: se usa el constructor sin parámetros para crear una persona, que luego se inicializa mediante sus propiedades. Podríamos haber escrito [new Person() { Age = 7, ... }], pero los paréntesis no son obligatorios para el constructor sin parámetros en esta sintaxis. Los métodos [set] se llaman efectivamente: en la línea 19, el nombre que contiene un espacio es rechazado (línea 6 de los resultados).

4.1.17. Propiedades automáticas

En muchos casos, los métodos [get] y [set] de una propiedad simplemente leen y escriben un campo privado sin ningún procesamiento adicional. En tales casos, puede usarse una propiedad automática declarada de la siguiente manera:

public Type Property { get; set; }

El campo privado asociado a la propiedad no se declara; el compilador lo genera automáticamente y solo se puede acceder a él a través de su propiedad. Así, en lugar de escribir el campo [firstName] y la propiedad [FirstName] para el programa [classes-07.cs], se puede escribir:

    public string FirstName { get; set; } = "";

sin declarar el campo privado [firstName]. La expresión [= ""] que sigue a la propiedad es el valor inicial del campo oculto. La diferencia entre las dos propiedades es que la primera valida el nombre en [set], mientras que la segunda no realiza ninguna validación.

¿Usar la propiedad automática [FirstName] equivale a declarar un campo público [public string FirstName;]? Para el usuario de la clase, la sintaxis es la misma. Sin embargo, no se recomienda declarar un campo de una clase como público: viola el concepto de encapsulación del estado de un objeto, que debe ser privado y estar expuesto mediante métodos públicos. Con una propiedad automática, se pueden agregar verificaciones posteriormente en [set] sin cambiar el código de los usuarios de la clase.

Las propiedades automáticas tienen varias variantes, como lo muestra el programa [classes-08.cs]:

// propiedades automáticas, de solo lectura, init y required
var p = new Person("Dupont", 30) { FirstName = "Jean", City = "Angers" };
Console.WriteLine(p.Identity);
// FirstName es de lectura / escritura
p.FirstName = "Jacques";
// Age solo puede modificarse dentro de la clase
p.GrowOlder();
Console.WriteLine(p.Identity);
// el compilador rechaza las líneas siguientes
// p.LastName = "Durand"; // LastName es de solo lectura
// p.Age = 40;           // el set de Age es privado
// p.City = "Paris";     // City solo se puede asignar al crear el objeto

// propiedad obligatoria (required)
var c = new Contact { Email = "jean.dupont@example.com" };
Console.WriteLine($"Contact: {c.Email}, {c.Phone}");
// var c2 = new Contact();   // rechazado: la propiedad obligatoria Email no está inicializada

public class Person
{
    // constructor
    public Person(string lastName, int age)
    {
        LastName = lastName;
        Age = age;
    }

    // propiedad automática de lectura / escritura, con un valor inicial
    public string FirstName { get; set; } = "";
    // propiedad automática de solo lectura: asignada por el constructor
    public string LastName { get; }
    // propiedad automática cuya escritura está reservada a la clase
    public int Age { get; private set; }
    // propiedad init: asignada por el constructor o por un inicializador de objeto
    public string City { get; init; } = "?";
    // propiedad calculada de solo lectura (miembro con cuerpo de expresión)
    public string Identity => $"[{FirstName}, {LastName}, {Age}, {City}]";

    // método con cuerpo de expresión
    public void GrowOlder() => Age++;
}

public class Contact
{
    // la propiedad debe inicializarse al crear el objeto
    public required string Email { get; init; }
    // propiedad opcional
    public string Phone { get; init; } = "unknown";
}
  • línea 29: una propiedad automática de lectura y escritura con un valor inicial;
  • línea 31: una propiedad automática de solo lectura: no tiene [set] y solo puede asignarse mediante un constructor (línea 24);
  • línea 33: el método [set] puede tener un acceso más restringido que la propiedad: aquí, la propiedad [Age] puede ser leída por todos, pero solo puede ser modificada por los métodos de la clase, como [GrowOlder] (línea 40);
  • línea 35: una propiedad [init] (C# 9): puede asignarse mediante un constructor o un inicializador de objeto (línea 2), pero no después. Es una forma de crear objetos inmutables aprovechando la sintaxis de los inicializadores de objeto;
  • línea 37: una propiedad de solo lectura cuyo valor se calcula. La notación [=> expression] es una forma abreviada de [get { return expression; }]. También se aplica a los métodos (línea 40): se habla entonces de miembros con cuerpo de expresión;
  • línea 46: una propiedad requerida (C# 11): la palabra clave [required] obliga al código que crea un objeto [Contact] a inicializar la propiedad [Email] en un inicializador de objeto (línea 15). El compilador rechaza la línea 17 si se quita el comentario;
  • líneas 10–12: tres instrucciones que el compilador rechaza, por las razones indicadas en los comentarios.

Recuerde que con la palabra clave [var] (línea 2), el tipo de la variable se infiere de la expresión que la inicializa, en este caso [Person].

Resultados:

1
2
3
4
> dotnet run classes-08.cs
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown

Por último, una propiedad automática puede declararse virtual ([public virtual string Prop { get; set; }]) y sobrescribirse en una clase derivada, por ejemplo, para agregar una validación en [set]. Las palabras clave [virtual] y [override] se presentan junto con la herencia.

4.1.18. La palabra clave field (C# 14)

Entre la propiedad automática, que no realiza ninguna validación, y la propiedad completa del programa [classes-07.cs], que exige declarar un campo, C# 14 ofrece una opción intermedia: en los accesores de una propiedad, la palabra clave [field] hace referencia al campo creado por el compilador. Esto permite escribir una validación sin declarar un campo:

// la palabra clave field (C# 14)
var p = new Person { FirstName = "  jean ", LastName = "Dupont", Age = 30 };
Console.WriteLine(p.Identity);
try
{
    p.LastName = "";
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
try
{
    p.Age = -4;
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
Console.WriteLine(p.Identity);

public class Person
{
    // propiedades con validaciones, sin campo declarado:
    // [field] designa el campo creado por el compilador
    public string FirstName
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException($"invalid first name ({value})")
            : value.Trim();
    } = "";   // valor inicial del campo oculto

    public string LastName
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException($"invalid last name ({value})")
            : value.Trim();
    } = "";

    public int Age
    {
        get;
        set
        {
            if (value < 0)
            {
                throw new ArgumentException($"invalid age ({value})");
            }
            field = value;
        }
    }

    // identidad
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";
}
  • Líneas 26–31: la propiedad [FirstName]. Su método [get] es automático ([get;]): devuelve el valor del campo oculto. Su método [set] verifica el valor recibido y lo asigna, sin espacios iniciales ni finales, al campo oculto designado por [field]. La expresión [condition ? throw ... : value] utiliza una expresión throw: si la condición es verdadera, se lanza una excepción; de lo contrario, la expresión se evalúa como [value.Trim()];
  • línea 32: el valor inicial del campo oculto;
  • líneas 42–51: un [set] escrito con un bloque de instrucciones.

Resultados:

1
2
3
4
5
> dotnet run classes-09.cs
[jean, Dupont, 30]
invalid last name ()
invalid age (-4)
[jean, Dupont, 30]

El nombre “jean”, proporcionado rodeado de espacios (línea 2 del programa), se almacenó sin ellos (línea 2 de los resultados).

4.1.19. Métodos y atributos de clase

Supongamos que queremos contar el número de objetos [Person] creados en una aplicación. Podríamos llevar un contador por nuestra cuenta, pero corremos el riesgo de pasar por alto objetos temporales que se crean aquí y allá. Parece más seguro incluir una instrucción en los constructores de la clase [Person] que incremente un contador. Este contador no puede ser un campo normal, ya que cada objeto tiene sus propios campos: es un campo de la clase misma, no de una instancia particular de esa clase. Lo declaramos con la palabra clave [static]:

    private static long nbPersons;

Para referirnos a él, escribimos [Person.nbPersons] para indicar que es un campo de la clase [Person] misma. Aquí hemos creado un campo privado al que no se puede acceder directamente desde fuera de la clase. Por lo tanto, creamos una propiedad pública para dar acceso al campo de clase [nbPersons]. Para devolver el valor de [nbPersons], el método [get] de esta propiedad no requiere un objeto [Person] específico: por eso también necesitamos una propiedad declarada como [static], que se llamará desde el exterior con la sintaxis [Person.NbPersons]. Este es un ejemplo, [classes-10.cs]:

// miembros de clase (static)
Person p1 = new Person("Jean", "Dupont", 30);
Person p2 = new Person(p1);
new Person(p1);
Console.WriteLine($"Number of persons created: {Person.NbPersons}");
// un método de clase
Person p3 = Person.Unknown();
p3.Identify();
Console.WriteLine($"Number of persons created: {Person.NbPersons}");

public class Person
{
    // atributo de clase
    private static long nbPersons;

    // propiedad de clase
    public static long NbPersons
    {
        get { return nbPersons; }
    }

    // método de clase
    public static Person Unknown()
    {
        return new Person("?", "?", 0);
    }

    // atributos de instancia
    private string firstName;
    private string lastName;
    private int age;

    // constructores
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) : this(p.firstName, p.lastName, p.age)
    {
    }

    // identidad de la persona
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • línea 14: el campo de clase. Como todo campo numérico, se inicializa en 0;
  • líneas 17–19: la propiedad de clase de solo lectura. Podría haberse escrito de forma más sencilla como [public static long NbPersons { get; private set; }];
  • líneas 23–25: un método de clase. Se llama usando el nombre de la clase: [Person.Unknown()] (línea 7). Un método de clase no tiene objeto actual: la palabra clave [this] no tiene sentido aquí, y solo puede acceder directamente a los miembros [static] de la clase;
  • Línea 39: el constructor principal incrementa el contador. El constructor de copia, que está encadenado al constructor principal, también lo incrementa, por lo tanto.

Resultados:

1
2
3
4
> dotnet run classes-10.cs
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

El programa contó correctamente el objeto temporal creado en la línea 4. Hemos usado miembros de clase desde el principio: [Console.WriteLine], [int.Parse] y [Math.Sqrt] son métodos [static]. [Console] y [Math] son incluso clases estáticas ([static class]): contienen únicamente miembros de tipo [static], y no se pueden crear instancias de ellas.

4.1.20. Un arreglo de personas

Un objeto es un dato como cualquier otro y, como tal, varios objetos pueden agruparse en un arreglo [classes-11.cs]:

// un arreglo de personas
Person[] friends = new Person[3];
friends[0] = new Person("Jean", "Dupont", 30);
friends[1] = new Person("Sylvie", "Vartan", 52);
friends[2] = new Person("Neil", "Armstrong", 66);
// visualización
foreach (Person friend in friends)
{
    friend.Identify();
}
  • Línea 2: crea un arreglo de 3 elementos de tipo [Person]. Estos 3 elementos se inicializan aquí con el valor [null], es decir, no hacen referencia a ningún objeto. Técnicamente, se habla de un “arreglo de objetos”, aunque solo es un arreglo de referencias a objetos. La creación del arreglo, que es en sí mismo un objeto (como indica [new]), no crea ningún objeto del mismo tipo que sus elementos; esto debe hacerse posteriormente. Observe que el compilador no señala que los elementos de un arreglo de tipo [Person[]] son iguales a [null] inmediatamente después de su creación: es una limitación del análisis de tipos que admiten valores NULL;
  • líneas 3–5: crean 3 objetos de tipo [Person];
  • líneas 7–9: muestran el contenido del arreglo [friends].

La clase [Person], declarada a continuación, se deriva del programa [classes-03.cs], reducida a su constructor de tres parámetros y su método [Identify]. Resultados:

1
2
3
4
> dotnet run classes-11.cs
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.21. Expresiones new() con tipo de destino

Cuando el tipo del objeto que se va a crear se conoce por el contexto, C# 9 permite omitir el nombre de la clase después de [new]. El programa [classes-12.cs] lo demuestra:

// inicializadores de objeto y expresiones new() con tipo de destino
// el tipo del objeto creado se infiere del tipo de la variable
Person p1 = new("Jean", "Dupont", 30);
Person p2 = new() { FirstName = "Arthur", LastName = "Martin", Age = 7 };
// un arreglo inicializado con una expresión de colección
Person[] friends =
[
    p1,
    p2,
    new("Sylvie", "Vartan", 52),
    new() { FirstName = "Neil", LastName = "Armstrong", Age = 66 },
];
foreach (Person friend in friends)
{
    Console.WriteLine(friend.Identity);
}
// new() con tipo de destino en una llamada a método: el tipo es el del parámetro
Display(new("Pauline", "Leduc", 12));

// una función local
static void Display(Person p)
{
    Console.WriteLine($"Display: {p.Identity}");
}

public class Person
{
    // constructores
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public Person()
    {
    }

    // propiedades automáticas
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
    public int Age { get; set; }
    // identidad
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";
}
  • Línea 3: el tipo del objeto creado por [new(...)] es el de la variable que lo recibe, [Person]. Esta sintaxis es lo opuesto de [var]: con [var], el tipo de la variable se infiere de la expresión; con [new()], el tipo del objeto se infiere de la variable;
  • línea 4: [new()] con un inicializador de objeto;
  • líneas 6–11: un arreglo creado y poblado mediante una expresión de colección (C# 12): los elementos se encierran entre corchetes y se separan por comas. El tipo de los elementos, [Person], es conocido: [new(...)] basta para crearlos;
  • línea 18: el tipo del objeto creado es el del parámetro de la función [Display].

Resultados:

1
2
3
4
5
6
> dotnet run classes-12.cs
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]

4.2. La herencia mediante un ejemplo

4.2.1. Descripción general

Aquí abordamos el concepto de herencia. El propósito de la herencia es “personalizar” una clase existente para que satisfaga nuestras necesidades. Supongamos que queremos crear una clase llamada [Teacher]: un docente es un tipo específico de persona. Tiene atributos que otras personas no tienen: la materia que enseña, por ejemplo. Pero también tiene los atributos comunes a todas las personas: nombre, apellido y edad. Un docente es, por lo tanto, un miembro de pleno derecho de la clase [Person] pero tiene atributos adicionales. En lugar de crear una clase [Teacher] desde cero, preferimos apoyarnos en la clase existente [Person] y adaptarla a las características específicas de los docentes. El concepto de herencia nos permite hacerlo.

Para indicar que la clase [Teacher] hereda las propiedades de la clase [Person], escribimos:

public class Teacher : Person

[Person] se denomina clase padre (o base), y [Teacher] se denomina clase derivada (o hija). Un objeto [Teacher] tiene todas las características de un objeto [Person]: tiene los mismos campos y métodos. Estos campos y métodos de la clase padre no se repiten en la definición de la clase hija; simplemente se especifican los campos y métodos que agrega la clase hija. Una clase de C# solo puede derivar de una única clase padre.

Los ejemplos de esta sección son dos proyectos de consola, [Inheritance1] y [Inheritance2], de la solución [04-classes.slnx]. En el proyecto [Inheritance1], la clase [Person] se define de la siguiente manera: [Person.cs]:

namespace Inheritance1;

public class Person
{
    // propiedad de clase: el número de personas creadas
    public static long NbPersons { get; private set; }

    // constructor
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
        NbPersons++;
        Console.WriteLine("Constructor Person(string, string, int)");
    }

    // propiedades
    public string FirstName
    {
        get;
        set => field = Check(value, "first name");
    } = "";

    public string LastName
    {
        get;
        set => field = Check(value, "last name");
    } = "";

    public int Age
    {
        get;
        set => field = value >= 0 ? value : throw new ArgumentException($"invalid age ({value})");
    }

    // identidad de la persona
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";

    // validación de una cadena obligatoria
    private static string Check(string text, string label)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            throw new ArgumentException($"invalid {label} ({text})");
        }
        return text;
    }
}
  • línea 6: el contador de personas del párrafo anterior, esta vez escrito como una propiedad automática de clase cuya definición está reservada para la clase;
  • líneas 9–15: el constructor inicializa el objeto mediante sus propiedades y muestra un mensaje de progreso;
  • líneas 19–34: tres propiedades que validan sus valores mediante la palabra clave [field]. Las validaciones del nombre y del apellido, que son idénticas, se factorizan en el método de clase privado [Check] (líneas 41–47);
  • línea 38: el método [Identify] de los ejemplos anteriores se ha reemplazado por la propiedad de solo lectura [Identity], que devuelve la identidad de la persona en lugar de mostrarla.

Creamos una clase llamada [Teacher] que hereda de la clase [Person]: [Teacher.cs]:

namespace Inheritance1;

public class Teacher : Person
{
    // constructor
    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        // almacenamos la sección mediante la propiedad Section
        Section = section;
        // seguimiento
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

    // propiedad Section
    public int Section { get; set; }

    // propiedad Identity: oculta (new) la de la clase padre
    public new string Identity => $"Teacher[{base.Identity},{Section}]";
}

La clase [Teacher] agrega a los métodos y propiedades de la clase [Person]:

  • línea 3: la clase [Teacher] deriva de la clase [Person];
  • línea 16: una propiedad [Section], que es el número de la sección a la que pertenece el docente dentro del cuerpo docente (aproximadamente una sección por materia);
  • líneas 6–12: un constructor que sirve para inicializar todas las propiedades de un docente;
  • línea 19: una nueva propiedad, [Identity], que se tratará con más detalle más adelante.

4.2.2. Creación de un objeto Teacher

Una clase hija no hereda los constructores de su clase padre. Debe definir los suyos propios. El constructor de la clase [Teacher] es el siguiente:

    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        // almacenamos la sección mediante la propiedad Section
        Section = section;
        // seguimiento
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

La declaración de las líneas 6–7 especifica que el constructor recibe cuatro parámetros: [firstName], [lastName], [age], [section], y pasa tres ([firstName], [lastName], [age]) a su clase base, en este caso la clase [Person]. Sabemos que esta clase tiene un constructor, [Person(string, string, int)], que nos permitirá crear una persona con los parámetros pasados. Una vez completada la construcción de la parte [Person], la construcción del objeto [Teacher] continúa con la ejecución del cuerpo del constructor (línea 10).

Observe que, a la izquierda del signo =, se utiliza la propiedad [Section]. Si esta propiedad realizara verificaciones de validez, el constructor se beneficiaría de ellas. Esto evita tener que colocar estas verificaciones en dos lugares distintos: el constructor y la propiedad.

En resumen, el constructor de una clase derivada:

  • pasa a su clase base los parámetros que esta necesita para construirse;
  • usa los parámetros restantes para inicializar sus propios miembros.

Podríamos haber optado por escribir:

1
2
3
4
5
6
7
public Teacher(string firstName, string lastName, int age, int section)
{
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    Section = section;
}

Esto es imposible, por dos razones. Primero, la clase *[Person] no tiene un constructor sin parámetros: en ausencia de ***[: base(...)], el compilador intenta llamar a ese constructor e informa un error. Segundo, aunque existieran los campos privados [firstName], [lastName] y [age] (aquí son los campos ocultos de las propiedades), solo los objetos de la clase [Person] tienen acceso directo a ellos. Todos los demás objetos, incluidos los de clases derivadas como en este caso, deben acceder a ellos mediante miembros públicos (o protegidos). Habría sido distinto si la clase *[Person] hubiera declarado estos campos como protegidos (*[protected]*): entonces habría permitido a las clases derivadas acceder a ellos directamente. Por lo tanto, usar el constructor de la clase padre es la solución correcta y el enfoque estándar: al construir un objeto hijo, primero se llama al constructor del objeto padre y luego se completan las inicializaciones específicas del objeto hijo ([Section]* en nuestro ejemplo).

Si la clase [Teacher] no definiera una propiedad [Identity], la expresión [e.Identity], donde [e] es un docente, haría referencia a la propiedad [Identity] heredada de la clase [Person]: es pública y, por herencia, se convierte en una propiedad pública de la clase [Teacher]. Esto daría entonces la identidad de la parte [Person] del docente, sin su sección.

4.2.3. Ocultar una propiedad o un método: la palabra clave new

Para obtener la identidad completa de un docente, la clase [Teacher] define su propia propiedad [Identity]:

    // propiedad Identity: oculta (new) la de la clase padre
    public new string Identity => $"Teacher[{base.Identity},{Section}]";

La propiedad [Identity] de la clase [Teacher] se apoya en la propiedad [Identity] de su clase padre, designada como [base.Identity], para obtener la parte “Person” y luego la complementa con la sección, que es específica de la clase [Teacher].

Consideremos un objeto docente [E]. Este objeto contiene un objeto [Person]:

Image

La propiedad [Identity] está definida tanto en la clase [Teacher] como en su clase padre [Person]. En la clase hija [Teacher], la propiedad [Identity] va precedida de la palabra clave [new] para indicar que se define intencionalmente una nueva propiedad, [Identity], para la clase [Teacher] (sin [new], el compilador emite una advertencia). La clase [Teacher] ahora tiene dos propiedades, [Identity]:

  • una heredada de la clase padre [Person];
  • la suya propia.

Si [E] es un objeto [Teacher], [E.Identity] hace referencia a la propiedad [Identity] de la clase [Teacher]. Se dice que la propiedad [Identity] de la clase hija enmascara (oculta) la propiedad [Identity] de la clase padre. En términos generales, si [O] es un objeto y [M] es un método, para ejecutar el método [O.M], el compilador busca un método [M] en el siguiente orden:

  • en la clase del objeto [O];
  • en su clase padre, si la tiene;
  • en la clase padre de su clase padre, si existe;
  • y así sucesivamente.

Por lo tanto, la herencia permite que la clase hija redefina métodos y propiedades con los mismos nombres que los de la clase padre. Esto es lo que permite adaptar la clase hija a sus propias necesidades.

El programa de prueba [Program.cs] del proyecto [Inheritance1] es el siguiente:

using Inheritance1;

// un profesor
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
// la propiedad Identity de la clase Teacher
Console.WriteLine(e.Identity);
// la propiedad Identity de la clase Person sigue ahí
Console.WriteLine(((Person)e).Identity);
// una persona
Person p = new Person("Jean", "Dupont", 30);
// el método Display recibe una Person o un objeto de una clase derivada
Display(e);
Display(p);
// el método ToString heredado de la clase object
Console.WriteLine(e.ToString());
Console.WriteLine(p.ToString());
Console.WriteLine($"Number of persons created: {Person.NbPersons}");

// muestra la identidad de p
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}
  • línea 4: crea un docente;
  • línea 6: muestra su identidad, la de la clase [Teacher];
  • línea 8: el operador de conversión [(Person)] trata el objeto [e] como un [Person]: entonces se usa la propiedad [Identity] de la clase [Person] ;
  • líneas 12–13: llamada a la función [Display] (líneas 20–22) con un docente y luego con una persona. Volveremos sobre esto en el siguiente párrafo;
  • líneas 15–16: llamada al método [ToString] sobre ambos objetos. También volveremos sobre esto.

Resultados:

> dotnet run
Constructor Person(string, string, int)
Constructor Teacher(string, string, int, int)
Teacher[[Lucile, Dumas, 56],61]
[Lucile, Dumas, 56]
Constructor Person(string, string, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Inheritance1.Teacher
Inheritance1.Person
Number of persons created: 2

Podemos observar que:

  • se creó un objeto [Person] (línea 2) antes que el objeto [Teacher] (línea 3);
  • [e.Identity] proporcionó la identidad completa del docente (línea 4), y [((Person)e).Identity] proporcionó la identidad de su parte [Person] (línea 5).

4.2.4. Polimorfismo

Consideremos una jerarquía de clases: C0 ← C1 ← C2 ← … ← Cn, donde Ci ← Cj indica que la clase Cj deriva de la clase Ci. Esto implica que la clase Cj tiene todas las características de la clase Ci más otras adicionales. Sean Oi objetos de tipo Ci. Es válido escribir [Oi = Oj] con j > i. En efecto, por herencia, la clase Cj tiene todas las características de la clase Ci más otras adicionales. Por lo tanto, un objeto Oj de tipo Cj contiene un objeto de tipo Ci. La operación [Oi = Oj] hace que Oi sea una referencia al objeto de tipo Ci contenido dentro del objeto Oj.

El hecho de que una variable Oi de clase Ci pueda hacer referencia no solo a un objeto de clase Ci sino a cualquier objeto derivado de la clase Ci se denomina polimorfismo: la capacidad de una variable de hacer referencia a diferentes tipos de objetos.

Tomemos un ejemplo y consideremos la función [Display] del programa anterior:

1
2
3
4
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}

Podemos pasarle una *[Person]* o un *[Teacher]: en este último caso, el parámetro formal [p], que es de tipo [Person], recibe un valor de tipo [Teacher]. Dado que el tipo [Teacher] deriva del tipo [Person]*, esto es válido.

La propiedad [p.Identity] devuelve una cadena que identifica al objeto [Person] [p]. ¿Qué ocurre si el parámetro pasado a la función [Display] es un objeto de tipo [Teacher]? Los resultados anteriores muestran que: la instrucción [p.Identity] ejecutó cada vez la propiedad [Identity] de un objeto [Person] , primero la persona contenida en el docente [e] (línea 7) y luego la persona [p] misma (línea 8). No se adaptó al objeto realmente pasado como parámetro a [Display]. Habríamos preferido obtener la identidad completa del docente [e]. Para que eso ocurra, la notación [p.Identity] tendría que hacer referencia a la propiedad [Identity] del objeto al que realmente apunta [p], y no a la propiedad [Identity] de la parte “Person” de ese objeto. Con el enmascaramiento ([new]), la propiedad se selecciona en tiempo de compilación, según el tipo declarado de la variable ([Person]).

4.2.5. Redefinición y polimorfismo: virtual y override

Es posible obtener el resultado deseado declarando [Identity] como una propiedad virtual ([virtual]) en la clase base [Person]. Eso es lo que hace el proyecto [Inheritance2]; su clase [Person] es la misma que la del proyecto [Inheritance1], con dos cambios:

    // identidad de la persona: propiedad virtual
    public virtual string Identity => $"[{FirstName}, {LastName}, {Age}]";

    // redefinición del método ToString de la clase object
    public override string ToString() => Identity;
  • Línea 38: la palabra clave [virtual] convierte a [Identity] en una propiedad virtual. Esta palabra clave también puede aplicarse a métodos. Las clases hijas que sobrescriben una propiedad o un método virtual deben entonces usar la palabra clave [override] en lugar de [new] para calificar su propiedad o método sobrescrito;
  • línea 41: una redefinición del método [ToString], que se explica en el párrafo siguiente.

En la clase [Teacher], la propiedad [Identity] se redefine de la siguiente manera:

namespace Inheritance2;

// una clase sellada (sealed): ninguna clase puede derivar de ella
public sealed class Teacher : Person
{
    // constructor
    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        Section = section;
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

    // propiedad Section
    public int Section { get; set; }

    // propiedad Identity: redefine (override) la de la clase padre
    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}
  • Línea 18: la propiedad [Identity] sobrescribe la de la clase padre;
  • Línea 4: la clase está sellada ([sealed]), lo que explicaremos con más detalle más adelante.

Con una propiedad o un método virtual, la elección de qué propiedad ejecuta [p.Identity] se realiza en tiempo de ejecución, según el tipo real del objeto referenciado por [p]. El programa [Program.cs] del proyecto [Inheritance2] es el siguiente:

using Inheritance2;

// un profesor
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Display(e);
// una persona
Person p = new Person("Jean", "Dupont", 30);
Display(p);
// Console.WriteLine(object) muestra el resultado del método ToString del objeto
Console.WriteLine(e);
Console.WriteLine(p);
// un arreglo de personas de diferentes tipos
Person[] persons = [p, e];
foreach (Person person in persons)
{
    Console.WriteLine($"{person.GetType().Name} : {person}");
}

// muestra la identidad de p
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}

Resultados:

> dotnet run
Constructor Person(string, string, int)
Constructor Teacher(string, string, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(string, string, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Esta vez, en la línea 4, la función [Display] mostró correctamente el nombre completo del docente.

4.2.6. El método ToString

La clase [object] (el alias de C# para la clase [System.Object]) es la clase “padre” de todas las clases de C#. Por lo tanto, cuando se escribe:

public class Person

se está escribiendo implícitamente:

public class Person : object

La clase [object] define un método virtual, [ToString], que de manera predeterminada devuelve el nombre completo de la clase del objeto. Esto es lo que mostraron las dos últimas líneas de la salida del proyecto [Inheritance1], con las llamadas a [e.ToString()] y [p.ToString()]: [Inheritance1.Teacher] y [Inheritance1.Person]. Aunque no sobrescribimos el método [ToString] en las clases [Person] y [Teacher] , el método [ToString] de la clase [object] pudo mostrar el nombre de la clase real del objeto.

En el proyecto [Inheritance2], la clase [Person] redefine el método [ToString] (véase más arriba):

    public override string ToString() => Identity;

Volvamos al programa [Program.cs] del proyecto [Inheritance2]:

// Console.WriteLine(object) muestra el resultado del método ToString del objeto
Console.WriteLine(e);
Console.WriteLine(p);
// un arreglo de personas de diferentes tipos
Person[] persons = [p, e];
foreach (Person person in persons)
{
    Console.WriteLine($"{person.GetType().Name} : {person}");
}

En la línea 10, el método [WriteLine] de la clase [Console] no tiene ninguna variante que acepte un parámetro de tipo [Person]. Entre las diversas variantes de [WriteLine], hay una que acepta un parámetro de tipo [object]. El compilador usará este método, [WriteLine(object o)], porque esta firma significa que el parámetro [o] puede ser de tipo [object] o de un tipo derivado. Dado que [object] es la superclase de todas las clases, cualquier objeto puede pasarse como parámetro a [WriteLine], incluido un objeto de tipo [Person] o [Teacher]. El método [WriteLine(object o)] escribe [o.ToString()] en la consola. Como el método [ToString] es virtual, se usa el método [ToString] del objeto real, en este caso el de la clase [Person]. Este método devuelve [Identity], que también es una propiedad virtual: para el docente [e], se usa por lo tanto la propiedad [Identity] de la clase [Teacher] , como se muestra en la línea 7 de los resultados. Por lo tanto, no es necesario redefinir [ToString] en la clase [Teacher], a diferencia de lo que ocurría en el curso de 2008.

El mismo mecanismo se aplica a la interpolación de cadenas: en [$"{person}"] (línea 16), el objeto [person] se convierte en cadena mediante su método [ToString]. El bucle de las líneas 14–16 recorre un arreglo de referencias a [Person], que en realidad apuntan a objetos de tipos distintos: el método [GetType] (que también se hereda de [object]) devuelve el tipo real del objeto, cuya propiedad [Name] es el nombre.

4.2.7. Clases selladas

La clase [Teacher] del proyecto [Inheritance2] se declara como [public sealed class Teacher : Person]. La palabra clave [sealed] impide derivar clases de la clase [Teacher]: el compilador rechazaría la declaración [class TeacherResearcher : Teacher]. Una clase se sella cuando no está destinada a ser derivada; además, el compilador y el entorno de ejecución pueden optimizar las llamadas a sus métodos virtuales. La palabra clave también se aplica a un método o propiedad redefinido: [public sealed override string Identity] impediría que las clases derivadas lo redefinan nuevamente, sin prohibir la derivación de la clase.

A la inversa, un método o propiedad que no está declarado como [virtual], [abstract] (véase más adelante) ni [override] no puede sobrescribirse con [override]: en C#, a diferencia de Java, los métodos no son virtuales de forma predeterminada.

4.3. Redefinir el significado de un operador para una clase

4.3.1. Introducción

Consideremos la expresión [op1 + op2], donde [op1] y [op2] son dos operandos. Es posible redefinir el significado del operador [+]. Si el operando [op1] es una instancia de la clase [C1], debe definirse un método estático en la clase [C1] con la siguiente firma:

public static Type operator +(C1 operand1, C2 operand2)

Cuando el compilador encuentra la expresión [op1 + op2], la traduce a [C1.operator +(op1, op2)]. El tipo devuelto por el método [operator] es importante. En efecto, consideremos la operación [op1 + op2 + op3]. El compilador la traduce como [(op1 + op2) + op3]. Sea [res12] el resultado de [op1 + op2]. La siguiente operación que se realiza es [res12 + op3]. Si [res12] es de tipo [C1], también se traducirá a [C1.operator +(res12, op3)]. Esto permite encadenar operaciones.

También pueden redefinirse los operadores unarios, que tienen un solo operando. Así, si [op1] es un objeto de tipo [C1], la operación [op1++] puede redefinirse mediante un método estático de la clase [C1]:

public static C1 operator ++(C1 operand1)

Lo que se ha expuesto aquí se aplica a la mayoría de los operadores, con algunas excepciones:

  • los operadores [==] y [!=] deben redefinirse juntos, al igual que [<] y [>], [<=] y [>=];
  • los operadores [&&], [||], [=], [.], [?:], [??] y [new] no pueden redefinirse;
  • hasta C# 13, los operadores de asignación compuesta ([+=], [-=], …) no podían sobrescribirse: [a += b] siempre se compilaba como [a = a + b]. C# 14 permite sobrescribirlos, como veremos.

4.3.2. Un ejemplo

El proyecto [Lists] de la solución define una clase llamada [ListOfPersons], que es una lista de personas. Las clases [Person] y [Teacher] de este proyecto son las mismas que las del proyecto [Inheritance2], pero sin sus mensajes de seguimiento y el contador de personas. En el curso de 2008, la clase *[ListOfPersons] derivaba de la clase *[ArrayList]*, una lista de objetos de tipo *[object], que hoy está obsoleta. Usamos la lista genérica [List<Person>] (las clases genéricas se tratan más adelante en este capítulo; la clase [List<T>] se trata en el próximo capítulo) y, en lugar de heredar de ella, la colocamos en un campo privado de la clase. Esto se denomina usar composición en lugar de herencia: la clase [ListOfPersons] expone así únicamente las operaciones que ha elegido. De la clase [List<Person>], usamos solo los siguientes elementos:

  • el método [L.Add(p)], que agrega la persona [p] a la lista [L], y el método [L.AddRange(L2)], que le agrega todos los elementos de la lista [L2];
  • la propiedad [L.Count], que devuelve el número de elementos de la lista [L];
  • la notación [L[i]], que designa el elemento n.º i de la lista [L].

La definición de la clase [ListOfPersons] es la siguiente: [ListOfPersons.cs]:

namespace Lists;

public class ListOfPersons
{
    // las personas de la lista
    private readonly List<Person> persons = [];

    // número de personas en la lista
    public int Count => persons.Count;

    // operador +: devuelve una nueva lista que contiene las personas de l y la persona p
    public static ListOfPersons operator +(ListOfPersons l, Person p)
    {
        ListOfPersons result = new ListOfPersons();
        result.persons.AddRange(l.persons);
        result.persons.Add(p);
        return result;
    }

    // operador de asignación compuesta += (C# 14): agrega p a la lista actual
    public void operator +=(Person p)
    {
        persons.Add(p);
    }

    // indexador por posición, de lectura y escritura
    public Person this[int i]
    {
        get { return persons[i]; }
        set { persons[i] = value; }
    }

    // indexador por apellido, de solo lectura: devuelve la posición de la persona o -1
    public int this[string lastName]
    {
        get
        {
            // buscamos a la persona
            for (int i = 0; i < persons.Count; i++)
            {
                if (persons[i].LastName == lastName)
                {
                    return i;
                }
            }
            return -1;
        }
    }

    // ToString: devuelve (persona1,persona2,...)
    public override string ToString()
    {
        return "(" + string.Join(",", persons) + ")";
    }
}
  • línea 6: la lista de personas. La palabra clave [readonly] indica que el campo solo puede asignarse en el momento de su declaración o dentro de un constructor: el contenido de la lista puede cambiar, pero el campo siempre hará referencia a la misma lista. [] es una expresión de colección vacía: el tipo de la colección creada, [List<Person>], se infiere del tipo del campo;
  • línea 9: el número de personas, una propiedad de solo lectura;
  • líneas 12–17: definición del operador [+] para la operación [l + p], donde [l] es de tipo [ListOfPersons] y [p] es de tipo [Person] o de un tipo derivado. El operador crea una nueva lista (línea 14), copia en ella las personas de [l] (línea 15) y luego agrega la persona [p] (línea 16). Como ocurre con el operador [+] para números o cadenas, los operandos no se modifican. Dado que la lista [l] es de la misma clase, el operador tiene acceso a su campo privado [l.persons]. La lista resultante es de tipo [ListOfPersons], lo que permite encadenar los operadores [+] como en [l + p1 + p2], interpretado (precedencia de operadores) como [(l + p1) + p2];
  • líneas 21–23: definición del operador [+=] (C# 14). A diferencia de los demás operadores, no es un método estático sino un método de instancia sin valor de retorno ([void]): modifica el objeto actual, en este caso agregándole la persona [p];
  • líneas 51–53: redefinimos el método [ToString] para mostrar una lista de personas con la forma (persona1, persona2, ...), donde personai es a su vez el resultado del método [ToString] de la persona. El método estático [string.Join(separator, elements)] concatena las representaciones textuales de los elementos, separándolas con el separador. El curso de 2008 construía esta cadena manualmente con un objeto [StringBuilder].

Observe que la clase [ListOfPersons] no tiene constructor. Por lo tanto, utiliza el constructor predeterminado [public ListOfPersons()], que no hace más que inicializar el campo [persons] con el valor especificado en su declaración. Las líneas 26–46 se tratan en la siguiente sección.

El programa de prueba [Program.cs] comienza de la siguiente manera:

using Lists;

// --- el operador +
// una lista de personas
ListOfPersons l = new ListOfPersons();
// agregado de personas
l = l + new Person("jean", "martin", 10) + new Person("pauline", "leduc", 12);
// visualización
Console.WriteLine("l=" + l);
// l + p devuelve una nueva lista: l no se modifica
ListOfPersons l2 = l + new Person("louis", "durand", 8);
Console.WriteLine("l=" + l);
Console.WriteLine("l2=" + l2);

// --- el operador += (C# 14)
ListOfPersons l3 = l;
// += agrega el profesor a la lista referenciada por l, sin crear una nueva lista
l += new Teacher("camille", "germain", 27, 60);
Console.WriteLine("l=" + l);
// l y l3 siguen referenciando el mismo objeto
Console.WriteLine($"l3=l : {ReferenceEquals(l, l3)}");
  • línea 5: creación de una lista vacía de personas [l];
  • línea 7: agrega dos personas con el operador [+];
  • línea 11: [l + p] crea una nueva lista [l2]; la lista [l] permanece sin cambios;
  • línea 18: agrega un docente con el operador [+=];
  • Líneas 9–13: la concatenación de una cadena y un objeto utiliza el método [ToString], que está redefinido en la clase [ListOfPersons].

Resultados:

1
2
3
4
5
6
> dotnet run
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3=l : True

4.3.3. Operadores de asignación compuesta (C# 14)

¿Por qué definir el operador [+=] cuando [l = l + p] produce el mismo resultado? Si la clase no define [+=], el compilador traduce [l += p] a [l = l + p]: se crea una nueva lista, se copian en ella todas las personas de [l] y luego [l] pasa a hacer referencia a esta nueva lista, mientras que el recolector de basura descarta la anterior. Con el operador [+=] definido por la clase, la persona se agrega a la lista existente sin copiarla. La línea 16 guarda una segunda referencia, [l3], a la lista [l]; después de la instrucción [l += ...], ambas referencias siguen apuntando al mismo objeto (línea 6 de los resultados), lo que demuestra que la lista no se volvió a crear. Para una lista grande, o dentro de un bucle, la diferencia de rendimiento es significativa.

4.4. Definir un indexador para una clase

Aquí seguimos usando la clase [ListOfPersons]. Si [l] es una instancia de [ListOfPersons], queremos poder usar la notación [l[i]] para designar a la persona número i de la lista [l], tanto para leer ([Person p = l[i]]) como para escribir ([l[i] = new Person(...)]).

Para poder escribir [l[i]], donde [l[i]] designa un objeto [Person], debemos definir una propiedad específica llamada [this] en la clase [ListOfPersons]:

    // indexador por posición, de lectura y escritura
    public Person this[int i]
    {
        get { return persons[i]; }
        set { persons[i] = value; }
    }

    // indexador por apellido, de solo lectura: devuelve la posición de la persona o -1
    public int this[string lastName]
    {
        get
        {
            // buscamos a la persona
            for (int i = 0; i < persons.Count; i++)
            {
                if (persons[i].LastName == lastName)
                {
                    return i;
                }
            }
            return -1;
        }
    }

La propiedad [this[int i]] se denomina indexador porque da sentido a la expresión [obj[i]], que se parece a la notación de arreglos, aunque [obj] no es un arreglo sino un objeto. El método [get] del indexador del objeto [obj] se llama cuando se escribe [variable = obj[i]], y el método [set] se llama cuando se escribe [obj[i] = value].

  • Líneas 27–30: el indexador basado en la posición. El método [get] devuelve la persona n.º i de la lista privada [persons], y el método [set] le asigna la persona [value]. El curso de 2008, cuya clase derivaba de [ArrayList], tenía que enmascarar el indexador de la clase padre con la palabra clave [new] y convertir a [object] el elemento de tipo que este devolvía a [Person]. Con una lista genérica, ya no se necesita ninguna conversión;
  • líneas 34–46: también queremos poder escribir [int i = l["lastName"]], es decir, indexar la lista [l] no por un número de elemento sino por el apellido de una persona. El resultado de [l[lastName]] es un entero: la posición en la lista de la persona con el apellido [lastName], o -1 si esa persona no está en la lista. Solo se define el método [get], lo que impide la sintaxis [l["lastName"] = value], que habría requerido la definición de un método [set]. Una clase puede tener varios indexadores, siempre que sus parámetros sean diferentes.

El programa de prueba continúa de la siguiente manera:

// --- indexadores
// cambio del elemento n.º 1
l[1] = new Person("franck", "gallon", 5);
// visualización del elemento n.º 1
Console.WriteLine("l[1]=" + l[1]);
// visualización de la lista l
Console.WriteLine("l=" + l);
// búsqueda de personas por su apellido
string[] lastNames = ["martin", "germain", "xx"];
foreach (string lastName in lastNames)
{
    int index = l[lastName];
    if (index != -1)
    {
        Console.WriteLine($"Person({lastName})={l[index]}");
    }
    else
    {
        Console.WriteLine($"Person({lastName}) does not exist");
    }
}
  • línea 25: llamada al método [set] del indexador [this[int]];
  • línea 27: llamada a su método [get];
  • Línea 34: llamada al indexador [this[string]];
  • línea 37: llamada al indexador [this[int]].

Resultados:

l[1]=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

4.5. Estructuras

4.5.1. Valor y referencia

La estructura de C# es análoga a la estructura del lenguaje C y se parece mucho al concepto de clase. Una estructura se define de la siguiente manera:

struct StructureName
{
    // campos
    ...
    // propiedades
    ...
    // constructores
    ...
    // métodos
    ...
}

A pesar de las similitudes en sus declaraciones, existen diferencias significativas entre las clases y las estructuras. Por ejemplo, el concepto de herencia no existe con las estructuras (una estructura sí puede, sin embargo, implementar interfaces, que se tratan más adelante). Si estamos escribiendo una clase que no está destinada a ser derivada, ¿qué diferencias entre una estructura y una clase nos ayudarán a elegir entre ambas? Usemos el siguiente ejemplo para averiguarlo: [classes-13.cs]:

// estructura y clase: copia de valor, copia de referencia
// una estructura sp1
SPerson sp1;
sp1.Name = "paul";
sp1.Age = 10;
Console.WriteLine("sp1=SPerson(" + sp1.Name + "," + sp1.Age + ")");
// una estructura sp2
SPerson sp2 = sp1;
Console.WriteLine("sp2=SPerson(" + sp2.Name + "," + sp2.Age + ")");
// se modifica sp2
sp2.Name = "nicole";
sp2.Age = 30;
// verificación de sp1 y sp2
Console.WriteLine("sp1=SPerson(" + sp1.Name + "," + sp1.Age + ")");
Console.WriteLine("sp2=SPerson(" + sp2.Name + "," + sp2.Age + ")");

// un objeto op1
CPerson op1 = new CPerson();
op1.Name = "paul";
op1.Age = 10;
Console.WriteLine("op1=CPerson(" + op1.Name + "," + op1.Age + ")");
// un objeto op2
CPerson op2 = op1;
Console.WriteLine("op2=CPerson(" + op2.Name + "," + op2.Age + ")");
// se modifica op2
op2.Name = "nicole";
op2.Age = 30;
// verificación de op1 y op2
Console.WriteLine("op1=CPerson(" + op1.Name + "," + op1.Age + ")");
Console.WriteLine("op2=CPerson(" + op2.Name + "," + op2.Age + ")");

// estructura SPerson
struct SPerson
{
    public string Name;
    public int Age;
}

// clase CPerson
class CPerson
{
    public string Name = "";
    public int Age;
}
  • líneas 33–36: una estructura con dos campos públicos: [Name], [Age];
  • líneas 40–43: una clase con dos campos públicos: [Name], [Age]. Los campos públicos, que en general se desaconsejan, hacen que este ejemplo sea más legible.

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run classes-13.cs
sp1=SPerson(paul,10)
sp2=SPerson(paul,10)
sp1=SPerson(paul,10)
sp2=SPerson(nicole,30)
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)

Esta estructura no tiene un constructor aquí. Podría tenerlo, como mostraremos más adelante. De forma predeterminada, siempre tiene un constructor sin parámetros (en este caso, [SPerson()]) que establece todos sus campos en cero ([null] para las referencias).

La declaración de la línea 3 crea una estructura ([Name], [Age]), y el valor de [sp1] es esta misma estructura. Sus campos aún no tienen valores: el compilador exige que todos se asignen (líneas 4–5) antes de usar la estructura (línea 6). En el caso de una clase, el objeto ([Name], [Age]) debe crearse explícitamente con el operador [new] (línea 18). La instrucción crea un objeto [CPerson] (aproximadamente equivalente a nuestra estructura), y el valor de [op1] es entonces la dirección (la referencia) de ese objeto.

En resumen:

  • en el caso de la estructura, el valor de [sp1] es la estructura misma;
  • en el caso de la clase, el valor de [op1] es la dirección del objeto creado.

Image

Cuando se escribe [SPerson sp2 = sp1;] en el programa (línea 8), se crea una nueva estructura [sp2] ([Name], [Age]) y se inicializa con el valor de [sp1], que es la estructura misma:

Image

La estructura de [sp1] se duplica en [sp2] (lado izquierdo del diagrama). Se trata de una copia por valor. Consideremos ahora la instrucción [CPerson op2 = op1;] (línea 23). En el caso de las clases, el valor de [op1] se copia en [op2], pero como ese valor es en realidad la dirección del objeto, el objeto en sí no se duplica (lado derecho del diagrama).

En el caso de la estructura, cambiar el valor de [sp2] no cambia el valor de [sp1], como lo muestra el programa (líneas 4–5 de los resultados). En el caso del objeto, si se modifica el objeto al que apunta [op2], el objeto al que apunta [op1] también se modifica, ya que son el mismo (líneas 8–9).

Por lo tanto, de estas explicaciones podemos concluir que:

  • el valor de una variable de tipo estructura es la estructura misma;
  • el valor de una variable de tipo clase es la dirección del objeto al que apunta.

Se dice que las estructuras son tipos de valor y las clases son tipos de referencia. Los tipos simples de C# ([int], [double], [decimal], [bool], [char], …) son estructuras de .NET ([System.Int32], [System.Double], …), mientras que [string] y los arreglos son tipos de referencia. Una estructura es adecuada para representar un dato pequeño (un punto, un color, una fecha, un monto…) que se trata como un valor. Una estructura no se asigna individualmente en el montón del recolector de basura: una variable local de tipo estructura se coloca generalmente en la pila, y un arreglo de estructuras contiene las estructuras mismas y no referencias a ellas.

4.5.2. Una estructura con propiedades y constructores

Una vez comprendida la diferencia fundamental entre un valor y una referencia, una estructura resulta muy similar a una clase, como muestra el siguiente ejemplo [classes-14.cs]:

// una estructura con constructores, propiedades y un método
// una persona p1
SPerson p1 = new SPerson();
Console.WriteLine($"p1={p1}");
p1.Name = "paul";
p1.Age = 10;
Console.WriteLine($"p1={p1}");
// una persona p2
SPerson p2 = p1;
Console.WriteLine("p2=" + p2);
// se modifica p2
p2.Name = "nicole";
p2.Age = 30;
// verificación de p1 y p2
Console.WriteLine("p1=" + p1);
Console.WriteLine("p2=" + p2);
// una persona p3
SPerson p3 = new SPerson("amandin", 18);
Console.WriteLine("p3=" + p3);
// una persona p4
SPerson p4 = new SPerson { Name = "x", Age = 10 };
Console.WriteLine("p4=" + p4);
// el valor predeterminado de una estructura: todos los campos en cero (null para las referencias)
SPerson p5 = default;
Console.WriteLine("p5=" + p5);
// igualdad de dos estructuras: comparación de los valores de los campos
SPerson p6 = new SPerson("nicole", 30);
Console.WriteLine($"p1.Equals(p2) : {p1.Equals(p2)}, p2.Equals(p6) : {p2.Equals(p6)}");

// estructura SPerson
struct SPerson
{
    // constructores
    public SPerson(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public SPerson() : this("?", 0)
    {
    }

    // propiedades
    public string? Name { get; set; }
    public int Age { get; set; }

    // ToString
    public override string ToString()
    {
        return $"SPerson({Name},{Age})";
    }
}
  • líneas 34–37: un constructor con dos parámetros. El curso de 2008 explicaba que el constructor de un struct no podía inicializar campos mediante propiedades: esta restricción se ha eliminado (C# 11);
  • línea 40: desde C# 10, un struct puede declarar su propio constructor sin parámetros, que aquí está encadenado al anterior. Se llama mediante [new SPerson()] (línea 3) y mediante el inicializador de objeto de la línea 21, que luego modifica las dos propiedades;
  • líneas 45–46: dos propiedades automáticas. La propiedad [Name] se declara de tipo [string?] (una cadena que podría ser [null]) porque un struct siempre puede crearse sin usar un constructor: es el caso de su valor predeterminado (línea 24), donde todos los campos se establecen en cero y, por lo tanto, el nombre es [null], así como de los elementos de un arreglo de estructuras recién creado;
  • líneas 49–51: redefinición del método [ToString]. Una estructura deriva implícitamente de la clase [System.ValueType], que a su vez deriva de [object];
  • línea 28: el método [Equals], heredado de [ValueType], compara dos estructuras campo por campo. En cambio, el operador [==] no está definido para una estructura a menos que se sobrescriba.

Resultados:

> dotnet run classes-14.cs
p1=SPerson(?,0)
p1=SPerson(paul,10)
p2=SPerson(paul,10)
p1=SPerson(paul,10)
p2=SPerson(nicole,30)
p3=SPerson(amandin,18)
p4=SPerson(x,10)
p5=SPerson(,0)
p1.Equals(p2) : False, p2.Equals(p6) : True

Al final del programa, las estructuras [p1] y [p2] son diferentes (líneas 5–6): con una clase, [p1] y [p2] habrían hecho referencia al mismo objeto.

4.5.3. Estructuras inmutables y estructuras de registro

Una estructura cuyo estado puede modificarse puede conducir a resultados inesperados: como se copia en cada asignación o paso de parámetro, a menudo se modifica una copia creyendo que se modifica el original. Por eso se recomienda hacer que las estructuras sean inmutables: una vez creadas, ya no pueden modificarse. El programa [classes-15.cs] muestra las dos formas de lograrlo:

// estructuras inmutables (readonly struct) y estructuras de registro (record struct)
Point a = new Point(1, 2);
// a.X = 5;   // rechazado: las propiedades de un readonly struct no pueden modificarse
Point b = a.Move(3, 4);
Console.WriteLine($"a={a}, b={b}");

// un record struct: el compilador genera ToString, Equals, == y !=
PointR r1 = new PointR(1, 2);
PointR r2 = new PointR(1, 2);
Console.WriteLine($"r1={r1}, r2={r2}");
Console.WriteLine($"r1 == r2 : {r1 == r2}");
// un record struct (no readonly) puede modificarse
r2.Y = 20;
Console.WriteLine($"r2={r2}, r1 == r2 : {r1 == r2}");
// la expresión with crea una copia modificada
PointR r3 = r1 with { X = 10 };
Console.WriteLine($"r3={r3}");

// un readonly record struct es inmutable
Color red = new Color(255, 0, 0);
Color pink = red with { G = 128, B = 128 };
Console.WriteLine($"red={red}, pink={pink}");
// pink.G = 0;   // rechazado: la estructura es de solo lectura

// una estructura inmutable
readonly struct Point
{
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public int X { get; }
    public int Y { get; }

    // no modificamos el punto: devolvemos uno nuevo
    public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

    public override string ToString() => $"({X},{Y})";
}

// una estructura de registro "posicional": X e Y son propiedades públicas
record struct PointR(int X, int Y);

// una estructura de registro inmutable
readonly record struct Color(byte R, byte G, byte B);
  • líneas 26–40: una estructura declarada como [readonly] (C# 7.2). El compilador verifica que todos sus campos y propiedades sean de solo lectura. Para “mover” un punto, el método [Move] devuelve un nuevo punto (línea 38);
  • línea 44: una estructura de registro (C# 10). Esta única línea declara una estructura cuyo constructor tiene dos parámetros, [X] y [Y], y que tiene dos propiedades públicas de lectura y escritura, [X] y [Y]. El compilador también genera un método llamado [ToString] que muestra el nombre de la estructura y sus propiedades, los métodos de igualdad y los operadores [==] y [!=] (línea 11), así como compatibilidad con la expresión [with], que crea una copia de la estructura modificando ciertas propiedades (línea 16);
  • línea 47: una estructura de registro inmutable: sus propiedades son de solo lectura (más precisamente, [init]: solo pueden asignarse en la creación), mientras que la expresión [with] sigue siendo válida (línea 21).

Resultados:

1
2
3
4
5
6
7
> dotnet run classes-15.cs
a=(1,2), b=(4,6)
r1=PointR { X = 1, Y = 2 }, r2=PointR { X = 1, Y = 2 }
r1 == r2 : True
r2=PointR { X = 1, Y = 20 }, r1 == r2 : False
r3=PointR { X = 10, Y = 2 }
red=Color { R = 255, G = 0, B = 0 }, pink=Color { R = 255, G = 128, B = 128 }

Los registros ([record]) también existen como clases: los examinaremos en detalle un poco más adelante. Por ahora, notemos simplemente que un [readonly record struct] es la forma más concisa de declarar un dato pequeño e inmutable de tipo valor: este es el tipo que usaremos para los tramos del impuesto en la aplicación de ejemplo de este capítulo.

4.6. Interfaces

4.6.1. Un primer ejemplo

Una interfaz es un conjunto de declaraciones de métodos o propiedades que forma un contrato. Una clase (o estructura) que decide implementar una interfaz se compromete a proporcionar una implementación de todos los métodos y propiedades definidos en la interfaz. El compilador verifica esta implementación.

Por ejemplo, esta es la definición de la interfaz [System.Collections.IEnumerator] de .NET:

1
2
3
4
5
6
7
8
public interface IEnumerator
{
    // propiedades
    object Current { get; }
    // métodos
    bool MoveNext();
    void Reset();
}

Las propiedades y los métodos de la interfaz se definen únicamente mediante sus firmas. No están implementados (no tienen código). Son las clases que implementan la interfaz las que proporcionan el código de los métodos y propiedades de la interfaz:

1
2
3
4
5
6
7
public class C : IEnumerator
{
    ...
    public object Current { get { ... } }
    public bool MoveNext() { ... }
    public void Reset() { ... }
}
  • Línea 1: la clase [C] implementa la interfaz [IEnumerator]. Observe que el símbolo [:] utilizado para implementar una interfaz es el mismo que se usa para derivar una clase;
  • Líneas 4–6: la implementación de los métodos y propiedades de la interfaz [IEnumerator]. Deben ser públicos.

Por convención, el nombre de una interfaz comienza con la letra I. Los siguientes ejemplos conforman el proyecto [Statistics] de la solución. Consideremos la siguiente interfaz, [IStats.cs]:

namespace Statistics;

public interface IStats
{
    // promedio de una serie de valores
    double Average { get; }

    // desviación estándar de la serie
    double StandardDeviation();
}

La interfaz [IStats] tiene:

  • una propiedad de solo lectura [Average]: para calcular el promedio de una serie de valores;
  • un método [StandardDeviation]: para calcular la desviación estándar.

Observe que en ninguna parte se especifica a qué conjunto de valores se refiere. Podría ser el promedio de calificaciones de una clase, el promedio mensual de ventas de un producto determinado, la temperatura promedio en un lugar dado… Este es el principio de las interfaces: suponen la existencia de métodos en el objeto, pero no la de datos específicos.

Una primera clase de implementación de la interfaz [IStats] podría ser una clase que sirva para almacenar las notas de los estudiantes de un curso en una asignatura determinada. Un estudiante se caracteriza por la siguiente estructura [Student]: [Student.cs]:

1
2
3
4
namespace Statistics;

// un estudiante
public readonly record struct Student(string FirstName, string LastName);

El estudiante se identifica por su nombre y su apellido. El curso de 2008 definía una estructura con dos propiedades automáticas; una estructura record inmutable, como la del apartado anterior, se expresa en una sola línea. Una nota se caracteriza por la siguiente estructura: [Grade] [Grade.cs]:

1
2
3
4
5
6
7
namespace Statistics;

// la nota de un estudiante
public readonly record struct Grade(Student Student, double Value)
{
    public override string ToString() => $"[{Student.FirstName},{Student.LastName},{Value}]";
}

La nota se define por el estudiante evaluado y por la nota misma. La estructura redefine el método [ToString] generado por el compilador para mostrar una nota con la forma [firstName,lastName,value].

Las notas de todos los estudiantes en una asignatura determinada se agrupan en la siguiente clase [ArrayOfGrades]: [ArrayOfGrades.cs]:

namespace Statistics;

public class ArrayOfGrades : IStats
{
    // propiedades
    public string Subject { get; }
    public Grade[] Grades { get; }
    public double Average { get; }
    // campo
    private readonly double standardDeviation;

    // constructor
    public ArrayOfGrades(string subject, Grade[] grades)
    {
        // almacenamiento de los datos
        Subject = subject;
        Grades = grades;
        // cálculo del promedio de las notas
        double sum = 0;
        foreach (Grade grade in Grades)
        {
            sum += grade.Value;
        }
        Average = Grades.Length != 0 ? sum / Grades.Length : -1;
        // cálculo de la desviación estándar
        double squares = 0;
        foreach (Grade grade in Grades)
        {
            squares += Math.Pow(grade.Value - Average, 2);
        }
        standardDeviation = Grades.Length != 0 ? Math.Sqrt(squares / Grades.Length) : -1;
    }

    // implementación del método StandardDeviation de la interfaz IStats
    public double StandardDeviation()
    {
        return standardDeviation;
    }

    // ToString
    public override string ToString()
    {
        return $"subject={Subject}, grades=({string.Join(",", Grades)})";
    }
}
  • Línea 3: la clase [ArrayOfGrades] implementa la interfaz [IStats]. Por lo tanto, debe implementar la propiedad [Average] y el método [StandardDeviation]. Estos se implementan en la línea 8 ([Average]) y en las líneas 35–37 ([StandardDeviation]);
  • líneas 6–8: tres propiedades automáticas de solo lectura: la asignatura para la que el objeto almacena notas, el arreglo de notas y el promedio de las notas;
  • línea 10: un campo que almacena la desviación estándar de las notas;
  • líneas 13–31: el constructor. Aquí se supone que las notas pasadas al constructor no cambiarán después. Por lo tanto, se usa el constructor para calcular de inmediato el promedio y la desviación estándar de estas notas y almacenarlos. A una propiedad de solo lectura como [Average] se le puede asignar un valor en el constructor (línea 24); después ya no se le puede asignar ninguno. Las expresiones [condition ? value1 : value2] establecen en -1 la media y la desviación estándar de un arreglo vacío;
  • líneas 41–43: el método [ToString] usa [string.Join] para concatenar las notas, cada una de las cuales se convierte en cadena mediante el método [ToString] de la estructura [Grade].

En la clase anterior, las notas se almacenaban en un arreglo. No era posible agregar una nueva nota después de crear el objeto [ArrayOfGrades]. Ahora presentamos una segunda implementación de la interfaz [IStats], llamada [ListOfGrades], en la que esta vez las notas se almacenan en una lista [List<Grade>], con la posibilidad de agregar notas después de la creación inicial del objeto [ListOfGrades]: [ListOfGrades.cs]:

namespace Statistics;

public class ListOfGrades : IStats
{
    // propiedades
    public string Subject { get; }
    public List<Grade> Grades { get; }
    // promedio y desviación estándar almacenados (null: aún no calculados)
    private double? average;
    private double? standardDeviation;

    // constructor
    public ListOfGrades(string subject, List<Grade> grades)
    {
        Subject = subject;
        Grades = grades;
    }

    // agregado de una nota
    public void Add(Grade grade)
    {
        Grades.Add(grade);
        // habrá que volver a calcular el promedio y la desviación estándar
        average = null;
        standardDeviation = null;
    }

    // promedio de las notas: calculado en la primera solicitud
    public double Average
    {
        get
        {
            average ??= ComputeAverage();
            return average.Value;
        }
    }

    // desviación estándar de las notas: calculada en la primera solicitud
    public double StandardDeviation()
    {
        standardDeviation ??= ComputeStandardDeviation();
        return standardDeviation.Value;
    }

    private double ComputeAverage()
    {
        if (Grades.Count == 0)
        {
            return -1;
        }
        double sum = 0;
        foreach (Grade grade in Grades)
        {
            sum += grade.Value;
        }
        return sum / Grades.Count;
    }

    private double ComputeStandardDeviation()
    {
        if (Grades.Count == 0)
        {
            return -1;
        }
        double m = Average;
        double squares = 0;
        foreach (Grade grade in Grades)
        {
            squares += Math.Pow(grade.Value - m, 2);
        }
        return Math.Sqrt(squares / Grades.Count);
    }

    // ToString
    public override string ToString()
    {
        return $"subject={Subject}, grades=({string.Join(",", Grades)})";
    }
}
  • Línea 3: la clase [ListOfGrades] implementa la interfaz [IStats];
  • línea 7: las notas ahora se almacenan en una lista en lugar de un arreglo;
  • líneas 20–25: ahora es posible agregar una nota a las ya almacenadas. El promedio y la desviación estándar ya no se calculan en el constructor sino bajo demanda, dentro de los propios miembros de la interfaz: [Average] (líneas 29–34) y [StandardDeviation] (líneas 39–42). Una vez calculados, estos valores se guardan para no recalcularlos en cada consulta: se dice que están en caché. Al agregar una nota se invalida el caché;
  • líneas 9–10: el caché. El tipo [double?] (C# 2) es un tipo de valor que admite valores nulos: una variable de este tipo contiene un [double] o [null], que aquí significa “aún no calculado”. El curso de 2008 usaba para ello el valor -1;
  • línea 33: el operador [??=] (C# 8) solo asigna un valor a la variable de la izquierda si esta es [null]. Por lo tanto, el método [ComputeAverage] solo se invoca si el promedio aún no se ha calculado. La propiedad [Value] de una variable [double?] devuelve el valor [double] que contiene.

Un programa de prueba podría ser el siguiente: [Program.cs]:

using Statistics;

// algunos estudiantes y sus notas de inglés
Student[] students = [new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")];
Grade[] grades = [new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18)];
// que almacenamos en un objeto ArrayOfGrades
ArrayOfGrades english = new ArrayOfGrades("english", grades);
// visualización del promedio y la desviación estándar
DisplayStats(english);
// las mismas notas en un objeto ListOfGrades
ListOfGrades french = new ListOfGrades("french", new List<Grade>(grades));
DisplayStats(french);
// agregamos una nota
french.Add(new Grade(new Student("Jérôme", "Jaric"), 10));
DisplayStats(french);
// una variable puede tener una interfaz como tipo
IStats stats = english;
Console.WriteLine($"English average: {stats.Average}");
stats = french;
Console.WriteLine($"French average: {stats.Average}");

// visualización del promedio y la desviación estándar de un objeto que implementa IStats
static void DisplayStats(IStats values)
{
    Console.WriteLine($"{values}, Average={values.Average}, Standard deviation={values.StandardDeviation()}");
}
  • línea 4: crea un arreglo de estudiantes;
  • línea 5: creación de un arreglo de notas;
  • línea 7: un objeto [ArrayOfGrades] cuyo promedio y desviación estándar se muestran en la línea 9;
  • línea 11: un objeto [ListOfGrades], cuyo promedio y desviación estándar se muestran en la línea 12. La clase [List<Grade>] tiene un constructor que acepta una colección de notas, en este caso el arreglo [grades];
  • línea 14: se agrega una nueva nota y se vuelve a mostrar;
  • líneas 23–25: la función [DisplayStats] recibe como parámetro un tipo [IStats], que es un tipo interfaz. Esto significa que el parámetro real puede ser cualquier objeto que implemente la interfaz [IStats]. Al usar un dato de tipo interfaz, solo se utilizan los métodos de la interfaz implementados por ese objeto; el resto se ignora. Esta propiedad es similar al polimorfismo que vimos con las clases. Si un conjunto de clases Ci que no están relacionadas entre sí por herencia (y que, por lo tanto, no pueden usar el polimorfismo basado en la herencia) comparten un conjunto de métodos con la misma firma, puede ser útil agrupar esos métodos en una interfaz I que todas las clases en cuestión implementarían. Las instancias de esas clases Ci pueden entonces usarse como parámetros reales de funciones que aceptan un parámetro formal de tipo I; es decir, funciones que usan solo los métodos de los objetos Ci definidos en la interfaz I, y no los campos y métodos específicos de las distintas clases Ci;
  • líneas 17–19: una variable puede ser del tipo de una interfaz. Entonces puede referirse a cualquier objeto de una clase que implemente la interfaz. El compilador solo permite acceder a los miembros de la interfaz: la propiedad [Average] y el método [StandardDeviation].

Resultados:

1
2
3
4
5
6
> dotnet run
subject=english, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18]), Average=16, Standard deviation=1,632993161855452
subject=french, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18]), Average=16, Standard deviation=1,632993161855452
subject=french, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18],[Jérôme,Jaric,10]), Average=14,5, Standard deviation=2,958039891549808
English average: 16
French average: 14,5

Por último, observe que las interfaces pueden tener varias implementaciones; es decir, se puede escribir:

1
2
3
4
public class DerivedClass : BaseClass, I1, I2, ..., In
{
    ...
}

donde las Ij son interfaces: una clase hereda de una sola clase, pero puede implementar tantas interfaces como desee.

4.6.2. Métodos de interfaz predeterminados

A partir de C# 8, una interfaz puede proporcionar una implementación predeterminada para algunos de sus métodos. Una clase que implementa la interfaz puede entonces usar esa implementación o proporcionar la suya. Esto permite, por ejemplo, agregar un método a una interfaz ya publicada sin obligar a modificar todas las clases que la implementan. El programa [classes-16.cs] ofrece un ejemplo:

// métodos de interfaz predeterminados (C# 8)
IShape[] shapes = [new Square(2), new Circle(1)];
foreach (IShape shape in shapes)
{
    Console.WriteLine(shape.Description());
}
// el método predeterminado solo es accesible a través del tipo de la interfaz
Square square = new Square(3);
// Console.WriteLine(square.Description());   // rechazado: Square no define Description
Console.WriteLine(((IShape)square).Description());

public interface IShape
{
    // método por implementar
    double Area();

    // método con una implementación predeterminada
    string Description() => $"{GetType().Name} with area {Area():F2}";
}

// Square usa la implementación predeterminada de Description
public class Square : IShape
{
    private readonly double side;

    public Square(double side)
    {
        this.side = side;
    }

    public double Area() => side * side;
}

// Circle proporciona su propia implementación de Description
public class Circle : IShape
{
    private readonly double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public double Area() => Math.PI * radius * radius;

    public string Description() => $"Circle with radius {radius} and area {Area():F2}";
}
  • Líneas 12–18: la interfaz [IShape] declara un método, [Area], que debe implementarse, y un método, [Description], con una implementación predeterminada. Este método puede usar los demás miembros de la interfaz ([Area]) y los de [object] ([GetType]). El formato [{Area():F2}] muestra el área con dos decimales;
  • líneas 22–31: la clase [Square] implementa solo [Area]; usa el método [Description] predeterminado;
  • líneas 35–46: la clase [Circle] proporciona su propio método, [Description];
  • línea 10: el método predeterminado pertenece a la interfaz, no a la clase [Square]: solo puede invocarse mediante una referencia de tipo [IShape]. El compilador rechaza la llamada a [square.Description()] .

Resultados:

1
2
3
4
> dotnet run classes-16.cs
Square with area 4,00
Circle with radius 1 and area 3,14
Square with area 9,00

Por último, a partir de C# 11, una interfaz puede declarar miembros estáticos abstractos que los tipos que la implementan deben proporcionar. Estos se usan solo con genéricos: los trataremos al final de la sección sobre genéricos.

4.7. Clases abstractas

Una clase abstracta es una clase que no se puede instanciar. Es necesario crear clases derivadas, que sí se pueden instanciar. Las clases abstractas permiten factorizar el código de una jerarquía de clases. Examinemos el siguiente ejemplo, que forma el proyecto [Users] de la solución: [User.cs]:

namespace Users;

public abstract class User
{
    // campos
    private readonly string login;
    private readonly string password;
    private readonly string role;

    // constructor
    protected User(string login, string password)
    {
        // almacenamos la información
        this.login = login;
        this.password = password;
        // identificamos al usuario
        string? role = Identify();
        // ¿identificado?
        if (role == null)
        {
            throw new UnknownUserException($"[{login},{password}]");
        }
        this.role = role;
    }

    // ToString
    public override string ToString()
    {
        return $"User[{login},{password},{role}]";
    }

    // identificación: devuelve el rol del usuario o null si no se lo reconoce
    protected abstract string? Identify();
}
  • línea 3: la clase se declara abstracta mediante la palabra clave [abstract];
  • líneas 11–23: el constructor de la clase [User]. Esta clase almacena información sobre un usuario de una aplicación web. La aplicación tiene varios tipos de usuarios que se autentican mediante un nombre de usuario y una contraseña (líneas 6–7). Estos dos datos se verifican en un directorio (LDAP) para algunos usuarios, en una base de datos para otros, etc. El constructor es [protected]: solo pueden invocarlo los constructores de las clases derivadas;
  • líneas 14–15: se almacena la información de autenticación;
  • línea 17: se verifica mediante un método llamado [Identify]. Como el método de autenticación no se conoce en este nivel, se declara abstracto (línea 33) mediante la palabra clave [abstract]. Un método abstracto no tiene cuerpo: las clases derivadas lo proporcionarán. Una clase que tiene un método abstracto debe declararse a su vez abstracta. El método [Identify] devuelve una cadena que indica el rol del usuario (básicamente, lo que está autorizado a hacer), o [null] si no se reconoce al usuario: por lo tanto, su tipo de retorno es [string?];
  • líneas 19–21: si no se reconoce al usuario, se lanza una excepción;
  • líneas 27–29: el método [ToString], que identifica una instancia de la clase.

Suponemos aquí que el desarrollador quiere tener control sobre la construcción de las instancias de la clase [User] y de sus clases derivadas, quizá porque desea asegurarse de que se lance una excepción de cierto tipo si no se reconoce al usuario. Las clases derivadas pueden apoyarse en este constructor. Para ello, deben proporcionar el método [Identify]. Observe que el constructor invoca aquí un método redefinido por las clases derivadas aunque estas todavía no hayan ejecutado sus propios constructores: por lo tanto, el método [Identify] no debe usar ningún campo de la clase derivada, ya que aún no se han inicializado. Es una práctica que debe usarse con cautela.

La clase [UnknownUserException] es la siguiente:

1
2
3
4
5
6
7
8
namespace Users;

public class UnknownUserException : Exception
{
    public UnknownUserException(string message) : base(message)
    {
    }
}
  • Línea 3: deriva de la clase [Exception];
  • línea 5: tiene un solo constructor que recibe un mensaje de error como parámetro. Este parámetro se pasa a la clase padre, que tiene el mismo constructor.

Ahora derivamos la clase hija [Administrator] de la clase [User]:

namespace Users;

public class Administrator : User
{
    // constructor
    public Administrator(string login, string password)
        : base(login, password)
    {
    }

    // identificación
    protected override string? Identify()
    {
        // identificación LDAP
        // ...
        return "admin";
    }
}
  • líneas 6–7: el constructor simplemente pasa a su clase padre los parámetros que recibe;
  • Líneas 12–16: el método [Identify] de la clase [Administrator]. Supongamos que un administrador se identifica mediante un directorio LDAP. Este método redefine el método abstracto [Identify] de su clase padre: la palabra clave [override] es obligatoria (un método abstracto es implícitamente virtual). El curso de 2008 afirmaba incorrectamente lo contrario. Conserva el modificador de acceso [protected] del método que redefine.

Ahora derivamos la clase hija [Observer] de la clase [User]:

namespace Users;

public class Observer : User
{
    // constructor
    public Observer(string login, string password)
        : base(login, password)
    {
    }

    // identificación
    protected override string? Identify()
    {
        // identificación mediante una base de datos
        // ...
        return "observer";
    }
}
  • Líneas 12–16: el método [Identify] de la clase [Observer]. Suponemos que un observador se identifica verificando sus datos de identificación en una base de datos.

En definitiva, los objetos [Administrator] y [Observer] se inicializan con el mismo constructor, el de la clase padre [User]. Este constructor usa el método [Identify] proporcionado por esas clases.

Una tercera clase, [Unknown], también deriva de la clase [User]:

namespace Users;

public class Unknown : User
{
    // constructor
    public Unknown(string login, string password)
        : base(login, password)
    {
    }

    // identificación
    protected override string? Identify()
    {
        // usuario desconocido
        // ...
        return null;
    }
}
  • Línea 16: el método [Identify] devuelve [null] para indicar que no se reconoció al usuario.

Un programa de prueba para [Program.cs] podría ser el siguiente:

using Users;

Console.WriteLine(new Observer("observer", "pwd1"));
Console.WriteLine(new Administrator("admin", "pwd2"));
try
{
    Console.WriteLine(new Unknown("xx", "yy"));
}
catch (UnknownUserException e)
{
    Console.WriteLine("Unknown user: " + e.Message);
}
// User u = new User("x", "y");   // rechazado: la clase User es abstracta

Observe que en las líneas 3 y 4, el método [User.ToString()] es invocado por el método [WriteLine]. En la línea 7, el constructor lanza una excepción [UnknownUserException], que se captura en la línea 9: el objeto no se crea y [WriteLine]no muestra nada. La línea 13, si se descomenta, es rechazada por el compilador: no se puede crear un objeto de una clase abstracta.

Resultados:

1
2
3
4
> dotnet run
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Una clase abstracta es similar a una interfaz: ambas declaran miembros que otras clases deben implementar. Sin embargo, una clase abstracta puede tener campos, constructores y código común a sus clases derivadas; en cambio, una clase puede derivar de una sola clase abstracta, mientras que puede implementar varias interfaces. Con frecuencia se combinan ambas: una interfaz define el contrato y una clase abstracta que la implementa factoriza el código común a varias implementaciones. Esto es lo que hará la aplicación de ejemplo de este capítulo.

4.8. Clases, interfaces y métodos genéricos

4.8.1. Clases y métodos genéricos

Supongamos que queremos escribir un método que intercambie dos enteros. Este método podría ser así:

1
2
3
4
5
6
7
public static void Swap1(ref int value1, ref int value2)
{
    // intercambiamos los valores de value1 y value2
    int temp = value2;
    value2 = value1;
    value1 = temp;
}

Ahora bien, si quisiéramos intercambiar dos referencias a objetos [Person], escribiríamos:

1
2
3
4
5
6
7
public static void Swap2(ref Person value1, ref Person value2)
{
    // intercambiamos las referencias value1 y value2
    Person temp = value2;
    value2 = value1;
    value1 = temp;
}

Lo que distingue a los dos métodos es el tipo T de los parámetros: [int] en [Swap1], y [Person] en [Swap2]. Las clases, interfaces y métodos genéricos responden a la necesidad de tener código que solo difiere en el tipo de ciertos datos. Se introdujeron con C# 2: antes se usaba el tipo [object], que acepta cualquier tipo, a costa de conversiones de tipo en tiempo de ejecución y de errores que solo se detectan en tiempo de ejecución. Eso es lo que hacía la clase [ArrayList], mencionada en la sección sobre operadores.

El programa [classes-17.cs] presenta una clase genérica, un método genérico y una segunda clase genérica, más realista:

// clases y métodos genéricos
// --- una clase genérica Generic1<T>
// int
int i1 = 1, i2 = 2;
Generic1<int>.Swap(ref i1, ref i2);
Console.WriteLine($"i1={i1},i2={i2}");
// string
string s1 = "s1", s2 = "s2";
Generic1<string>.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
// Person
Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
Generic1<Person>.Swap(ref p1, ref p2);
Console.WriteLine($"p1={p1},p2={p2}");

// --- un método genérico Generic2.Swap<T>
Generic2.Swap<int>(ref i1, ref i2);
Console.WriteLine($"i1={i1},i2={i2}");
// el compilador infiere T a partir del tipo de los parámetros reales
Generic2.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
Generic2.Swap(ref p1, ref p2);
Console.WriteLine($"p1={p1},p2={p2}");

// --- una clase genérica con estado: una pila de elementos de tipo T
MyStack<Person> stack = new MyStack<Person>();
stack.Push(p1);
stack.Push(p2);
Console.WriteLine($"The stack contains {stack.Count} persons");
Person top = stack.Pop();
Console.WriteLine($"Popped person: {top}, {stack.Count} left");
// stack.Push("x");   // rechazado: la pila solo acepta objetos Person

// una clase genérica
class Generic1<T>
{
    public static void Swap(ref T value1, ref T value2)
    {
        // intercambiamos los valores de value1 y value2
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// una clase no genérica con un método genérico
class Generic2
{
    public static void Swap<T>(ref T value1, ref T value2)
    {
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// una pila de elementos de tipo T
class MyStack<T>
{
    // los elementos de la pila
    private readonly List<T> elements = new List<T>();

    // número de elementos
    public int Count => elements.Count;

    // agrega un elemento en la cima de la pila
    public void Push(T element)
    {
        elements.Add(element);
    }

    // retira el elemento de la cima de la pila
    public T Pop()
    {
        if (elements.Count == 0)
        {
            throw new InvalidOperationException("empty stack");
        }
        T element = elements[^1];
        elements.RemoveAt(elements.Count - 1);
        return element;
    }
}

// una persona
class Person
{
    private readonly string firstName;
    private readonly string lastName;
    private readonly int age;

    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public override string ToString() => $"[{firstName}, {lastName}, {age}]";
}
  • líneas 35–42: la clase *[Generic1] está parametrizada por un tipo denominado *[T]. Se le puede dar el nombre que se quiera. Este tipo, [T], se usa luego dentro de la clase como cualquier otro tipo: para los dos parámetros que se van a intercambiar y para la variable temporal [temp]. Se dice que la clase [Generic1] es una clase genérica;
  • línea 5: al usar una clase genérica parametrizada por los tipos T1, T2, …, es necesario “instanciar” estos tipos. Aquí se usa el método estático [Swap] del tipo [Generic1<int>] para indicar que las referencias pasadas al método [Swap] son de tipo [int]. Líneas 9 y 13: lo mismo vale para los tipos [string] y [Person];
  • líneas 47–49: la clase [Generic2] no es genérica, pero su método estático [Swap] sí lo es;
  • línea 17: se invoca el método [Swap] especificando el tipo de los parámetros entre [<>]. En realidad, el compilador puede deducir, a partir del tipo de los parámetros reales, qué variante del método [Swap] usar. Por lo tanto, el código de las líneas 20–22 es válido;
  • líneas 58–81: una clase genérica con estado: una pila de elementos de tipo [T]. Los elementos se apilan en la cima de la pila y se desapilan desde ella. Los elementos se almacenan en una lista genérica de tipo [List<T>] (línea 61), que a su vez está parametrizada por el tipo de la pila, [T]. La expresión [elements[^1]] (línea 79) se refiere al último elemento de la lista;
  • línea 26: una pila de personas. El compilador garantiza que solo contendrá personas: la instrucción de la línea 32 sería rechazada. El método [Pop] devuelve un objeto de tipo [Person], sin conversión.

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run classes-17.cs
i1=2,i2=1
s1=s2,s2=s1
p1=[pauline, dard, 55],p2=[jean, clu, 20]
i1=1,i2=2
s1=s1,s2=s2
p1=[jean, clu, 20],p2=[pauline, dard, 55]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

Observe que, para intercambiar dos variables, C# 7 ofrece ahora una sintaxis más concisa basada en tuplas: [(a, b) = (b, a);].

4.8.2. Restricciones sobre los parámetros genéricos

Se pueden imponer restricciones a los parámetros genéricos mediante la palabra clave [where]. Las principales son las siguientes:

Restricción
Significado
[where T : struct]
T debe ser un tipo de valor (estructura), excluyendo los tipos que admiten valores nulos como [int?]
[where T : class]
T debe ser un tipo de referencia (clase, interfaz, arreglo, delegado)
[where T : notnull]
T debe ser un tipo que no admita valores nulos (de valor o de referencia)
[where T : new()]
T debe tener un constructor público sin parámetros. Esta restricción va al final
[where T : BaseClass]
T debe ser la clase especificada o una clase derivada de ella
[where T : IInterface]
T debe implementar la interfaz especificada. Se pueden especificar varias interfaces
[where T : U]
T debe ser el tipo U o un tipo derivado de U, donde U es otro parámetro genérico
[where T : unmanaged]
T debe ser un tipo de valor que no contenga referencias

El programa [classes-18.cs] usa dos de ellas:

// restricciones sobre los parámetros genéricos
// --- restricción where T : class
string s1 = "s1", s2 = "s2";
Generic3.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
int i1 = 1, i2 = 2;
// Generic3.Swap(ref i1, ref i2);   // error CS0452: int no es un tipo de referencia
Console.WriteLine($"i1={i1},i2={i2}");

// --- restricción where T : IValue
// intercambio de instancias de tipo RandomValue
for (int i = 0; i < 5; i++)
{
    RandomValue c1 = new RandomValue(), c2 = new RandomValue();
    Console.Write($"Before swap --> c1={c1},c2={c2}");
    Generic4.Order(ref c1, ref c2);
    Console.WriteLine($"   After swap --> c1={c1},c2={c2}");
}
// intercambio de instancias de tipo StringValue
StringValue c3 = new StringValue("xxxxxxxxxxxxxx"), c4 = new StringValue("xx");
Console.WriteLine($"Before swap --> c3={c3},c4={c4}");
Generic4.Order(ref c3, ref c4);
Console.WriteLine($"After swap --> c3={c3},c4={c4}");

// T debe ser un tipo de referencia
class Generic3
{
    public static void Swap<T>(ref T value1, ref T value2) where T : class
    {
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// el tipo T debe implementar IValue
class Generic4
{
    public static void Order<T>(ref T element1, ref T element2) where T : IValue
    {
        // si el 1.er elemento es mayor que el 2.º, intercambiamos los elementos
        if (element1.Value() > element2.Value())
        {
            T temp = element2;
            element2 = element1;
            element1 = temp;
        }
    }
}

// un objeto que tiene un valor entero
interface IValue
{
    int Value();
}

// un objeto que tiene un valor aleatorio
class RandomValue : IValue
{
    // generador de números aleatorios compartido por todas las instancias
    // (inicializado con una semilla fija para que los resultados sean reproducibles)
    private static readonly Random generator = new Random(2026);
    // valor del objeto
    private readonly int value = generator.Next(100);

    public int Value() => value;

    public override string ToString() => value.ToString();
}

// un objeto cuyo valor es la longitud de una cadena
class StringValue : IValue
{
    private readonly string s;

    public StringValue(string s)
    {
        this.s = s;
    }

    public int Value() => s.Length;

    public override string ToString() => s;
}
  • líneas 26–28: el método genérico [Swap] exige que el tipo [T] sea un tipo de referencia (restricción [where T : class]);
  • línea 7: si se descomenta esta línea, el compilador informa de un error porque el tipo [int] no es una clase ni una interfaz: es una estructura.

Este es el mensaje de error que se recibe al compilar el programa después de descomentar la línea 7:

> dotnet build classes-18.cs
classes-18.cs(7,10): error CS0452: The type 'int' must be a reference type in order to use it as parameter 'T' in the generic type or method 'Generic3.Swap<T>(ref T, ref T)'

El mensaje del compilador se muestra en el idioma del sistema; en este caso, inglés (en una computadora configurada en francés, estaría en francés). Indica el nombre del archivo, los números de línea y de columna del error, y el código de error ([CS0452]), que se puede consultar en la documentación.

Volvamos al programa [classes-18.cs]:

  • Líneas 37–39: el tipo [T] debe implementar la interfaz [IValue] (líneas 52–54). Esta interfaz tiene un método llamado [Value], utilizado en la línea 42, que devuelve el valor del objeto de tipo [T]. Sin esta restricción, el compilador rechazaría la llamada a [element1.Value()]: no todo objeto de tipo [T] tiene un método llamado [Value]. Las dos referencias [element1] y [element2] se intercambian solo si el valor de [element1] es mayor que el valor de [element2]: el método [Order] ordena los dos elementos de forma ascendente según su valor;
  • líneas 58–68: la clase [RandomValue] implementa la interfaz [IValue]. El valor de una instancia es un número aleatorio entre 0 y 99 (línea 64), proporcionado por un generador de números aleatorios de la clase [Random] compartido por todas las instancias (línea 62). Este generador se inicializa con una “semilla” fija: por lo tanto, siempre produce la misma secuencia de números, lo que hace reproducibles los resultados. El curso de 2008 creaba un generador por cada objeto, inicializado con la hora actual, y debía esperar un milisegundo entre creaciones para obtener números distintos. Cuando no se requiere reproducibilidad, se puede usar en su lugar el generador compartido [Random.Shared];
  • líneas 72–83: la clase [StringValue] también implementa la interfaz [IValue]: el valor de una instancia es la longitud de la cadena pasada al constructor;
  • líneas 12–17: se ordenan instancias de tipo [RandomValue];
  • líneas 20–23: se ordenan instancias de tipo [StringValue].

Resultados:

> dotnet run classes-18.cs
s1=s2,s2=s1
i1=1,i2=2
Before swap --> c1=15,c2=28   After swap --> c1=15,c2=28
Before swap --> c1=91,c2=99   After swap --> c1=91,c2=99
Before swap --> c1=91,c2=7   After swap --> c1=7,c2=91
Before swap --> c1=66,c2=85   After swap --> c1=66,c2=85
Before swap --> c1=62,c2=36   After swap --> c1=36,c2=62
Before swap --> c3=xxxxxxxxxxxxxx,c4=xx
After swap --> c3=xx,c4=xxxxxxxxxxxxxx

4.8.3. Una interfaz genérica: IComparer<T>

Para ilustrar el concepto de interfaz genérica, ordenaremos un arreglo de personas primero por sus nombres y luego por sus edades. El método que permite ordenar un arreglo es el método estático [Sort] de la clase [Array]. Tiene distintas firmas (está sobrecargado). Usaremos la siguiente firma:

public static void Sort<T>(T[] array, IComparer<T>? comparer)

[Sort] es un método genérico donde [T] designa cualquier tipo. El método recibe dos parámetros:

  • [T[] array]: el arreglo de elementos de tipo [T] que se va a ordenar;
  • [IComparer<T>? comparer]: una referencia a un objeto que implementa la interfaz [IComparer<T>].

[IComparer<T>] es una interfaz genérica definida de la siguiente manera (definición simplificada):

1
2
3
4
public interface IComparer<in T>
{
    int Compare(T? x, T? y);
}

La interfaz [IComparer<T>] tiene un solo método. El método [Compare]:

  • recibe dos parámetros, [x] y [y], de tipo [T]. El tipo [T?] indica que sus valores pueden ser [null] (la palabra clave [in] es un detalle técnico que no explicaremos aquí);
  • devuelve un número positivo si x > y, 0 si x == y y un número negativo si x < y. Corresponde al desarrollador definir el significado de los operadores <, == y >. Por ejemplo, si [p1] y [p2] son dos objetos [Person], podemos decir que p1 > p2 si el nombre de [p1] va después del nombre de [p2] en orden alfabético. Esto dará como resultado un orden ascendente según los nombres de las personas. Si queremos ordenar por edad, diremos que p1 > p2 si la edad de [p1] es mayor que la edad de [p2];
  • para ordenar de forma descendente, basta con invertir el signo de los resultados.

Ya sabemos lo suficiente para ordenar un arreglo de personas. El programa [classes-19.cs] es el siguiente:

// la interfaz genérica IComparer<T>: ordenamiento de un arreglo de personas
Person[] persons = [new Person("claude", "pollon", 25), new Person("valentine", "germain", 35), new Person("paul", "germain", 32)];
// visualización
Display("Array to sort", persons);
// orden por apellido y nombre
Array.Sort(persons, new CompareNames());
Display("Array after sorting by last name and first name", persons);
// orden por edad
Array.Sort(persons, new CompareAges());
Display("Array after sorting by age", persons);

// visualización de un arreglo de personas
static void Display(string text, Person[] persons)
{
    Console.WriteLine(text.PadRight(50, '-'));
    foreach (Person p in persons)
    {
        Console.WriteLine(p);
    }
}

// una persona
class Person
{
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string FirstName { get; }
    public string LastName { get; }
    public int Age { get; }

    public override string ToString() => $"[{FirstName}, {LastName}, {Age}]";
}

// comparación de los apellidos y nombres de dos personas
class CompareNames : IComparer<Person>
{
    public int Compare(Person? p1, Person? p2)
    {
        // descartamos el caso de las referencias nulas
        ArgumentNullException.ThrowIfNull(p1);
        ArgumentNullException.ThrowIfNull(p2);
        // comparamos los apellidos
        int i = string.Compare(p1.LastName, p2.LastName, StringComparison.CurrentCulture);
        if (i != 0)
        {
            return i;
        }
        // apellidos iguales: comparamos los nombres
        return string.Compare(p1.FirstName, p2.FirstName, StringComparison.CurrentCulture);
    }
}

// comparación de las edades de dos personas
class CompareAges : IComparer<Person>
{
    public int Compare(Person? p1, Person? p2)
    {
        ArgumentNullException.ThrowIfNull(p1);
        ArgumentNullException.ThrowIfNull(p2);
        // comparamos las edades
        return p1.Age.CompareTo(p2.Age);
    }
}
  • Línea 2: el arreglo de personas;
  • línea 6: ordenamiento del arreglo de personas por apellido y nombre. El segundo parámetro del método genérico [Sort] es una instancia de la clase [CompareNames], que implementa la interfaz genérica [IComparer<Person>];
  • líneas 40–54: la clase [CompareNames]. Su método [Compare] implementa el método [int Compare(T? x, T? y)] de la interfaz [IComparer<T>], donde [T] = [Person]:
    • líneas 45–46: como los parámetros se declaran de tipo [Person?], el compilador exige que se trate una referencia nula antes de usar [p1] y [p2]. El método estático [ArgumentNullException.ThrowIfNull] lanza una excepción si su parámetro es [null]; el compilador sabe que, después de invocarlo, el parámetro no es nulo;
    • línea 48: el método [string.Compare] compara dos cadenas en orden alfabético según la cultura actual, en este caso el francés;
  • línea 9: ordenamiento del arreglo de personas por edad, mediante una instancia de la clase [CompareAges] de las líneas 59–66. El método [CompareTo] de los tipos numéricos devuelve un número negativo, cero o positivo según que el número sea menor, igual o mayor que su parámetro: es exactamente lo que espera el método [Compare].

Resultados:

> dotnet run classes-19.cs
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by last name and first name---
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]

Veremos en el capítulo 7, dedicado a los delegados, que también podemos pasar una simple función de comparación a [Array.Sort] sin escribir una clase: [Array.Sort(persons, (p1, p2) => p1.Age.CompareTo(p2.Age));].

4.8.4. Miembros estáticos abstractos y matemática genérica

¿Podemos escribir un método genérico que sume los elementos de un arreglo de números, sea cual sea su tipo ([int], [double], [decimal]…)? Necesitaríamos poder escribir [sum + value] y disponer del elemento cero de tipo [T]. Sin embargo, el operador [+] es un método estático, y una restricción de interfaz estándar solo permite usar métodos de instancia. Desde C# 11, una interfaz puede declarar miembros estáticos abstractos ([static abstract]), que todo tipo que la implemente debe proporcionar. .NET 7 ha derivado de ello la “matemática genérica”: todos los tipos numéricos implementan la interfaz [INumber<T>] del espacio de nombres [System.Numerics], que declara el cero del tipo ([T.Zero]), los operadores aritméticos, etc. El programa [classes-20.cs] lo demuestra:

using System.Numerics;

// miembros de interfaz estáticos abstractos (C# 11) y matemática genérica
Console.WriteLine($"Sum of integers: {Sum([1, 2, 3])}");
Console.WriteLine($"Sum of reals: {Sum([1.5, 2.25])}");
Console.WriteLine($"Sum of decimals: {Sum([10.5m, 0.25m])}");
// una interfaz propia
Describe<Cat>();
Describe<Dog>();

// suma de los elementos de un arreglo de números de tipo T
// INumber<T> declara miembros estáticos abstractos: T.Zero, el operador +, ...
static T Sum<T>(T[] values) where T : INumber<T>
{
    T sum = T.Zero;
    foreach (T value in values)
    {
        sum += value;
    }
    return sum;
}

// el método usa un miembro estático del tipo T
static void Describe<T>() where T : IAnimal
{
    Console.WriteLine($"{typeof(T).Name} : {T.Sound}");
}

interface IAnimal
{
    // miembro estático que cada clase debe implementar
    static abstract string Sound { get; }
}

class Cat : IAnimal
{
    public static string Sound => "meow";
}

class Dog : IAnimal
{
    public static string Sound => "woof";
}
  • líneas 13–20: el método genérico *[Sum] exige que *[T] implemente *[INumber<T>]. Así puede usar el miembro estático [T.Zero] (línea 15) y el operador [+] del tipo [T]* (línea 18);
  • líneas 4–6: el mismo método suma valores [int], [double] y [decimal]. Las expresiones de colección crean arreglos del tipo esperado;
  • líneas 29–32: una interfaz personalizada que declara una propiedad estática abstracta [Sound];
  • líneas 35–42: dos clases implementan la propiedad estática;
  • líneas 24–26: el método genérico [Describe] usa el miembro estático [T.Sound] del tipo [T], sin necesidad de una instancia de ese tipo. [typeof(T)] devuelve la descripción del tipo [T], cuya propiedad [Name] es el nombre.

Resultados:

1
2
3
4
5
6
> dotnet run classes-20.cs
Sum of integers: 6
Sum of reals: 3,75
Sum of decimals: 10,75
Cat : meow
Dog : woof

4.9. Espacios de nombres

Para escribir una línea en la pantalla, usamos la instrucción [Console.WriteLine(...)]. Si consultamos la definición de la clase [Console] en la documentación de .NET, vemos que forma parte del espacio de nombres [System]. Esto significa que la clase [Console] debería designarse como [System.Console], y que en realidad deberíamos escribir [System.Console.WriteLine(...)]. Evitamos esto mediante una cláusula [using]:

1
2
3
using System;
...
Console.WriteLine(...);

Esto significa que el espacio de nombres [System] se importa mediante la cláusula [using]. Cuando el compilador encuentra un nombre de clase (en este caso, [Console]), lo busca en los diversos espacios de nombres importados por las cláusulas [using]. Aquí encuentra la clase [Console] en el espacio de nombres [System]. En un proyecto .NET reciente, ni siquiera necesitamos escribir [using System;]: este espacio de nombres está incluido en las instrucciones implícitas **using** del proyecto, como vimos al comienzo del capítulo.

La documentación proporciona un segundo dato sobre la clase [Console]: el ensamblado que la contiene, el archivo [System.Console.dll]. Un ensamblado es el resultado de compilar un proyecto: un archivo [.dll] (biblioteca) o un ejecutable. Para usar las clases de un ensamblado, el compilador debe conocerlo. El curso de 2008 mostraba cómo pasar estas referencias al compilador [csc] por la línea de comandos ([csc /r:fic1.dll /r:fic2.dll prog.cs]). Hoy ya no invocamos el compilador directamente: los ensamblados del framework .NET se referencian automáticamente, y el archivo [.csproj] referencia las demás bibliotecas, ya sea como paquetes ([PackageReference]) o como proyectos ([ProjectReference]), como veremos en el capítulo 6, dedicado a las arquitecturas en capas.

Al crear una clase, se puede crear dentro de un espacio de nombres. La finalidad de estos espacios de nombres es evitar conflictos de nombres entre clases, por ejemplo, cuando se distribuyen. Consideremos dos empresas, E1 y E2, que distribuyen clases empaquetadas en los ensamblados [e1.dll] y [e2.dll], respectivamente. Supongamos que un cliente C compra ambos conjuntos de clases, en los que las dos empresas han definido una clase llamada [Person]. Si el programa del cliente usa la clase [Person], el compilador no sabrá si debe usar la clase [Person] de [e1.dll] o la de [e2.dll]. Informará de un error. Si la empresa E1 crea sus clases en un espacio de nombres llamado [E1] y la empresa E2 crea las suyas en un espacio de nombres llamado [E2], las dos clases llamadas [Person] pasarán a llamarse [E1.Person] y [E2.Person]. El cliente deberá usar [E1.Person] o [E2.Person] (o un alias) en sus clases, pero no [Person]. El espacio de nombres resuelve esta ambigüedad.

Para crear una clase en un espacio de nombres, el curso de 2008 indicaba:

1
2
3
4
namespace NamespaceName
{
    // definición de la clase
}

Este formato sigue siendo válido (permite incluir varios espacios de nombres en un solo archivo), pero desde C# 10 se prefiere el espacio de nombres de ámbito de archivo —[namespace NamespaceName;]— colocado al comienzo del archivo, ya que ahorra un nivel de sangría. Este es el formato que hemos usado desde el comienzo de este capítulo.

El proyecto [Namespaces] de la solución ilustra estos conceptos. Contiene dos clases [Person], en dos espacios de nombres diferentes. La primera, [E1/Person.cs]:

// las clases de este archivo pertenecen al espacio de nombres E1
namespace E1;

public class Person
{
    private readonly string firstName;
    private readonly string lastName;

    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public override string ToString() => $"E1.Person[{firstName}, {lastName}]";
}

La segunda, *[E2/Person.cs]*:

// las clases de este archivo pertenecen al espacio de nombres E2
namespace E2;

public class Person
{
    public Person(string name)
    {
        Name = name;
    }

    public string Name { get; }

    public override string ToString() => $"E2.Person[{Name}]";
}

Observe que la carpeta de un archivo fuente no determina su espacio de nombres; solo importa la declaración *[namespace]* . Sin embargo, es una convención útil organizar los archivos de un mismo espacio de nombres en una carpeta con el mismo nombre.

El archivo [GlobalUsings.cs] contiene las siguientes cláusulas [global using] (C# 10):

1
2
3
// importaciones válidas para todos los archivos fuente del proyecto
global using E1;
global using System.Text;

Una directiva [global using] se aplica a todos los archivos fuente del proyecto. Así es como se implementan las instrucciones using implícitas: durante la compilación, el archivo del SDK genera un archivo [obj/Debug/net10.0/Namespaces.GlobalUsings.g.cs] que contiene las líneas [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;] y [global using System.Threading.Tasks;]. También se puede agregar una instrucción "using" global en el archivo [.csproj]: [<Using Include="E1" />].

El programa principal, [Program.cs], es el siguiente:

// alias de espacios de nombres y alias de tipos
using PersonE2 = E2.Person;
using Point = (int X, int Y);

// Person designa E1.Person: el espacio de nombres E1 se importa en GlobalUsings.cs
Person p1 = new Person("Jean", "Dupont");
// PersonE2 es un alias de E2.Person
PersonE2 p2 = new PersonE2("Durand");
// el nombre completo de una clase elimina toda ambigüedad
E2.Person p3 = new E2.Person("Martin");
Console.WriteLine($"{p1} {p2} {p3}");
// nombre completo de los tipos y ensamblado que los contiene
Console.WriteLine($"{typeof(Person).FullName}, {typeof(PersonE2).FullName}");
Console.WriteLine($"{typeof(Console).FullName} is in the assembly {typeof(Console).Assembly.GetName().Name}");
// StringBuilder es conocido gracias a global using System.Text
StringBuilder sb = new StringBuilder("abc");
Console.WriteLine(sb.Append("def"));
// Point es un alias del tipo tupla (int X, int Y)
Point origin = (0, 0);
Console.WriteLine($"origin=({origin.X},{origin.Y})");
  • línea 2: un alias: en este archivo, [PersonE2] se refiere a la clase [E2.Person];
  • línea 3: a partir de C# 12, un alias puede referirse a cualquier tipo; aquí se refiere a una tupla con dos campos llamados [X] y [Y];
  • línea 6: [Person] se refiere a la clase [E1.Person], gracias a la cláusula [global using E1;]. Si el espacio de nombres [E2] también se importara, el nombre [Person] sería ambiguo y el compilador lo rechazaría;
  • línea 8: uso del alias;
  • línea 10: el nombre completo de la clase resuelve cualquier ambigüedad;
  • línea 13: la propiedad [FullName] de un tipo devuelve su nombre completo, precedido por su espacio de nombres;
  • línea 14: la propiedad [Assembly] de un tipo hace referencia al ensamblado que lo contiene;
  • línea 16: la clase [System.Text.StringBuilder] se define mediante la cláusula [global using System.Text;];
  • línea 19: uso del alias para el tipo tupla.

Resultados:

1
2
3
4
5
6
> dotnet run
E1.Person[Jean, Dupont] E2.Person[Durand] E2.Person[Martin]
E1.Person, E2.Person
System.Console is in the assembly System.Console
abcdef
origin=(0,0)

4.10. Records

Muchas clases sirven solo para transportar datos: una persona, una nota, un tramo impositivo… Para ellas, siempre escribimos el mismo código: un constructor que copia sus parámetros en propiedades, un método [ToString] que muestra esas propiedades y, a menudo, métodos de comparación. C# 9 introdujo los records: el compilador genera ese código a partir de una declaración de una sola línea. Ya hemos visto la versión para estructuras ([record struct]); esta es la versión para clases ([classes-21.cs]):

// registros (records) (C# 9)
Person r1 = new Person("Jean", "Dupont", 30);
Person r2 = new Person("Jean", "Dupont", 30);
// ToString generado por el compilador
Console.WriteLine(r1);
// igualdad por valor: r1 y r2 son dos objetos distintos pero iguales
Console.WriteLine($"r1 == r2 : {r1 == r2}, same object: {ReferenceEquals(r1, r2)}");
// las propiedades son de solo lectura (init)
// r1.Age = 31;   // rechazado
// la expresión with crea una copia modificada
Person r3 = r1 with { Age = 31 };
Console.WriteLine(r3);
Console.WriteLine($"r1 == r3 : {r1 == r3}");
// deconstrucción en variables
var (firstName, lastName, age) = r1;
Console.WriteLine($"first name={firstName}, last name={lastName}, age={age}");

// lo mismo con una clase
PersonC c1 = new PersonC("Jean", "Dupont", 30);
PersonC c2 = new PersonC("Jean", "Dupont", 30);
Console.WriteLine(c1);
Console.WriteLine($"c1 == c2 : {c1 == c2}");

// un registro derivado
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Console.WriteLine(e);
Console.WriteLine(e.Identity);
// la igualdad tiene en cuenta el tipo: una Person no es igual a un Teacher
Person pe = new Person("Lucile", "Dumas", 56);
Console.WriteLine($"pe == e : {pe == e}");

// un registro posicional: FirstName, LastName, Age son propiedades públicas { get; init; }
record Person(string FirstName, string LastName, int Age)
{
    // se pueden agregar miembros
    public virtual string Identity => $"[{FirstName}, {LastName}, {Age}]";
}

// un registro puede derivar de otro registro
record Teacher(string FirstName, string LastName, int Age, int Section) : Person(FirstName, LastName, Age)
{
    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}

// una clase equivalente... o casi
class PersonC
{
    public PersonC(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string FirstName { get; init; }
    public string LastName { get; init; }
    public int Age { get; init; }
}
  • Líneas 33–36: un record posicional. La declaración [record Person(string FirstName, string LastName, int Age)] genera:
    • un constructor con tres parámetros;
    • tres propiedades públicas de solo lectura: [FirstName], [LastName] y [Age] ([{ get; init; }]);
    • un método [ToString] que muestra el nombre del tipo y sus propiedades públicas (línea 5);
    • los métodos [Equals] y [GetHashCode] y los operadores [==] y [!=], que comparan los valores de las propiedades en lugar de las referencias;
    • un método [Deconstruct] que descompone el objeto en variables (línea 15);
    • la expresión [with];
    • un record también puede, como una clase, tener miembros adicionales; aquí, la propiedad [Identity];
  • Línea 7: [r1] y [r2] son dos objetos distintos ([ReferenceEquals] devuelve [false]) pero son iguales en el sentido de [] porque sus propiedades tienen los mismos valores. En una clase ordinaria, [] compara las referencias (línea 22);
  • línea 11: como un record es, en principio, inmutable, no se modifica (línea 9): la expresión [with] crea una copia de [r1] en la que se han cambiado ciertas propiedades;
  • líneas 40–42: un record puede derivar de otro record (no de una clase ordinaria). Los parámetros [FirstName], [LastName] y [Age] se pasan al constructor del record padre. La propiedad [Identity], declarada [virtual] en [Person], se redefine;
  • línea 30: la igualdad de los records tiene en cuenta el tipo real de los objetos: un [Person] nunca es igual a un [Teacher], aunque sus propiedades comunes sean iguales;
  • líneas 46–57: una clase que se parece al record [Person]… salvo que hubo que escribir el constructor y las propiedades, y que no se proporcionan la igualdad por valor, [ToString] ni [with].

Resultados:

> dotnet run classes-21.cs
Person { FirstName = Jean, LastName = Dupont, Age = 30, Identity = [Jean, Dupont, 30] }
r1 == r2 : True, same object: False
Person { FirstName = Jean, LastName = Dupont, Age = 31, Identity = [Jean, Dupont, 31] }
r1 == r3 : False
first name=Jean, last name=Dupont, age=30
PersonC
c1 == c2 : False
Teacher { FirstName = Lucile, LastName = Dumas, Age = 56, Identity = Teacher[[Lucile, Dumas, 56],61], Section = 61 }
Teacher[[Lucile, Dumas, 56],61]
pe == e : False

Observe que el método [ToString] generado también muestra la propiedad calculada [Identity] (línea 2), mientras que el método [ToString] de la clase [PersonC] se limita a mostrar el nombre de la clase (línea 7).

Resumamos las diferencias entre una clase y un record:

 
Clase
Record
Igualdad: [==], [Equals]
mismo objeto (referencias iguales)
mismos valores de propiedades, mismo tipo
[ToString]
nombre del tipo
nombre del tipo y propiedades públicas
constructor y propiedades
por escribir
Generados por la declaración posicional, propiedades [init]
copia modificada
por escribir
expresión [with]
herencia
de una clase
de un record

Un record se usa para datos definidos por su valor (una persona obtenida de una base de datos, un mensaje intercambiado por una red, un tramo impositivo), y una clase se usa para un objeto con identidad y comportamiento (un servicio de cálculo, una conexión, una lista editable). Un record se escribe como [record] (o [record class], que es idéntico) para un tipo de referencia, y [record struct] para un tipo de valor.

4.11. Constructores primarios

Los records posicionales declaran los parámetros de su constructor inmediatamente después de su nombre. Desde C# 12, las clases y estructuras ordinarias pueden hacer lo mismo: es el constructor primario. El programa [classes-22.cs] lo ilustra:

// constructores primarios (C# 12)
Person p = new Person("Jean", "Dupont", 30);
Console.WriteLine(p.Identity);
p.GrowOlder();
Console.WriteLine(p.Identity);
// otro constructor
Person unknown = new Person("Martin");
Console.WriteLine(unknown.Identity);
// una clase derivada
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Console.WriteLine(e.Identity);
// una estructura
Point pt = new Point(3, 4);
Console.WriteLine($"pt=({pt.X},{pt.Y}), distance to the origin: {pt.Distance()}");

// una clase con un constructor primario
class Person(string firstName, string lastName, int age)
{
    // los parámetros firstName y lastName se usan para inicializar propiedades
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;
    // el parámetro age lo usan los métodos: se conserva en un campo oculto
    public int Age => age;

    // cualquier otro constructor debe llamar al constructor primario
    public Person(string lastName) : this("?", lastName, 0)
    {
    }

    public void GrowOlder() => age++;

    public virtual string Identity => $"[{FirstName}, {LastName}, {age}]";
}

// una clase derivada: pasa tres de sus parámetros al constructor primario de la clase padre
class Teacher(string firstName, string lastName, int age, int section) : Person(firstName, lastName, age)
{
    public int Section { get; } = section;

    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}

// una estructura con un constructor primario
readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;

    public double Distance() => Math.Sqrt(X * X + Y * Y);
}
  • línea 17: la clase [Person] tiene un constructor primario con tres parámetros. A diferencia de los de un record, estos parámetros no se convierten en propiedades públicas: son parámetros, visibles en todo el cuerpo de la clase;
  • líneas 20–21: los parámetros [firstName] y [lastName] se usan para inicializar dos propiedades de solo lectura;
  • línea 23: el parámetro [age] es usado por miembros de la clase: la propiedad [Age], el método [GrowOlder] (línea 30) y la propiedad [Identity]. El compilador lo almacena entonces en un campo oculto, que puede modificarse ([age++]). Se recomienda no mezclar estos dos usos para un mismo parámetro (inicializar una propiedad y usarlo directamente), ya que podrían resultar dos copias del mismo dato;
  • línea 26: una clase con un constructor primario puede tener otros constructores, pero estos deben invocar al constructor primario mediante [this(...)];
  • línea 36: una clase derivada pasa algunos de los parámetros de su constructor primario al constructor de su clase padre: [: Person(firstName, lastName, age)]. Esto equivale a [: base(firstName, lastName, age)] en un constructor tradicional;
  • línea 44: una estructura también puede tener un constructor primario.

Resultados:

1
2
3
4
5
6
> dotnet run classes-22.cs
[Jean, Dupont, 30]
[Jean, Dupont, 31]
[?, Martin, 0]
Teacher[[Lucile, Dumas, 56],61]
pt=(3,4), distance to the origin: 5

El constructor primario elimina el código repetitivo de los constructores que se limitan a almacenar sus parámetros. Se usa mucho en las clases que reciben servicios durante su construcción, como veremos con la inyección de dependencias (capítulo 6).

4.12. Métodos y miembros de extensión

¿Cómo se agrega un método a una clase que no se puede modificar, como la clase [string] proveniente de .NET? C# 3 introdujo los métodos de extensión: métodos estáticos que se usan como métodos de instancia del tipo extendido. C# 14 extiende este mecanismo a las propiedades y a los miembros estáticos con los bloques de extensión. El programa [classes-23.cs] demuestra ambos:

// métodos de extensión (C# 3) y miembros de extensión (C# 14)
Person p = new Person("jean", "dupont", 30);
// métodos de extensión clásicos: se usan como métodos de instancia
Console.WriteLine(p.Initials());
Console.WriteLine("jean".FirstUpper());
// el compilador traduce la llamada anterior en la siguiente llamada a un método estático
Console.WriteLine(ClassicExtensions.FirstUpper("jean"));
// propiedades de extensión (C# 14)
Console.WriteLine($"{p.FullName} is an adult: {p.IsAdult}");
Console.WriteLine($"\"the weather is nice\" has {"the weather is nice".NbWords} words");
// miembro de extensión estático (C# 14): se usa con el nombre del tipo
Person unknown = Person.Unknown;
Console.WriteLine($"{unknown.FullName} is an adult: {unknown.IsAdult}");

// una persona
record Person(string FirstName, string LastName, int Age);

// métodos de extensión clásicos: métodos estáticos de una clase estática,
// cuyo primer parámetro va precedido de la palabra clave this
static class ClassicExtensions
{
    public static string Initials(this Person p)
    {
        return $"{char.ToUpper(p.FirstName[0])}.{char.ToUpper(p.LastName[0])}.";
    }

    public static string FirstUpper(this string s)
    {
        return s.Length == 0 ? s : char.ToUpper(s[0]) + s[1..];
    }
}

// bloques de extensión (C# 14)
static class Cs14Extensions
{
    // miembros de instancia agregados al tipo Person: p designa el objeto extendido
    extension(Person p)
    {
        public bool IsAdult => p.Age >= 18;

        public string FullName => $"{p.FirstName.FirstUpper()} {p.LastName.ToUpper()}";
    }

    // miembros estáticos agregados al tipo Person
    extension(Person)
    {
        public static Person Unknown => new Person("?", "?", 0);
    }

    // una propiedad agregada al tipo string
    extension(string s)
    {
        public int NbWords => s.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
  • líneas 20–29: los métodos de extensión tradicionales son métodos estáticos de una clase estática. Su primer parámetro, precedido por la palabra clave [this], especifica el objeto extendido:
    • [Initials(this Person p)] extiende el tipo [Person]: se invoca como [p.Initials()] (línea 4);
    • [FirstUpper(this string s)] extiende el tipo [string]: se invoca como ["jean".FirstUpper()] (línea 5). La expresión [s[1..]] se refiere a la subcadena que comienza en el carácter n.º 1;
  • línea 7: un método de extensión sigue siendo un método estático ordinario: el compilador traduce ["jean".FirstUpper()] a esta llamada. El método solo tiene acceso a los miembros públicos del objeto extendido;
  • líneas 34–53: los bloques de extensión de C# 14, también declarados dentro de una clase estática:
    • líneas 37–41: el bloque ***[extension(Person p)] agrega al tipo *[Person] los miembros de instancia que contiene. *[p]* se refiere al objeto extendido. Ahora se pueden agregar propiedades ([IsAdult], [FullName]), lo que no era posible con los métodos de extensión tradicionales;
    • líneas 45–47: el bloque [extension(Person)], sin nombres de parámetro, agrega miembros estáticos al tipo [Person]: [Person.Unknown] (línea 12) se escribe como si la propiedad se hubiera declarado en el record [Person];
    • líneas 51–53: una propiedad de extensión de tipo [string], usada en la línea 10.

Resultados:

1
2
3
4
5
6
7
> dotnet run classes-23.cs
J.D.
Jean
Jean
Jean DUPONT is an adult: True
"the weather is nice" has 4 words
? ? is an adult: False

Los métodos de extensión son omnipresentes en .NET: los operadores de LINQ ([Where], [Select], [OrderBy]…), que se tratan en el próximo capítulo, son métodos de extensión de la interfaz [IEnumerable<T>]. Para que una extensión pueda usarse, debe importarse el espacio de nombres de su clase estática.

4.13. Filtrado de patrones en objetos

La expresión [switch] y el filtrado de patrones no se limitan a valores simples (números, cadenas); también se aplican a objetos. Se puede comprobar el tipo de un objeto, verificar los valores de sus propiedades y obtener el objeto convertido al tipo correcto, todo en una sola expresión. El programa [classes-24.cs] usa una jerarquía de tres records:

// coincidencia de patrones (pattern matching) en objetos
object?[] objects =
[
    new Person("Jean", "Dupont", 30),
    new Person("Lise", "Morel", 12),
    new Teacher("Lucile", "Dumas", 56, 61),
    new Teacher("Marc", "Petit", 44, 27),
    new Student("Paul", "Martin", 19, "computer science"),
    "a string",
    42,
    null,
];

// 1 - el patrón de tipo: is Type variable
foreach (object? o in objects)
{
    if (o is Person p)
    {
        // aquí p es una Person (o un objeto de una clase derivada)
        Console.WriteLine($"{p.FirstName} is of type {p.GetType().Name}");
    }
}

// 2 - el patrón de propiedad: { Property: patrón }
foreach (object? o in objects)
{
    if (o is Person { Age: >= 18 } adult)
    {
        Console.WriteLine($"{adult.FirstName} is an adult");
    }
}

// 3 - la expresión switch sobre el tipo y las propiedades del objeto
foreach (object? o in objects)
{
    Console.WriteLine(Describe(o));
}

static string Describe(object? o) => o switch
{
    Teacher { Section: 27 } e => $"{e.FirstName} teaches computer science",
    Teacher e => $"{e.FirstName} teaches in section {e.Section}",
    Student(var firstName, _, _, var major) => $"{firstName} studies {major}",
    Person { Age: < 18 } p => $"{p.FirstName} is a minor",
    Person p => $"{p.FirstName} is {p.Age} years old",
    string s => $"a string of {s.Length} characters",
    int n and > 0 => $"the positive integer {n}",
    null => "the null reference",
    _ => "an unknown object",
};

record Person(string FirstName, string LastName, int Age);
record Teacher(string FirstName, string LastName, int Age, int Section) : Person(FirstName, LastName, Age);
record Student(string FirstName, string LastName, int Age, string Major) : Person(FirstName, LastName, Age);
  • líneas 52–54: un record [Person] y dos records derivados, [Teacher] y [Student];
  • líneas 2–11: un arreglo de objetos de diversos tipos (el tipo [object?] también acepta [null]);
  • línea 17: el patrón de tipo [o is Person p] es verdadero si [o] hace referencia a un objeto de tipo [Person] o de un tipo derivado; en ese caso, la variable [p], de tipo [Person], hace referencia a este objeto. Esto evita la secuencia del curso de 2008: comprobar el tipo con [is] y luego convertir con [(Person)o]. El patrón es falso si [o] es igual a [null];
  • línea 27: el patrón de propiedades [{ Age: >= 18 }] (C# 8) comprueba el valor de una propiedad del objeto, en este caso mediante un patrón relacional [>= 18] (C# 9). Se pueden comprobar varias propiedades separándolas con comas;
  • líneas 39–49: la expresión [switch] prueba los patrones en orden y devuelve el valor asociado al primero que coincide:
    • línea 41: un profesor de la sección 27;
    • línea 42: cualquier otro profesor. El orden es importante: si se colocara antes del anterior, este patrón haría inalcanzable el anterior, lo que el compilador señalaría como un error;
    • línea 43: un patrón posicional: usa el método [Deconstruct] del record [Student] para extraer sus propiedades en el orden en que se declararon; [_] ignora una propiedad;
    • línea 44: un menor de edad;
    • línea 47: un entero positivo, mediante el combinador [and] (C# 9); también existen [or] y [not];
    • línea 48: el patrón [null];
    • línea 49: el patrón [_] acepta todo. Sin él, el compilador informaría de que la expresión [switch] no cubre todos los casos.

Resultados:

> dotnet run classes-24.cs
Jean is of type Person
Lise is of type Person
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference

Observe que el patrón de tipo también coincide con los tipos derivados: el bucle del patrón de tipo (líneas 2–6) capturó a los profesores y al estudiante, que son personas. El filtrado de patrones es una alternativa útil a los [if (o is ...)] en cascada; sin embargo, no debe sustituir al polimorfismo: cuando el comportamiento depende del tipo del objeto y se tiene control sobre la jerarquía de clases, un método virtual redefinido en cada clase sigue siendo la solución orientada a objetos.

4.14. Tipos de referencia que admiten valores nulos

Desde el comienzo de este capítulo, nuestros proyectos tienen habilitados los tipos de referencia que admiten valores nulos ([<Nullable>enable</Nullable>] en el archivo [.csproj], una opción habilitada de manera predeterminada en las aplicaciones de un solo archivo). El principio es el siguiente:

  • una variable, campo, parámetro o resultado de tipo de referencia declarado sin signo de interrogación (por ejemplo, de tipo [Person]) nunca debería ser igual a [null];
  • si puede ser [null], se declara con un signo de interrogación: [Person?];
  • el compilador analiza el flujo del programa y emite una advertencia cada vez que se usa un valor potencialmente nulo sin verificación, o se asigna a una variable que no admite valores nulos.

El lenguaje no prohíbe nada en tiempo de ejecución: se trata de advertencias de compilación, pero un programa que compila sin advertencias es mucho menos propenso a la excepción [NullReferenceException], el error de ejecución más común. El curso de 2008, anterior a esta característica (C# 8, 2019), obviamente no la trataba. El programa [classes-25.cs] demuestra los operadores asociados a los tipos que admiten valores nulos:

// tipos de referencia que admiten valores nulos aplicados a objetos
Person[] persons = [new Person("Jean", "Dupont") { MiddleName = "Marie" }, new Person("Paul", "Martin")];
foreach (Person p in persons)
{
    // ?. : devuelve null si el objeto de la izquierda es null; de lo contrario accede al miembro
    int? length = p.MiddleName?.Length;
    // ?? : devuelve el operando derecho si el izquierdo es null
    Console.WriteLine($"{p.FirstName} : middle name={p.MiddleName ?? "(none)"}, length={length?.ToString() ?? "null"}");
}

// un método que puede devolver null: su tipo de retorno es Person?
Person? found = Find(persons, "Durand");
Console.WriteLine(found?.FirstName ?? "Durand: person not found");
// después de una prueba, el compilador sabe que la referencia no es null
found = Find(persons, "Martin");
if (found is not null)
{
    Console.WriteLine($"Martin : {found.FirstName}");
}
// ??= : asigna un valor solo si la variable (o la propiedad) es null
persons[1].MiddleName ??= "Pierre";
persons[0].MiddleName ??= "Pierre";
Console.WriteLine($"{persons[0].MiddleName}, {persons[1].MiddleName}");
// C# 14: asignación condicional: solo se realiza si el objeto no es null
Find(persons, "Dupont")?.MiddleName = "Louise";
Find(persons, "Durand")?.MiddleName = "Louise";
Console.WriteLine(persons[0].MiddleName);
// ! : afirmamos al compilador que la referencia no es null
Person martin = Find(persons, "Martin")!;
Console.WriteLine(martin.FirstName);
// las líneas siguientes provocan advertencias del compilador
// Console.WriteLine(new Person("Lise", "Morel").MiddleName.Length);   // warning
// Person dupond = Find(persons, "Dupond");   // warning
// persons[0] = null;   // warning

// búsqueda de una persona por apellido
static Person? Find(Person[] persons, string lastName)
{
    foreach (Person p in persons)
    {
        if (p.LastName == lastName)
        {
            return p;
        }
    }
    return null;
}

class Person
{
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    // propiedades no nullable: nunca deben ser null
    public string FirstName { get; }
    public string LastName { get; }
    // propiedad nullable: null significa "sin segundo nombre"
    public string? MiddleName { get; set; }
}
  • líneas 58–61: la clase [Person] tiene dos propiedades que no admiten valores nulos, inicializadas por el constructor, y una propiedad que sí los admite, [MiddleName]: [null] significa “sin segundo nombre”;
  • línea 6: el operador [?.] (C# 6) devuelve [null] si el objeto a su izquierda es [null], y en caso contrario accede al miembro. El resultado es de tipo [int?];
  • línea 8: el operador [??] devuelve su operando izquierdo si no es [null], y su operando derecho en caso contrario;
  • líneas 37–46: la función [Find] devuelve la persona buscada o [null]; su tipo de retorno es [Person?];
  • línea 13: se combinan los dos operadores;
  • líneas 16–18: tras la verificación [is not null], el compilador sabe que [found] no es igual a [null]: [found.FirstName] puede escribirse sin advertencia;
  • líneas 21–22: el operador [??=] solo asigna un valor a la propiedad si es [null]: el segundo nombre de Jean, “Marie”, no se reemplaza;
  • líneas 25–26: C# 14 permite usar [?.] en el lado izquierdo de una asignación: la asignación se realiza solo si el objeto no es nulo. Dupont existe y recibe un nuevo segundo nombre; Durand no existe y la instrucción no hace nada;
  • línea 29: el operador [!] (un operador “null-forgiving”, de tolerancia a nulos) le indica al compilador que sabemos que el valor no es nulo: no emite ninguna advertencia. Corresponde al desarrollador estar seguro de ello: si el valor es nulo en tiempo de ejecución, se producirá un error más adelante. Úselo con moderación;
  • líneas 32–34: tres instrucciones que provocan advertencias.

Resultados:

1
2
3
4
5
6
7
8
> dotnet run classes-25.cs
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand: person not found
Martin : Paul
Marie, Pierre
Louise
Paul

Descomentemos las tres últimas líneas del programa principal y compilemos:

1
2
3
4
> dotnet build classes-25.cs
classes-25.cs(32,19): warning CS8602: Dereference of a possibly null reference.
classes-25.cs(33,17): warning CS8600: Converting null literal or possible null value to non-nullable type.
classes-25.cs(34,14): warning CS8625: Cannot convert null literal to non-nullable reference type.
  • Advertencia [CS8602]: la propiedad [MiddleName] de una persona recién creada puede ser [null]: no se puede usar su propiedad [Length] sin verificación;
  • Advertencia [CS8600]: la función [Find] puede devolver [null], un valor que se asigna a una variable de tipo [Person] que no admite valores nulos;
  • Advertencia [CS8625]: la constante [null] se asigna a un elemento de tipo [Person], que no admite valores nulos.

El programa se ejecutaría a pesar de estas advertencias, pero la primera línea lanzaría una excepción [NullReferenceException]. En este curso, todos los programas compilan sin ninguna advertencia: corregimos el código (declarando el tipo como que admite valores nulos, verificando el valor o proporcionando un valor predeterminado mediante [??]) en lugar de ignorar la advertencia o suprimirla con [!].

4.15. Aplicación de ejemplo - V2

Retomaremos el cálculo del impuesto que vimos en el capítulo anterior (versión 1) y lo implementaremos con clases e interfaces. Recordemos el problema. 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 (con la tabla de 2004 para los ingresos de 2003, conservada tal cual: es un ejercicio):

  • calculamos 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 sus 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:
límite
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 tres campos. Para calcular el impuesto I, se busca la primera fila en la que QF ≤ el límite. Por ejemplo, si QF = 5,000, se encontrará la fila (8,382; 0.068; 291.09). El impuesto I es entonces igual a 0.068 × R - 291.09 × partes. Si QF es tal que la condición QF ≤ límite nunca se cumple, se usan los coeficientes de la última fila, de donde resulta un impuesto I = 0.481 × R - 9,505.54 × partes.

La aplicación forma el proyecto [TaxV2] de la solución:

1
2
3
4
5
6
7
TaxV2/
  TaxBracket.cs        a bracket of the tax scale
  ITax.cs              the tax calculation interface
  AbstractTax.cs       an abstract class implementing ITax
  HardwiredTax.cs      a derived class, with hard-coded data
  Program.cs           the program that dialogues with the user
  TaxV2.csproj

Primero, definimos un tipo capaz de encapsular una fila del arreglo anterior [TaxBracket.cs]:

1
2
3
4
namespace TaxV2;

// un tramo de la tabla de impuestos
public readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN);

El curso de 2008 usaba una estructura con tres propiedades automáticas de lectura y escritura. Nosotros usamos una estructura record inmutable ([readonly record struct]):

  • una estructura porque un tramo es un dato pequeño sin identidad, definido únicamente por su valor: un arreglo de tramos contiene directamente los tramos, sin un objeto separado en memoria para cada uno. Con tres [decimal] (48 bytes), la estructura supera el tamaño de aproximadamente 16 bytes que suele recomendarse para una estructura; esto no es un problema aquí: hay pocos tramos y solo se copian cuando se leen;
  • inmutable ([readonly]) porque no hay razón para que un tramo impositivo se modifique una vez creado. El curso de 2008, dicho sea de paso, modificaba el límite del último tramo durante el cálculo, un efecto secundario que eliminamos;
  • un record ([record]) porque el compilador genera el constructor, las propiedades, [ToString], y el operador de igualdad a partir de una sola línea.

Luego definimos una interfaz [ITax] capaz de calcular el impuesto [ITax.cs]:

1
2
3
4
5
6
7
namespace TaxV2;

public interface ITax
{
    // cálculo del impuesto de un contribuyente
    int Calculate(bool married, int nbChildren, int salary);
}
  • Línea 6: el método para calcular el impuesto a partir de tres datos: el estado civil del contribuyente, el número de hijos y el salario anual. Devuelve el impuesto redondeado hacia abajo al euro más cercano.

A continuación, definimos una clase abstracta que implementa esta interfaz [AbstractTax.cs]:

namespace TaxV2;

public abstract class AbstractTax : ITax
{
    // los tramos del impuesto necesarios para el cálculo provienen de una fuente externa
    // que solo las clases derivadas conocen
    protected abstract TaxBracket[] TaxBrackets { get; }

    // cálculo del impuesto
    public int Calculate(bool married, int nbChildren, int salary)
    {
        // cálculo del número de partes
        decimal shares = (decimal)nbChildren / 2 + (married ? 2 : 1);
        if (nbChildren >= 3)
        {
            shares += 0.5m;
        }
        // cálculo del ingreso gravable y del cociente familiar
        decimal income = 0.72m * salary;
        decimal quotient = income / shares;
        // búsqueda del tramo del impuesto: se usa el último si ningún límite se ajusta
        TaxBracket[] brackets = TaxBrackets;
        TaxBracket bracket = brackets[^1];
        for (int i = 0; i < brackets.Length - 1; i++)
        {
            if (quotient <= brackets[i].Limit)
            {
                bracket = brackets[i];
                break;
            }
        }
        // cálculo del impuesto
        return (int)(income * bracket.CoeffR - shares * bracket.CoeffN);
    }
}
  • Línea 3: la clase [AbstractTax] implementa la interfaz [ITax];
  • línea 7: los datos de la tabla, en forma de una propiedad abstracta protegida. La clase [AbstractTax] no sabe de dónde provienen estos datos (escritos en el código, leídos de un archivo, de una base de datos, etc.). Eso lo deja en manos de las clases derivadas. Por eso se declara abstracta, lo que impide instanciarla. El curso de 2008 usaba un campo protegido que las clases derivadas debían inicializar; la propiedad abstracta obliga a las clases derivadas a proporcionarla: el compilador lo verifica;
  • líneas 10–33: la implementación del método [Calculate] de la interfaz [ITax]. Las clases derivadas no tendrán que reescribir este método. La clase [AbstractTax] sirve así como clase de factorización para las clases derivadas: contiene lo que es común a todas ellas;
  • línea 13: el número de partes. La conversión [(decimal)nbChildren] es esencial: sin ella, [nbChildren / 2] sería una división entera (3 / 2 = 1). La expresión [married ? 2 : 1] es igual a 2 para un contribuyente casado y a 1 en caso contrario;
  • Líneas 19–20: el ingreso imponible y el cociente familiar. Todos los cálculos se realizan con [decimal], un tipo adecuado para los importes: el sufijo [m] de [0.72m] denota una constante de este tipo;
  • líneas 22–29: determinación del tramo impositivo. Por defecto, es el último tramo ([brackets[^1]], línea 23). El bucle recorre todos los tramos excepto el último y se detiene ([break]) en el primer tramo cuyo límite es mayor o igual que el cociente familiar;
  • línea 33: cálculo del impuesto. La conversión [(int)] trunca el resultado [decimal] a su parte entera.

Se puede crear una clase que implemente la interfaz [ITax] derivándola de la clase [AbstractTax]. Eso es lo que haremos ahora con [HardwiredTax.cs]:

namespace TaxV2;

public class HardwiredTax : AbstractTax
{
    // datos del cálculo del impuesto (tabla de 2004 sobre ingresos de 2003), escritos directamente en el código
    private static readonly decimal[] limits = [4962m, 8382m, 14753m, 23888m, 38868m, 47932m, 0m];
    private static readonly decimal[] coeffR = [0m, 0.068m, 0.191m, 0.283m, 0.374m, 0.426m, 0.481m];
    private static readonly decimal[] coeffN = [0m, 291.09m, 1322.92m, 2668.39m, 4846.98m, 6883.66m, 9505.54m];

    // los tramos del impuesto
    private readonly TaxBracket[] taxBrackets;

    // constructor
    public HardwiredTax()
    {
        // creación y llenado del arreglo de tramos del impuesto
        taxBrackets = new TaxBracket[limits.Length];
        for (int i = 0; i < taxBrackets.Length; i++)
        {
            taxBrackets[i] = new TaxBracket(limits[i], coeffR[i], coeffN[i]);
        }
    }

    // implementación de la propiedad abstracta de la clase padre
    protected override TaxBracket[] TaxBrackets => taxBrackets;
}
  • Líneas 6–8: la clase [HardwiredTax] incorpora directamente en el código los datos necesarios para calcular el impuesto. Son campos de clase ([static]) de solo lectura ([readonly]): son compartidos por todas las instancias y no pueden reemplazarse por otros arreglos;
  • líneas 14–20: el constructor usa estos datos para construir la tabla de tramos impositivos;
  • línea 25: se implementa la propiedad abstracta de la clase padre: devuelve la tabla de tramos impositivos.

El próximo capítulo agregará otras clases derivadas de [AbstractTax], que leerán los tramos impositivos de un archivo de texto o JSON: solo tendrán que proporcionar la propiedad [TaxBrackets].

Un programa de prueba podría ser el siguiente [Program.cs]:

using TaxV2;

// programa interactivo de cálculo del impuesto
// el usuario escribe tres datos en el teclado: married nbChildren salary
// el programa muestra entonces el impuesto a pagar

const string syntax = """
    syntax: Married NbChildren Salary
    Married: y for married, n for not married
    NbChildren: number of children
    Salary: annual salary in euros
    """;

// creación de un objeto ITax
ITax tax = new HardwiredTax();

// bucle de entrada
while (true)
{
    // se piden los parámetros del cálculo del impuesto
    Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
    string parameters = (Console.ReadLine() ?? "").Trim();
    // ¿algo que hacer?
    if (parameters == "")
    {
        break;
    }
    // verificación del número de campos de la línea escrita
    string[] fields = parameters.Split(' ', StringSplitOptions.RemoveEmptyEntries);
    if (fields.Length != 3)
    {
        Console.WriteLine(syntax);
        continue;
    }
    // verificación de la validez de los parámetros
    // married
    string married = fields[0].ToLower();
    if (married != "y" && married != "n")
    {
        Console.WriteLine(syntax + "\nIncorrect married argument: type y or n");
        continue;
    }
    // nbChildren
    if (!int.TryParse(fields[1], out int nbChildren) || nbChildren < 0)
    {
        Console.WriteLine(syntax + "\nIncorrect NbChildren argument: type a positive or zero integer");
        continue;
    }
    // salary
    if (!int.TryParse(fields[2], out int salary) || salary < 0)
    {
        Console.WriteLine(syntax + "\nIncorrect salary argument: type a positive or zero integer");
        continue;
    }
    // los parámetros son correctos: calculamos el impuesto
    Console.WriteLine($"Tax={tax.Calculate(married == "y", nbChildren, salary)} euros");
}

El programa anterior permite al usuario realizar simulaciones de cálculo de impuestos de forma repetida.

  • líneas 7–11: el mensaje de ayuda se escribe como un literal de cadena sin formato (C# 11), delimitado por tres comillas: la cadena puede ocupar varias líneas y se elimina la sangría común de las líneas, determinada por la posición de las comillas de cierre;
  • Línea 15: creación de un objeto [tax] que implementa la interfaz [ITax]. Este objeto se obtiene instanciando un tipo [HardwiredTax], un tipo que implementa la interfaz [ITax]. Observe que a la variable [tax] no se le asignó el tipo [HardwiredTax] sino el tipo [ITax]. Al escribirlo así, indicamos que solo nos interesa el método [Calculate] del objeto [tax] y no el resto. Para usar datos de un archivo, basta con cambiar esta única línea;
  • líneas 18–56: el bucle de simulaciones de cálculo de impuestos;
  • línea 22: los tres parámetros necesarios para el método [Calculate] se solicitan en una sola línea ingresada por teclado. [Console.ReadLine] devuelve [null] si la entrada estándar está cerrada: el operador [??] reemplaza entonces [null] por una cadena vacía, lo que termina el programa;
  • línea 29: el método [Split] divide la línea en palabras separadas por espacios, con la opción [StringSplitOptions.RemoveEmptyEntries] que elimina las palabras vacías causadas por espacios consecutivos;
  • líneas 44–50: el método [int.TryParse] verifica que los dos últimos campos sean enteros; la declaración [out int nbChildren] crea la variable que recibe el número. El curso de 2008 usaba [int.Parse] dentro de un bloque [try / catch];
  • línea 56: llamada al método [Calculate] del objeto [tax] que implementa la interfaz [ITax].

Este es un ejemplo del programa en funcionamiento:

> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Los importes de impuestos se calculan correctamente: 4,282 euros para un contribuyente casado con dos hijos y un salario anual de 60,000 euros (línea 26), y 2,959 euros con tres hijos (línea 28). Un contribuyente soltero sin hijos paga 11,519 euros por el mismo salario (línea 30).

En comparación con la versión 1, el cálculo ahora está encapsulado en clases detrás de una interfaz: el programa de diálogo solo conoce la interfaz [ITax]. Las versiones siguientes se apoyarán en esta separación: la versión 3 cambiará la fuente de datos derivando nuevas clases de [AbstractTax], y la versión 4 organizará la aplicación en capas.