Qual è la differenza tra l'implementazione di un'interfaccia in modo esplicito o implicito?

In Visual Studio posso fare clic con il pulsante destro del mouse su un'interfaccia e scegliere Implementa interfaccia o Implementa esplicitamente l'interfaccia.

public class Test : ITest
{
    public string Id // Generated by Implement Interface
    {
        get { throw new NotImplementedException(); }
    }

    string ITest.Id // Generated by Implement Interface Explicitly
    {
        get { throw new NotImplementedException(); }
    }
}

L'unica differenza che vedo tra i due è che il nome dell'interfaccia viene aggiunto alle proprietà e ai metodi dell'interfaccia quando vengono creati se si sceglie di implementare l'interfaccia in modo esplicito.

Trovo che renda il codice un po 'più leggibile poiché posso vedere da dove proviene quel metodo / proprietà, tuttavia questo fa qualche differenza nel modo in cui la classe viene utilizzata o compilata? E importa davvero se implemento le mie interfacce in modo implicito o esplicito?

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

Fondamentalmente:

• Implicito: accedi ai metodi e alle proprietà dell'interfaccia come se facessero parte della classe.
• Esplicito: è possibile accedere a metodi e proprietà solo trattando 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 esplicitamente un'interfaccia, è quando la tua classe ha già un metodo con la stessa firma di uno dei metodi della tua interfaccia, oppure quando la tua classe implementa diverse interfacce che condividono metodi con le stesse firme ma contratti incompatibili.

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

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

Pertanto, per chiamare il codice è necessario utilizzare una variabile di tipo ITestper accedere ITest.Id.

L'articolo Implementazione esplicita dell'interfaccia (Guida per programmatori C #) su MSDN ha un buon esempio.

Ti consente 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 quell'interfaccia esplicita.

Vedi: Tutorial esplicito sull'implementazione dell'interfaccia

EDIT: Non dovrebbe fare la differenza Non dovresti farlo a meno che la tua classe non implementi due interfacce con le stesse proprietà, poiché dovrai eseguire il cast all'interfaccia pertinente prima di poter 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 si implementa esplicitamente un membro dell'interfaccia anche se si utilizza solo un'unica interfaccia (che dimentico sempre: S), quindi proverei a evitare l'implementazione esplicita ogni volta che è possibile, poiché nasconderebbe i membri della classe se " non trasmettere alla giusta interfaccia (il che è abbastanza confuso).

Sulla base della risposta di Jalayan,

• Implicito: accedi ai metodi e alle proprietà dell'interfaccia come se facessero parte della classe.
• Esplicito: è possibile accedere a metodi e proprietà solo trattando la classe come interfaccia implementata.