Tracks
/
C#
C#
/
Temario
/
Interfaces
In

Interfaces en C#

2 ejercicios

Acerca de Interfaces

Las interfaces son el medio principal para desacoplar los usos de una clase de su implementación. Este desacoplamiento aporta flexibilidad al mantener la implementación y ayuda a permitir un comportamiento genérico con seguridad de tipos.

La sintaxis de una interfaz es similar a la de una clase o una estructura, salvo que los métodos y las propiedades aparecen solo como firma y no se proporciona ningún cuerpo.

public interface ILanguage
{
    string Speak();
}

public interface IItalianLanguage : ILanguage
{
    string Speak();
    string SpeakItalian();
}

public interface IScriptConverter
{
    string Version { get; set; }
    string ConvertCyrillicToLatin(string cyrillic);
}

La clase o estructura que la implemente debe implementar todas las operaciones definidas por la interfaz.

Normalmente, las interfaces hacen una o varias de las siguientes cosas:

  • permitir que el código que las usa trate varias clases distintas de forma genérica. En este caso, las interfaces desempeñan el mismo papel que una clase base
  • exponer un subconjunto de la funcionalidad para algún propósito concreto (como IComparable<T>) o
  • exponer la API pública de una clase para que puedan coexistir varias implementaciones. Un ejemplo es el de un doble de prueba
public class ItalianTraveller : IItalianLanguage
{
    public string Speak()
    {
        return "Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class ItalianTravellerV2 : IItalianLanguage
{
    public string Speak()
    {
        return "migliorata - Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class FrenchTraveller : ILanguage
{
    public string Speak()
    {
        return "Ça va?";
    }
}

public class RussianTraveller : ILanguage, IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Speak()
    {
        return "Привет мир";
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

public class DocumentTranslator : IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Translate(string russian)
    {
        throw new NotImplementedException();
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

El código que usa las interfaces y clases anteriores puede:

  • tratar a todos los hablantes del mismo modo, independientemente del idioma.
  • permitir que algún subsistema que se ocupa de la conversión de escrituras funcione sin importarle con qué tipos concretos trata.
  • no enterarse de los cambios en el hablante italiano, lo cual resulta práctico si el código de la clase y el código de usuario los mantienen equipos diferentes

Las interfaces se usan mucho para facilitar las pruebas, ya que permiten simular con facilidad.

Consulta este artículo para ver en detalle qué tipos de miembro puede incluir una interfaz.

Las interfaces pueden heredar de otras interfaces.

Los miembros de una interfaz son públicos por defecto.

Las interfaces pueden contener tipos anidados, como literales const, enums, delegates, classes y structs. En este caso, las interfaces actúan como espacios de nombres del mismo modo que lo hacen las clases y las estructuras, y el comportamiento y la sintaxis son idénticos.

Por diseño, C# no admite la herencia múltiple, pero facilita una especie de herencia múltiple a través de las interfaces.

Además, el hecho de que el polimorfismo se pueda implementar mediante interfaces es lo que sustenta el mecanismo de las interfaces.

Implementación explícita de interfaces

A veces, dos interfaces distintas pueden compartir nombres y firmas de métodos. Para poder ofrecer una implementación distinta de estos métodos, C# permite la implementación explícita de interfaces. Ten en cuenta que, para usar una implementación concreta de una interfaz, debes convertir a esa interfaz la expresión que hace referencia al objeto. Una asignación, una conversión de tipo o el paso como parámetro lo consiguen.

public interface IFoo
{
    void X();
}

public interface IBar
{
    void X();
}

public class Census : IFoo, IBar
{
    void IFoo.X()
    {
        Console.Write("This is from Foo");
    }

    void IBar.X()
    {
        Console.Write("This is from Bar");
    }
}

public class User
{
    public void Use()
    {
        IFoo foo = new Census();
        IBar bar = new Census();
        foo.X();
        // => "This is from Foo"
        bar.X();
        // => "This is from Bar"
    }
}

Hay varios casos de uso:

  • Un conflicto entre dominios (como se ilustra arriba) en el que los métodos tienen firmas idénticas.
  • Métodos con el mismo nombre pero tipos de valor devuelto distintos: si implementas tus propias clases de colección, puede que necesites una interfaz explícita para el método heredado IEnumerable.GetEnumerator(), junto con IEnumerable<T>.GetEnuerator(). Puede que nunca llegues a usar esa interfaz, pero el compilador puede exigirla.
  • Métodos en los que no hay conflicto de nombres entre interfaces, pero conviene que la clase que los implementa use el nombre para algún propósito relacionado: IFormattable tiene un método ToString() que recibe un parámetro de tipo de formato, además de un parámetro de tipo IFormatProvider. Una clase como FormattableString, de la biblioteca de clases base (BCL), tiene la interfaz para asegurarse de que puedan usarla rutinas que aceptan un IFormattable, pero resulta más expresivo que su versión principal de ToString(IFormatProvider) omita el parámetro de tipo de formato, ya que no se usa en la implementación y confundiría a quienes usan la API.

Implementación predeterminada

La versión 8 de C# aborda un problema recurrente de las API. Si añades métodos a una interfaz para ampliar la funcionalidad de nuevas implementaciones, es necesario modificar todas las implementaciones existentes de la interfaz para que cumplan el contrato de la API, aunque no tengan ningún comportamiento específico que implementar. Ahora C# permite proporcionar un método predeterminado como parte de la interfaz (a quienes programan en Java les resultará familiar). Antes, cuando se producía un cambio así, existía una versión 2 de la interfaz junto a la original.

Este artículo es una excelente introducción a las interfaces y se centra en la implementación predeterminada y en otras novedades de apoyo, como los miembros static, private y virtual.

Editar en GitHub El enlace se abre en una nueva ventana o pestaña

Aprende Interfaces

La práctica está bloqueada

Desbloquea 1 ejercicio más para practicar Interfaces