In che modo un proxy WCF implementa ICommunicationObject se i suoi metodi non sono visibili?

Question

In che modo un canale WCF (creato tramite ChannelFactory) implementa ICommunicationObject, ma non espone il metodo Close(), ad esempio, a meno che non si lanci il proxy su ICommunicationObject? Ha senso?

Ho pensato a questo sulla via di casa oggi e non riuscivo a capirlo nella mia testa. Forse sto facendo la domanda sbagliata? Forse sto facendo una domanda stupida? :)

È una specie di trucco ninja?

Answer 1

Questo viene effettuato tramite Explicit Interface Implementation.

Supponiamo di avere un'interfaccia, in questo modo:

public interface IFoo 
{ 
    void Foo(); 
} 

È possibile implementare questa norma:

public class Bar : IFoo 
{ 
    public void Foo() {} // Implicit interface implementation 
} 

In alternativa, è possibile implementare elementi d'interfaccia esplicitamente, che richiede il cast:

public class Baz : IFoo 
{ 
    void IFoo.Foo() {} // This will require casting the object to IFoo to call 
} 

Th può essere molto utile a volte. Ad esempio, spesso viene implementato lo IDisposable in classi in cui l'API preferita potrebbe essere, ad esempio, chiamare .Close(). Implementando esplicitamente IDisposable, si "nasconde" il metodo Dispose(), ma si consente comunque di utilizzare l'istanza di classe tramite un'istruzione using.

Answer 2

La classe Channel implementa esplicitamente l'interfaccia ICommunicationObject. Ecco un esempio che illustra la differenza tra implementazione dell'interfaccia esplicita e implicita implementazione di interfaccia:

internal interface IExample 
{ 
    void DoSomething(); 
} 

class ImplicitExample : IExample 
{ 
    public void DoSomething() 
    { 
     // ... 
    } 
} 

class ExplicitExample : IExample 
{ 
    void IExample.DoSomething() 
    { 
     // ... 
    } 
} 

class Consumer 
{ 
    void Demo() 
    { 
     var explicitExample = new ExplicitExample(); 
     // explicitExample.DoSomething(); <-- won't compile 
     ((IExample)explicitExample).DoSomething(); // <-- compiles 

     var implicitExample = new ImplicitExample(); 
     implicitExample.DoSomething(); // <-- compiles 
    } 
} 

Ecco un link per l'un articolo di MSDN su questo argomento: http://msdn.microsoft.com/en-us/library/ms173157.aspx