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:
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]:
El comando crea una carpeta llamada [Persons] que contiene dos archivos. El archivo [Persons.csproj] describe el proyecto:
- 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]:
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:
- 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:
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:
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:
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
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:
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:
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]:
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:
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í:
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:
- 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:
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:
- 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:
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:
o
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]:
- 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:
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):
Resultados:
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:
- 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:
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:
- 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:
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]):
- líneas 22–35: los métodos de lectura, llamados getters;
- líneas 38–51: los métodos de escritura, llamados setters.
Resultados:
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:
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:
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:
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:
Esta sintaxis, conocida como inicializador de objeto, equivale al siguiente código:
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:
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:
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:
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]:
- 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:
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:
- 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:
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]:
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]:
- 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:
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]:
- 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:
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:
- 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:
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:
[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]:
- 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]:
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:
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:
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]:
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]:

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:
- 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:
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:
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:
- 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:
- 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:
Resultados:
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:
se está escribiendo implícitamente:
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):
Volvamos al programa [Program.cs] del proyecto [Inheritance2]:
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:
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]:
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]:
- 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:
- 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:
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]:
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:
- 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:
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:
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]:
- 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:
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.

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:

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]:
- 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:
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:
- 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:
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:
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:
- 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]:
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]:
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]:
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]:
- 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]:
- 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]:
- 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
Cipueden entonces usarse como parámetros reales de funciones que aceptan un parámetro formal de tipoI; es decir, funciones que usan solo los métodos de los objetosCidefinidos en la interfazI, y no los campos y métodos específicos de las distintas clasesCi; - 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:
Por último, observe que las interfaces pueden tener varias implementaciones; es decir, se puede escribir:
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:
- 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:
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]:
- 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:
- 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]:
- 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]:
- 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]:
- 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:
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:
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í:
Ahora bien, si quisiéramos intercambiar dos referencias a objetos [Person], escribiríamos:
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:
- 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:
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:
- 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:
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:
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:
[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):
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:
- 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:
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:
- 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:
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]:
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:
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]:
La segunda, *[E2/Person.cs]*:
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):
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:
- 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:
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]):
- 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:
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:
- 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:
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:
- 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.
- líneas 37–41: el bloque
Resultados:
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:
- 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:
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:
- 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:
Descomentemos las tres últimas líneas del programa principal y compilemos:
- 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:
Primero, definimos un tipo capaz de encapsular una fila del arreglo anterior [TaxBracket.cs]:
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]:
- 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]:
- 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]:
- 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]:
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:
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.