c# - una - ¿Por qué la implementación de interfaz explícita?

interface mvc c#

Question

Recientemente implementé una clase como:

class TestClass : IDisposable
{
    RegistryKey m_key;
    public TestClass()
    {
        m_key = Registry.CurrentUser.OpenSubKey("Software", false);
    }

    public void Dispose()
    {
        // m_key.Dispose();
        IDisposable disp = m_key;
        disp.Dispose();
    }
}

Si elimino el comentario de la llamada directa a Dispose, aparece el error CS0117 ("''Microsoft.Win32.RegistryKey'' no contiene una definición para ''Dispose''"). Algunos de Google me llevaron a este hilo , donde aprendí lo que estaba pasando, así que ahora entiendo su mecánica. La documentación de MSDN sugiere que el autor preferiría que llame a Close () en lugar de a Dispose (), pero no explica por qué.

¿Cuál es el propósito de este patrón (que creo que también lo he visto en las clases de IO)? A la luz del hecho de que esta fue una decisión intencional del autor de la clase, ¿qué tan malo es el código anterior (la llamada a Dispose a través de la interfaz IDisposable)? No puede ser tan malo, después de todo, es lo que sucedería en una declaración de uso, ¿verdad?

[ediciones: 1) cambió el título de "no público" a "explícito" 2) eliminó la implementación explícita de mi código, accidentalmente dejado en la experimentación]

Answer 1

Esto se llama implementación de interfaz explícita . En su ejemplo, ya que define el método Dispose () como "void IDisposable.Dispose ()" también está implementando explícitamente la interfaz IDisposable.

Esto normalmente se hace para evitar colisiones. Si Microsoft alguna vez hubiera querido agregar otro método Dispose () que hiciera algo distinto a RegistryKey, no podría hacerlo a menos que utilizara la implementación explícita de esa interfaz.

Esto se hace a menudo con la interfaz genérica IEnumerable <T>. También requiere que implemente la interfaz no genérica IEnumerable. El único miembro en estas dos interfaces es GetEnumerator, siendo el genérico más útil, por lo que generalmente se implementa así:

public clas SomeClass : IEnumerable<SomeOtherClass>
{
    public IEnumerator<SomeOtherClass> GetEnumerator ()
    {
        ...
    }

    IEnumerator IEnumerable.GetEnumerator ()
    {
        return GetEnumerator ();
    }
}

De esta forma, cuando llamas a un objeto del método GetEnumator de SomeClass, llama a la versión genérica, ya que la otra se implementó de manera explícita, lo que nos permite obtener genéricos de tipo fuerte.

Vea las páginas 166-169 de Programming C # por Jesse Liberty (Tengo la cuarta edición).

Answer 2

La mayoría de las personas no está de acuerdo conmigo, pero me gusta usar la implementación de interfaz explícita para todas las interfaces . Quiero dejar en claro si estoy escribiendo un método para llamar a mi objeto o en mi interfaz.

Esto es doloroso si tiene una referencia al objeto y desea llamar a un método de interfaz (como el ejemplo anterior), pero lo atenúo escribiendo:

class C : IDisposable
{
    public IDisposable IDisposable { get { return this; } }
    void IDisposable.Dispose() { }
}

lo que significa que al llamar al método en C se ve así:

C c = ...
c.IDisposable.Dispose();

El compilador lo analiza como "Llamar a la propiedad IDisposable en C, luego llama al método Dispose() en el resultado", pero lo leí como "Llame el método IDisposable.Dispose() en C ", que parece natural aquí.

Este enfoque puede ponerse feo cuando se usan interfaces genéricas, desafortunadamente.