Qué son y cómo usar los interface en C#

Un interfaz en es una colección de definiciones que una clase o una estructura puede implementar (como métodos, propiedades, eventos o indexadores).

A diferencia de las clases, los interfaces no contienen implementaciones de métodos, solo definen los miembros que deben ser implementados por las clases o estructuras que los implementan.

Las interfaces son fundamentales en la programación orientada a objetos porque permiten definir funcionalidades y comportamiento que pueden ser implementadas por diferentes clases, y favorecen la mantenibilidad y la reutilización del código.

Interfaces en C#

La declaración de una interfaz se realiza utilizando la palabra clave interface.

[modificador] interface NombreDeLaInterfaz
{
    // Definición de métodos
    tipoDeDato NombreDelMetodo(parametros);

    // Definición de propiedades
    tipoDeDato NombreDeLaPropiedad { get; set; }
}

Implementación de interfaces

Para implementar un interfaz en una clase se utiliza la sintaxis de dos puntos (:) seguida del nombre del interfaz. La clase debe proporcionar implementaciones para todos los miembros definidos en el interfaz.

Aquí hay un ejemplo de cómo definir e implementar una interfaz en C#:

public interface IConducible
{
    string Matricula { get; set; }

    // Métodos
    void Conducir();
    void Frenar();
}

public class Coche : IConducible
{
    // Implementación de propiedades    
    public string Matricula { get; set; }

    // Implementación de métodos
    public void Conducir()
    {
        Console.WriteLine("El coche está en marcha.");
    }

    public void Frenar()
    {
        Console.WriteLine("El coche se ha detenido.");
    }
}

Polimorfismo con interfaces

Una de las características más importantes de los interfaces es su capacidad para dar soporte el polimorfismo.. Esto permite que una instancia de una clase que implementa un interfaz sea tratada como una instancia de ese interfaz.

Supongamos que tengamos otra clase que implementa IConducible llamara Bicicleta

public class Bicicleta : IConducible
{
	// implementación
}

Ahora podemos definir una variable de tipo IConducible, y asignar variables de tipo Coche o Bicicleta.

IConducible vehiculo;

vehiculo = new Coche();
vehiculo.Arrancar(); // Salida: El coche ha arrancado.
vehiculo.Detener();  // Salida: El coche se ha detenido.

vehiculo = new Bicicleta();
vehiculo.Arrancar(); // Salida: La bicicleta ha comenzado a moverse.
vehiculo.Detener();  // Salida: La bicicleta se ha detenido.

Implementar múltiples interfaces

C# no soporta la herencia múltiple directa (una clase derivada de múltiples clases base). Sin embargo, una clase puede implementar múltiples interfaces, lo que proporciona una forma de lograr un comportamientos similar a la herencia múltiple.

Por ejemplo, en este ejemplo, la clase Pato implementa los interfaces IVolador e INadador.

public interface IVolador
{
    void Volar();
}

public interface INadador
{
    void Nadar();
}

public class Pato : IVolador, INadador
{
    public void Volar()
    {
        Console.WriteLine("El pato está volando.");
    }

    public void Nadar()
    {
        Console.WriteLine("El pato está nadando.");
    }
}

Implementación explícita

C# permite la implementación explícita de miembros de interfaces. Esto es útil cuando una clase implementa múltiples interfaces que pueden tener métodos con el mismo nombre, o cuando se desea proporcionar implementaciones específicas que no sean accesibles directamente a través de la clase.

En este ejemplo, la clase Multifuncional implementa los interfaces IImprimible e IEscaneable. Pero ambos interface declaran un método Imprimir(). Podemos declarar explícitamente los interfaces para resolver el conflicto de nombres.

public interface IImprimible
{
    void Imprimir();
}

public interface IEscaneable
{
    void Imprimir();
}

public class Multifuncional : IImprimible, IEscaneable
{
    void IImprimible.Imprimir()
    {
        Console.WriteLine("Imprimiendo...");
    }

    void IEscaneable.Imprimir()
    {
        Console.WriteLine("Escaneando...");
    }
}

// Uso
IImprimible impresora = new Multifuncional();
impresora.Imprimir(); // Salida: Imprimiendo...

IEscaneable escaner = new Multifuncional();
escaner.Imprimir(); // Salida: Escaneando...

Ejemplos prácticos

public interface IEncendible
{
    // Métodos
    void Encender();
    void Apagar();
    void Reiniciar();
}

public class Telefono : IEncendible
{
    // Implementación de métodos
    public void Encender()
    {
        Console.WriteLine("El teléfono se está encendiendo.");
    }

    public void Apagar()
    {
        Console.WriteLine("El teléfono se está apagando.");
    }

    public void Reiniciar()
    {
        Console.WriteLine("El teléfono se está reiniciando.");
    }
}

public interface IComunicador
{
    // Métodos
    void Llamar(string numero);
    void EnviarMensaje(string numero, string mensaje);
}

public class Telefono : IComunicador, IEncendible
{
	// ... codigo de IEncendible del ejemplo anterior ... //
	
    // Implementación de métodos IComunicador
    public void Llamar(string numero)
    {
        Console.WriteLine($"Llamando al número {numero}.");
    }

    public void EnviarMensaje(string numero, string mensaje)
    {
        Console.WriteLine($"Enviando mensaje al número {numero}: {mensaje}");
    }
}

public interface IPagos
{
    // Métodos
    void ProcesarPago(decimal monto);
    void ReembolsarPago(decimal monto);
}

public class PagoElectronico : IPagos
{
    // Implementación de métodos
    public void ProcesarPago(decimal monto)
    {
        Console.WriteLine($"Procesando pago de {monto}.");
    }

    public void ReembolsarPago(decimal monto)
    {
        Console.WriteLine($"Reembolsando pago de {monto}.");
    }
}