Implementace explicitního rozhraní (Průvodce programováním v C#)

Pokud třída implementuje dvě rozhraní, která obsahují člen se stejným podpisem, implementace daného člena ve třídě způsobí, že obě rozhraní budou tento člen používat jako jejich implementaci. V následujícím příkladu všechny volání, která mají Paint vyvolat stejnou metodu. Tato první ukázka definuje typy:

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");
    }
}

Následující ukázka volá metody:

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

Ale možná nechcete, aby se pro obě rozhraní volala stejná implementace. Pokud chcete volat jinou implementaci v závislosti na používaném rozhraní, můžete explicitně implementovat člen rozhraní. Explicitní implementace rozhraní je člen třídy, který je volána pouze prostřednictvím zadaného rozhraní. Člen třídy pojmenujte předponou s názvem rozhraní a tečkou. Příklad:

public class SampleClass : IControl, ISurface
{
    void IControl.Paint()
    {
        System.Console.WriteLine("IControl.Paint");
    }
    void ISurface.Paint()
    {
        System.Console.WriteLine("ISurface.Paint");
    }
}

Člen IControl.Paint třídy je k dispozici pouze prostřednictvím IControl rozhraní a ISurface.Paint je k dispozici pouze prostřednictvím ISurface. Implementace obou metod jsou oddělené a žádná z nich není k dispozici přímo ve třídě. Příklad:

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

Explicitní implementace se také používá k řešení případů, kdy dvě rozhraní deklarují různé členy stejného názvu, jako je vlastnost a metoda. K implementaci obou rozhraní musí třída použít explicitní implementaci buď pro vlastnost P, nebo metodu P, nebo obojí, aby se zabránilo chybě kompilátoru. Příklad:

interface ILeft
{
    int P { get;}
}
interface IRight
{
    int P();
}

class Middle : ILeft, IRight
{
    public int P() { return 0; }
    int ILeft.P { get { return 0; } }
}

Implementace explicitního rozhraní nemá modifikátor přístupu, protože není přístupný jako člen typu, ve který je definovaný. Místo toho je přístupná pouze v případě, že je volána prostřednictvím instance rozhraní. Pokud zadáte modifikátor přístupu pro explicitní implementaci rozhraní, zobrazí se chyba kompilátoru CS0106. Další informace najdete v tématu (Referenční dokumentaceinterface jazyka C#).

Můžete definovat implementaci pro členy deklarované v rozhraní. Pokud třída dědí implementaci metody z rozhraní, je tato metoda přístupná pouze prostřednictvím odkazu typu rozhraní. Zděděný člen se nezobrazuje jako součást veřejného rozhraní. Následující ukázka definuje výchozí implementaci pro metodu rozhraní:

public interface IControl
{
    void Paint() => Console.WriteLine("Default Paint method");
}
public class SampleClass : IControl
{
    // Paint() is inherited from IControl.
}

Následující ukázka vyvolá výchozí implementaci:

var sample = new SampleClass();
//sample.Paint();// "Paint" isn't accessible.
var control = sample as IControl;
control.Paint();

Každá třída, která implementuje IControl rozhraní, může přepsat výchozí Paint metodu, buď jako veřejnou metodu, nebo jako explicitní implementaci rozhraní.

Viz také