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

  • Článek

Pokud třída implementuje dvě rozhraní, která obsahují člen se stejným podpisem, pak implementace člena ve třídě způsobí, že obě rozhraní budou používat tento člen jako svou implementaci. V následujícím příkladu všechna volání vyvolat Paint 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

Možná ale nebudete chtít, 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 člena 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. Napří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. Obě implementace metody jsou oddělené a ani jedna z nich není k dispozici přímo ve třídě. Napří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. Pokud chcete implementovat obě rozhraní, třída musí použít explicitní implementaci buď pro vlastnost P, nebo metodu P, nebo obojí, aby se zabránilo chybě kompilátoru. Napří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 definována. Místo toho je přístupná pouze při zavolání 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 interface (Referenční dokumentace 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();

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

Viz také