Bagikan melalui

Implementasi Antarmuka Eksplisit (Panduan Pemrograman C#)

  • Artikel

Jika suatu 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 ini 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 menginginkan implementasi yang sama dipanggil untuk kedua antarmuka. Untuk memanggil implementasi yang berbeda tergantung 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 memberinya awalan nama antarmuka dan titik. Contohnya:

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

Anggota kelas IControl.Paint 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, maupun keduanya, untuk menghindari kesalahan pengompilasi. 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 didefinisikannya. Sebaliknya, ini hanya dapat diakses ketika dipanggil melalui instans antarmuka. Jika Anda menentukan pengubah akses untuk implementasi antarmuka eksplisit, Anda mendapatkan kesalahan pengompilasi CS0106. Untuk informasi selengkapnya, lihat interface (Referensi C#).

Anda dapat menentukan implementasi untuk anggota yang dideklarasikan dalam antarmuka. Jika kelas mewarisi implementasi metode dari sebuah 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 yang mengimplementasikan IControl antarmuka dapat mengambil alih metode default Paint, baik sebagai metode publik, atau sebagai implementasi antarmuka eksplisit.

Lihat juga