Share via

Expliciete interface-implementatie (C#-programmeerhandleiding)

  • Artikel

Als een klasse twee interfaces implementeert die een lid met dezelfde handtekening bevatten, zorgt het implementeren van dat lid in de klasse ervoor dat beide interfaces dat lid gebruiken als hun implementatie. In het volgende voorbeeld worden alle aanroepen om dezelfde methode aan te Paint roepen. In dit eerste voorbeeld worden de typen gedefinieerd:

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

In het volgende voorbeeld worden de methoden aangeroepen:

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

Maar misschien wilt u niet dat dezelfde implementatie wordt aangeroepen voor beide interfaces. Als u een andere implementatie wilt aanroepen, afhankelijk van welke interface wordt gebruikt, kunt u een interfacelid expliciet implementeren. Een expliciete interface-implementatie is een klasselid dat alleen wordt aangeroepen via de opgegeven interface. Geef het klasselid een naam door het voorvoegsel te voorzien van de naam van de interface en een punt. Voorbeeld:

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

Het klasselid IControl.Paint is alleen beschikbaar via de IControl interface en ISurface.Paint is alleen beschikbaar via ISurface. Beide methode-implementaties zijn gescheiden en beide zijn niet rechtstreeks beschikbaar in de klasse. Voorbeeld:

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

Expliciete implementatie wordt ook gebruikt om gevallen op te lossen waarbij twee interfaces elk verschillende leden van dezelfde naam declareren, zoals een eigenschap en een methode. Als u beide interfaces wilt implementeren, moet een klasse expliciete implementatie gebruiken voor de eigenschap P, of de methode P, of beide, om een compilerfout te voorkomen. Voorbeeld:

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

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

Een expliciete interface-implementatie heeft geen wijzigingsfunctie voor toegang, omdat deze niet toegankelijk is als lid van het type waarin deze is gedefinieerd. In plaats daarvan is deze alleen toegankelijk wanneer deze wordt aangeroepen via een exemplaar van de interface. Als u een toegangsaanpassing opgeeft voor een expliciete interface-implementatie, krijgt u de compilerfout CS0106. Zie interface (C#-naslaginformatie) voor meer informatie.

U kunt een implementatie definiëren voor leden die zijn gedeclareerd in een interface. Als een klasse een methode-implementatie overgaat van een interface, is die methode alleen toegankelijk via een verwijzing van het interfacetype. Het overgenomen lid wordt niet weergegeven als onderdeel van de openbare interface. In het volgende voorbeeld wordt een standaard implementatie voor een interfacemethode gedefinieerd:

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

In het volgende voorbeeld wordt de standaard implementatie aangeroepen:

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

Elke klasse die de IControl interface implementeert, kan de standaardmethode Paint overschrijven, hetzij als een openbare methode of als een expliciete interface-implementatie.

Zie ook