Implementazione esplicita dell'interfaccia (Guida per programmatori C#)
Se class implementa due interfacce che contengono un membro con la stessa firma e quest'ultimo viene implementato nella classe, entrambe le interfacce useranno il membro come propria implementazione. Nell'esempio seguente tutte le chiamate a Paint richiamano lo stesso metodo. Questo primo esempio definisce i tipi:
public interface IControl
{
void Paint();
}
public interface ISurface
{
void Paint();
}
public class SampleClass : IControl, ISurface
{
// Both ISurface.Paint and IControl.Paint call this method.
public void Paint()
{
Console.WriteLine("Paint method in SampleClass");
}
}
L'esempio seguente chiama i metodi:
SampleClass sample = new SampleClass();
IControl control = sample;
ISurface surface = sample;
// The following lines all call the same method.
sample.Paint();
control.Paint();
surface.Paint();
// Output:
// Paint method in SampleClass
// Paint method in SampleClass
// Paint method in SampleClass
Tuttavia potrebbe non essere necessario chiamare la stessa implementazione per entrambe le interfacce. Per chiamare un'implementazione diversa, a seconda dell'interfaccia in uso, è possibile implementare un membro dell'interfaccia in modo esplicito. Un'implementazione esplicita dell'interfaccia è un membro della classe chiamato solo tramite l'interfaccia specificata. Denominare il membro della classe anteponendo come prefisso il nome dell'interfaccia e un punto. Ad esempio:
public class SampleClass : IControl, ISurface
{
void IControl.Paint()
{
System.Console.WriteLine("IControl.Paint");
}
void ISurface.Paint()
{
System.Console.WriteLine("ISurface.Paint");
}
}
Il membro di classe IControl.Paint è disponibile solo tramite l'interfacciaIControl e ISurface.Paint è disponibile solo tramite ISurface. Entrambe le implementazioni del metodo sono separate e nessuna delle due è disponibile direttamente nella classe. Ad esempio:
SampleClass sample = new SampleClass();
IControl control = sample;
ISurface surface = sample;
// The following lines all call the same method.
//sample.Paint(); // Compiler error.
control.Paint(); // Calls IControl.Paint on SampleClass.
surface.Paint(); // Calls ISurface.Paint on SampleClass.
// Output:
// IControl.Paint
// ISurface.Paint
L'implementazione esplicita viene usata anche per risolvere i casi in cui due interfacce dichiarano ognuna membri diversi con lo stesso nome, ad esempio una proprietà e un metodo. Per implementare entrambe le interfacce, una classe deve usare l'implementazione esplicita per la proprietà P o per il metodo P oppure per entrambi, in modo da evitare un errore del compilatore. Ad esempio:
interface ILeft
{
int P { get;}
}
interface IRight
{
int P();
}
class Middle : ILeft, IRight
{
public int P() { return 0; }
int ILeft.P { get { return 0; } }
}
Un'implementazione esplicita dell'interfaccia non ha un modificatore di accesso perché non è accessibile come membro del tipo in cui è definito. Invece è accessibile solo con la chiamata, tramite un'istanza dell'interfaccia. Se si indica un modificatore di accesso per un'implementazione esplicita dell'interfaccia, viene visualizzato l'errore del compilatore CS0106. Per altre informazioni, vedere interface (Riferimenti per C#).
È possibile definire l'implementazione per i membri dichiarati in un'interfaccia. Se una classe eredita un'implementazione del metodo da un'interfaccia, questo metodo è accessibile solo tramite un riferimento del tipo di interfaccia. Il membro ereditato non è visibile come parte dell'interfaccia pubblica. L'esempio seguente definisce l'implementazione predefinita per un metodo di interfaccia:
public interface IControl
{
void Paint() => Console.WriteLine("Default Paint method");
}
public class SampleClass : IControl
{
// Paint() is inherited from IControl.
}
L'esempio seguente richiama l'implementazione predefinita:
var sample = new SampleClass();
//sample.Paint();// "Paint" isn't accessible.
var control = sample as IControl;
control.Paint();
Qualsiasi classe che implementa l'interfaccia IControl può eseguire l'override del metodo predefinito Paint, come metodo pubblico o come implementazione esplicita dell'interfaccia.
