Qual è la differenza tra l'implementazione di un'interfaccia esplicitamente o implicitamente?

Controlla la risposta migliore di Andrew Barrett per " implementazione implicita vs interfaccia esplicita "su SO .

In sostanza:

• Implicito: accedi ai metodi e alle proprietà dell'interfaccia come se fossero parte della classe.
• Esplicito: puoi accedere ai metodi e alle proprietà solo quando si tratta la classe come interfaccia implementata.

Esempi di codice:

implicito:

Test t = new Test();
t.Id; // OK
((ITest)t).Id; // OK

esplicito:

Test t = new Test();
t.Id; // Not OK
((ITest)t).Id; // OK

In termini di "quando" devi implementare un'interfaccia esplicitamente, è quando la tua classe ha già un metodo con la stessa firma di uno dei metodi della tua interfaccia, o quando la tua classe implementa diverse interfacce che condividono metodi con le stesse firme.

C'è anche una differenza nel modo in cui chiami il metodo.

Quando si utilizza un'implementazione dell'interfaccia esplicita , è necessario utilizzare il tipo di interfaccia per chiamare tale specifica implementazione.

Quindi, nel codice chiamante dovresti usare una variabile di tipo ITest per accedere a ITest.Id .

L'articolo Implementazione esplicita dell'interfaccia (C # Programming Guide) su MSDN ha un buon esempio.

Permette di implementare due interfacce che definiscono lo stesso metodo. Tuttavia, se si implementa esplicitamente l'interfaccia, è possibile accedere ai metodi solo quando la variabile viene digitata su tale interfaccia esplicita.

Vedi: Tutorial Implementazione esplicita dell'interfaccia

EDIT: Non dovrebbe fare la differenza Non dovresti farlo a meno che la tua classe non implementa due interfacce con le stesse proprietà, dato che dovrai eseguire il cast sull'interfaccia relativa prima puoi accedere al membro:

public interface ITest
{
    string Id { get; }
}

public interface IAlsoTest
{
    string Id { get; }
}

public interface ITestToo
{
    int Id { get; }
}

public class Test : ITest, IAlsoTest
{
    // Valid implicit implementation of BOTH interfaces
    public string Id
    {
        get { throw new NotImplementedException(); }
    }
}

public class TestSeparately : ITest, ITestToo
{
    // This way we can do different things depending
    // on which interface the callee called from.
    string ITest.Id
    {
        get { throw new NotImplementedException(); }
    }

    int ITestToo.Id
    {
        get { throw new NotImplementedException(); }
    }
}

public class TestOuch
{
    public void DoStuff()
    {
        var ts = new TestSeparately();

        // Works
        Console.WriteLine(((ITest)ts).Id);

        // Works
        Console.WriteLine(((ITestToo)ts).Id);

        // Not valid! Which one did we want to call?
        Console.WriteLine(ts.Id);
    }
}

L'utilizzo dell'esempio vale quando implementi esplicitamente un membro dell'interfaccia anche se utilizzi una sola interfaccia (che dimentico sempre: S), quindi cercherò di evitare l'implementazione esplicita quando possibile, in quanto nasconderà i membri della classe se non sono trasmessi all'interfaccia giusta (che è abbastanza confusa).