Implementación de miembros de interfaz explícitos en una clase

Completados

En C#, la implementación explícita de la interfaz permite a una clase implementar miembros de interfaz de forma que solo sean accesibles a través de la interfaz, no la instancia de clase. Esto resulta útil cuando una clase implementa varias interfaces con miembros que tienen la misma firma.

Varias interfaces de una clase

Una clase de C# puede implementar varias interfaces, lo que le permite heredar el comportamiento de varios orígenes. La capacidad de combinar varias interfaces es fundamental porque C# no admite varias clases de herencia. La implementación de varias interfaces permite a una clase tener características diferentes y garantiza que sigue las reglas establecidas por esas interfaces.

  • Las interfaces definen un grupo de funcionalidades relacionadas.
  • Una clase o estructura debe implementar todos los miembros de las interfaces que hereda.
  • Las interfaces pueden contener métodos, propiedades, eventos e indizadores.

Estas son dos interfaces simples para nuestro ejemplo:

public interface IEnglishDimensions
{
    float Length();
    float Width();
}

public interface IMetricDimensions
{
    float Length();
    float Width();
}

Miembros de interfaz explícitos

En C#, una clase solo puede heredar de una clase, pero puede implementar varias interfaces. Esto es especialmente importante cuando varias interfaces tienen los mismos nombres de miembro. Para evitar confusiones, usamos la implementación explícita de la interfaz.

La implementación de interfaz explícita garantiza que cada miembro de una interfaz tenga una implementación única, lo que impide conflictos. También aclara a qué interfaz pertenece un miembro cuando una clase implementa dos o más interfaces con los mismos nombres de miembro. La implementación de interfaz explícita permite a una clase cumplir los requisitos de varias interfaces, lo que proporciona diversas funcionalidades.

Para implementar explícitamente un miembro de una interfaz, agregue el nombre de la interfaz y un punto antes del nombre del miembro. Este es un ejemplo:

public class Box : IEnglishDimensions, IMetricDimensions
{
    float IEnglishDimensions.Length()
    {
        return 30.0f;
    }

    float IEnglishDimensions.Width()
    {
        return 20.0f;
    }

    float IMetricDimensions.Length()
    {
        return 76.2f;
    }

    float IMetricDimensions.Width()
    {
        return 50.8f;
    }
}

En este código, la Box clase implementa dos interfaces: IEnglishDimensions y IMetricDimensions. Ambas interfaces tienen miembros denominados Length y Width. Para evitar confusiones, cada miembro está vinculado explícitamente a su interfaz.

Nota:

Los miembros de interfaz implementados explícitamente no tienen modificadores de acceso como public, private, etc. Solo se puede tener acceso a ellos a través de una instancia de la interfaz, no a la clase . Esto significa que no puede llamar a Box.Length(), pero puede llamar a IEnglishDimensions.Length() si tiene una instancia de Box que se trata como un IEnglishDimensions.

Usar miembros de interfaz explícitos

Debe crear instancias de las interfaces y llamar a sus miembros para ejecutar y probar código que use miembros de interfaz explícitos. Esto garantiza que se invoque la implementación correcta en función del tipo de interfaz.

Box box = new Box();
IEnglishDimensions eDimensions = box;
IMetricDimensions mDimensions = box;

Console.WriteLine($"Length in inches: {eDimensions.Length()}");
Console.WriteLine($"Width in inches: {eDimensions.Width()}");
Console.WriteLine($"Length in centimeters: {mDimensions.Length()}");
Console.WriteLine($"Width in centimeters: {mDimensions.Width()}");

En este ejemplo, la instancia de clase Box se convierte en IEnglishDimensions y IMetricDimensions para acceder a los miembros de interfaz explícitos. La salida muestra las dimensiones tanto en inglés como en unidades métricas.

Length in inches: 30
Width in inches: 20
Length in centimeters: 76.2
Width in centimeters: 50.8

En C#, puede implementar varias interfaces en una clase, mediante la implementación de interfaz explícita para resolver conflictos de nomenclatura cuando los miembros tienen las mismas firmas. Se accede a los miembros implementados explícitamente a través de la instancia de interfaz, no la instancia de clase, lo que garantiza una funcionalidad adecuada y evita la ambigüedad. Este enfoque mejora la capacidad de mantenimiento del código definiendo claramente el comportamiento previsto para cada interfaz, lo que facilita la comprensión y extensión del código base.