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 členu třídy způsobí, že obě rozhraní budou používat tento člen jako jejich implementaci. V následujícím příkladu všechna volání vyvolá 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

Pro obě rozhraní ale možná nebudete chtít volat stejnou implementaci. Pokud chcete volat jinou implementaci v závislosti na tom, které rozhraní se používá, můžete člen rozhraní implementovat explicitně. 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. Obě implementace metod jsou oddělené a ani jedna 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 používá také 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; } }
}

Explicitní implementace rozhraní nemá modifikátor přístupu, protože není přístupný jako člen typu, ve které je definován. 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í dokumentace interface 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é