C # - Penggunaan kata kunci virtual + override vs baru

Apa perbedaan antara mendeklarasikan metode dalam tipe dasar " virtual" dan kemudian menimpanya dalam tipe anak menggunakan " override" kata kunci dibandingkan dengan hanya menggunakan newkata kunci " " ketika mendeklarasikan metode pencocokan dalam tipe anak?

Kata kunci "baru" tidak menggantikan, itu menandakan metode baru yang tidak ada hubungannya dengan metode kelas dasar.

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

public class Test
{
    public static void Main ()
    {
        Foo test = new Bar ();
        Console.WriteLine (test.DoSomething ());
    }
}

Ini mencetak false, jika Anda menimpanya akan dicetak benar.

(Kode dasar diambil dari Joseph Daigle)

Jadi, jika Anda melakukan polimorfisme nyata, Anda HARUS SELALU BERLEBIHAN . Satu-satunya tempat di mana Anda perlu menggunakan "baru" adalah ketika metode ini tidak terkait dengan cara apa pun dengan versi kelas dasar.

Saya selalu menemukan hal-hal seperti ini lebih mudah dipahami dengan gambar:

Sekali lagi, mengambil kode joseph daigle,

public class Foo
{
     public /*virtual*/ bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public /*override or new*/ bool DoSomething() { return true; }
}

Jika Anda memanggil kode seperti ini:

Foo a = new Bar();
a.DoSomething();

CATATAN: Yang penting adalah bahwa objek kita sebenarnya a Bar, tetapi kita menyimpannya dalam variabel tipeFoo (ini mirip dengan menuangnya)

Maka hasilnya adalah sebagai berikut, tergantung pada apakah Anda menggunakan virtual/ overrideatau newketika mendeklarasikan kelas Anda.

Berikut ini beberapa kode untuk memahami perbedaan dalam perilaku metode virtual dan non-virtual:

class A
{
    public void foo()
    {
        Console.WriteLine("A::foo()");
    }
    public virtual void bar()
    {
        Console.WriteLine("A::bar()");
    }
}

class B : A
{
    public new void foo()
    {
        Console.WriteLine("B::foo()");
    }
    public override void bar()
    {
        Console.WriteLine("B::bar()");
    }
}

class Program
{
    static int Main(string[] args)
    {
        B b = new B();
        A a = b;
        a.foo(); // Prints A::foo
        b.foo(); // Prints B::foo
        a.bar(); // Prints B::bar
        b.bar(); // Prints B::bar
        return 0;
    }
}

Kata newkunci sebenarnya membuat anggota yang sama sekali baru yang hanya ada pada jenis tertentu.

Misalnya

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

Metode ini ada pada kedua jenis. Ketika Anda menggunakan refleksi dan mendapatkan anggota tipe Bar, Anda akan benar-benar menemukan 2 metode DoSomething()yang terlihat persis sama. Dengan menggunakan newAnda secara efektif menyembunyikan implementasi di kelas dasar, sehingga ketika kelas berasal dari Bar(dalam contoh saya) panggilan metode untuk base.DoSomething()pergi ke Bardan tidak Foo.

virtual / override memberitahu kompiler bahwa kedua metode terkait dan bahwa dalam beberapa keadaan ketika Anda akan berpikir Anda memanggil metode pertama (virtual) itu benar untuk memanggil metode kedua (override) sebagai gantinya. Ini adalah dasar dari polimorfisme.

(new SubClass() as BaseClass).VirtualFoo()

Akan memanggil metode VirtualFoo () utama SubClass.

baru memberitahu kompiler bahwa Anda menambahkan metode ke kelas turunan dengan nama yang sama dengan metode di kelas dasar, tetapi mereka tidak memiliki hubungan satu sama lain.

(new SubClass() as BaseClass).NewBar()

Akan memanggil metode NewBar () BaseClass, sedangkan:

(new SubClass()).NewBar()

Akan memanggil metode NewCar () SubClass.

Selain detail teknis, saya pikir menggunakan virtual / override mengkomunikasikan banyak informasi semantik pada desain. Ketika Anda mendeklarasikan metode virtual, Anda mengindikasikan bahwa Anda berharap bahwa kelas implementasi mungkin ingin menyediakan implementasi mereka sendiri, non-default. Menghilangkan ini dalam kelas dasar, juga, menyatakan harapan bahwa metode default harus mencukupi untuk semua kelas implementasi. Demikian pula, seseorang dapat menggunakan deklarasi abstrak untuk memaksa kelas implementasi untuk menyediakan implementasi mereka sendiri. Sekali lagi, saya pikir ini banyak berkomunikasi tentang bagaimana programmer mengharapkan kode yang akan digunakan. Jika saya menulis basis dan kelas implementasi dan mendapati diri saya menggunakan yang baru, saya serius akan memikirkan kembali keputusan untuk tidak membuat metode virtual pada orang tua dan menyatakan maksud saya secara khusus.

Perbedaan antara kata kunci override dan kata kunci baru adalah bahwa yang pertama melakukan overriding metode dan kemudian yang bersembunyi metode.

Lihat tautan berikut untuk informasi lebih lanjut ...

MSDN dan Lainnya

• newkata kunci untuk Menyembunyikan. - Berarti Anda menyembunyikan metode Anda saat runtime. Output akan didasarkan pada metode kelas dasar.
• overrideuntuk mengganti. - berarti Anda menggunakan metode kelas turunan Anda dengan referensi kelas dasar. Output akan didasarkan pada metode kelas turunan.

Versi penjelasan saya berasal dari penggunaan properti untuk membantu memahami perbedaan.

overridecukup sederhana kan? Jenis yang mendasari menimpa orang tua.

newmungkin menyesatkan (bagi saya itu). Dengan properti lebih mudah dipahami:

public class Foo
{
    public bool GetSomething => false;
}

public class Bar : Foo
{
    public new bool GetSomething => true;
}

public static void Main(string[] args)
{
    Foo foo = new Bar();
    Console.WriteLine(foo.GetSomething);

    Bar bar = new Bar();
    Console.WriteLine(bar.GetSomething);
}

Menggunakan debugger Anda dapat melihat bahwa Foo fooada 2 GetSomething properti, karena sebenarnya memiliki 2 versi properti, FoodanBar ', dan untuk mengetahui mana yang akan digunakan, c # "mengambil" properti untuk jenis saat ini.

Jika Anda ingin menggunakan versi Bar, Anda akan menggunakan penggantian atau gunakan Foo foosebagai gantinya.

Bar bar hanya memiliki 1 , karena ingin perilaku yang sama sekali baru untuk GetSomething.

Tidak menandai metode dengan apa pun berarti: Bind metode ini menggunakan tipe kompilasi objek, bukan tipe runtime (pengikatan statis).

Menandai metode dengan virtual cara: Bind metode ini menggunakan tipe runtime objek, bukan tipe waktu kompilasi (pengikatan dinamis).

Menandai virtualmetode kelas dasar dengan overridekelas turunan berarti: Ini adalah metode yang akan diikat menggunakan tipe runtime objek (pengikatan dinamis).

Menandai virtualmetode kelas dasar dengan newkelas turunan berarti: Ini adalah metode baru, yang tidak memiliki hubungan dengan yang memiliki nama yang sama di kelas dasar dan harus diikat menggunakan jenis waktu kompilasi objek (pengikatan statis).

Tidak menandai virtualmetode kelas dasar dalam kelas turunan berarti: Metode ini ditandai sebagai new(pengikatan statis).

Menandai metode abstractberarti: Metode ini virtual, tetapi saya tidak akan mendeklarasikan sebuah tubuh untuk itu dan kelasnya juga abstrak (pengikatan dinamis).