Implementasi Antarmuka Eksplisit (Panduan Pemrograman C#)

Jika kelas mengimplementasikan dua antarmuka yang berisi anggota dengan tanda tangan yang sama, maka menerapkan anggota tersebut di kelas akan menyebabkan kedua antarmuka menggunakan anggota tersebut sebagai implementasi mereka. Dalam contoh berikut, semua panggilan untuk Paint memanggil metode yang sama. Sampel pertama ini mendefinisikan jenis:

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

Sampel berikut memanggil metode:

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

Tetapi Anda mungkin tidak ingin implementasi yang sama dipanggil untuk kedua antarmuka. Untuk memanggil implementasi yang berbeda tergantung pada antarmuka mana yang digunakan, Anda dapat mengimplementasikan anggota antarmuka secara eksplisit. Implementasi antarmuka eksplisit adalah anggota kelas yang hanya dipanggil melalui antarmuka yang ditentukan. Beri nama anggota kelas dengan cara menambahkan nama antarmuka di depan diikuti dengan titik. Contohnya:

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

Anggota IControl.Paint kelas hanya tersedia melalui IControl antarmuka, dan ISurface.Paint hanya tersedia melalui ISurface. Kedua implementasi metode terpisah, dan tidak tersedia langsung di kelas . Contohnya:

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

Implementasi eksplisit juga digunakan untuk menyelesaikan kasus di mana dua antarmuka masing-masing mendeklarasikan anggota yang berbeda dengan nama yang sama seperti properti dan metode. Untuk mengimplementasikan kedua antarmuka, kelas harus menggunakan implementasi eksplisit baik untuk properti P, atau metode P, atau keduanya, untuk menghindari kesalahan kompilator. Contohnya:

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

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

Implementasi antarmuka eksplisit tidak memiliki pengubah akses karena tidak dapat diakses sebagai anggota jenis yang ditentukan. Sebaliknya, ini hanya dapat diakses ketika dipanggil melalui instans antarmuka. Jika Anda menentukan pengubah akses untuk implementasi antarmuka eksplisit, Anda mendapatkan kesalahan kompilator CS0106. Untuk informasi selengkapnya, lihat interface (Referensi C#).

Anda dapat menentukan implementasi untuk anggota yang dideklarasikan dalam antarmuka. Jika kelas mewarisi implementasi metode dari antarmuka, metode tersebut hanya dapat diakses melalui referensi jenis antarmuka. Anggota yang diwariskan tidak muncul sebagai bagian dari antarmuka publik. Sampel berikut mendefinisikan implementasi default untuk metode antarmuka:

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

Sampel berikut memanggil implementasi default:

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

Kelas apa pun yang mengimplementasikan IControl antarmuka dapat mengambil alih metode default Paint , baik sebagai metode publik, atau sebagai implementasi antarmuka eksplisit.

Lihat juga

• Pemrograman berorientasi objek
• Antarmuka
• Warisan