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

Pokud Třída implementuje dvě rozhraní, která obsahují člena se stejnou signaturou, pak implementace tohoto člena na třídu způsobí, že obě rozhraní budou používat tento člen jako svou implementaci. V následujícím příkladu všechna volání 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í příklad 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á nebudete chtít volat stejnou implementaci pro obě rozhraní. Chcete-li volat 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ý se volá jenom prostřednictvím zadaného rozhraní. Pojmenujte člen třídy jeho prefixem 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 . Implementace obou metod jsou oddělené a žádné nejsou k dispozici přímo na 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 je také použita k vyřešení případů, kde dvě rozhraní každý deklaruje různé členy stejného názvu, jako je například vlastnost a metoda. Pro implementaci obou rozhraní musí třída použít explicitní implementaci buď pro vlastnost P , nebo pro metodu P , nebo pro obojí, aby nedošlo k 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, který je definován v. Místo toho je přístupná pouze při volá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 naleznete v tématu (Referenční dokumentace jazyka C#).

Počínaje jazykem C# 8,0můž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í příklad 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();

Libovolná 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é