2010-10-11 10 views
11

Esiste un modo per implementare un'interfaccia esplicitamente utilizzando una proprietà automatica? Ad esempio, prendere in considerazione questo codice:Implementazione esplicita di un'interfaccia utilizzando una proprietà automatica

namespace AutoProperties 
{ 
    interface IMyInterface 
    { 
     bool MyBoolOnlyGet { get; } 
    } 

    class MyClass : IMyInterface 
    { 
     static void Main(){} 

     public bool MyBoolOnlyGet { get; private set; } // line 1 
     //bool IMyInterface.MyBoolOnlyGet { get; private set; } // line 2 
    } 
} 

Questo codice compila. Tuttavia, se si sostituisce la riga 1 con la riga 2, non viene compilata.

(Non è che ho bisogno di ottenere la linea 2 di lavoro - Sono solo curioso.)

+0

Quale errore si ottiene? –

+2

Per "perché" - chiediti ... come potrei assegnarlo? –

+0

Ottengo due errori: 1. 'AutoProperties.MyClass.AutoProperties.IMyInterface.MyBoolOnlyGet.set' aggiunge un accessor non trovato nel membro dell'interfaccia 'AutoProperties.IMyInterface.MyBoolOnlyGet'. 2. Il modificatore 'privato' non è valido per questo articolo – user181813

risposta

13

Infatti, tale particolare disposizione (esplicita implementazione di una proprietà di interfaccia get-solo da una proprietà implementato automaticamente) isn' t supportato dalla lingua Quindi, o esegui manualmente (con un campo), o scrivi un puntello auto-implementato privato e un proxy. Ma ad essere onesti, per il momento che hai fatto che si potrebbe anche aver usato un campo ...

private bool MyBool { get;set;} 
bool IMyInterface.MyBoolOnlyGet { get {return MyBool;} } 

o:

private bool myBool; 
bool IMyInterface.MyBoolOnlyGet { get {return myBool;} } 
5

Il problema è che l'interfaccia ha solo getter e si tenta di implementarlo esplicitamente con getter e setter.
Quando si implementa esplicitamente un'interfaccia, l'implementazione esplicita verrà chiamata solo quando si fa riferimento al tipo di interfaccia, quindi ... se l'interfaccia ha solo getter non c'è modo di usare il setter, quindi non ha senso avere un setter lì.

Questo, ad esempio, verrà compilato:

namespace AutoProperties 
    { 
     interface IMyInterface 
     { 
      bool MyBoolOnlyGet { get; set; } 
     } 

     class MyClass : IMyInterface 
     { 
      static void Main() { } 

      bool IMyInterface.MyBoolOnlyGet { get; set; } 
     } 
    } 
+0

Non vedo questo spiegando perché l'implementazione esplicita dell'interfaccia dovrebbe essere più limitata dell'implementazione implicita. Forse ha senso se l'implementazione implicita risulta nel compilatore C# che genera automaticamente il codice di implementazione esplicita necessario per te. Potresti colmare il gap logico qui - cosa rende esattamente implicito diverso dall'esplicativo che infrange il codice dell'OP? – binki

+0

Supponiamo che tu possa aver definito un setter privato in un'implementazione esplicita. Come lo useresti? 'this.setter = ...' delegherà al setter implicito (perché questo è di tipo MyClass) e '((IMyInterface) this) .setter' fallirà perché IMyInterface non ha il setter definito. –

+0

Questo è il punto. Se la proprietà implementata esplicitamente potrebbe essere implementata automaticamente, non avrei dovuto implementare manualmente il mio backing store per questo. Potrei anche fare affidamento sull'interfaccia solo definendo un getter per nascondere il mio setter privato. Beh, ci sono problemi con questo, credo, ma nella mia mente è fondamentalmente lo stesso problema di essere [incapace di scavalcare solo il setter o il getter di una proprietà] (http://stackoverflow.com/a/6058526/429091). Dovresti essere in grado di dire al compilatore che solo il tuo setter o solo il tuo getter sta implementando l'interfaccia esplicita. – binki