Sdílet prostřednictvím

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

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í na Paint vyvolávají 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á následující 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á si ale nepřejete, aby se pro obě rozhraní volala stejná implementace. Pokud chcete vyvolat jinou implementaci v závislosti na tom, které rozhraní je používáno, můžete explicitně implementovat člena rozhraní. Explicitní implementace rozhraní je člen třídy, který je volán pouze prostřednictvím zadaného rozhraní. Člena třídy pojmenujte tak, že před jeho název umístíte předponu skládající se z názvu rozhraní a tečky. 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 metod 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 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. 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; } }
}

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 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();

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é