Perbedaan antara shadowing dan overriding di C #?

Apa perbedaan antara membayangi dan menimpa metode di C #?

Nah warisan ...

misalkan Anda memiliki kelas ini:

class A {
   public int Foo(){ return 5;}
   public virtual int Bar(){return 5;}
}
class B : A{
   public new int Foo() { return 1;}     //shadow
   public override int Bar() {return 1;} //override
}

lalu saat Anda menyebut ini:

A clA = new A();
B clB = new B();

Console.WriteLine(clA.Foo()); // output 5
Console.WriteLine(clA.Bar()); // output 5
Console.WriteLine(clB.Foo()); // output 1
Console.WriteLine(clB.Bar()); // output 1

//now let's cast B to an A class
Console.WriteLine(((A)clB).Foo()); // output 5 <<<-- shadow
Console.WriteLine(((A)clB).Bar()); // output 1

Misalkan Anda memiliki kelas dasar dan Anda menggunakan kelas dasar di semua kode Anda alih-alih kelas yang diwariskan, dan Anda menggunakan bayangan, itu akan mengembalikan nilai yang dikembalikan kelas dasar alih-alih mengikuti pohon warisan dari tipe objek yang sebenarnya.

Jalankan kode di sini

Semoga saya masuk akal :)

Membayangi sebenarnya adalah bahasa VB untuk apa yang kita sebut bersembunyi di C #.

Seringkali bersembunyi (membayangi di VB) dan menimpa ditampilkan seperti dalam jawaban Stormenet .

Metode virtual terbukti diganti oleh sub-kelas dan panggilan ke metode itu bahkan pada tipe kelas-super atau dari dalam kode kelas-super akan memanggil implementasi pengganti dari sub-kelas tersebut.

Kemudian metode konkret ditampilkan (yang tidak ditandai sebagai virtual atau abstrak) disembunyikan dengan menggunakan new kata kunci saat mendefinisikan metode dengan tanda tangan yang identik pada sub-kelas. Dalam kasus ini, ketika metode dipanggil pada tipe kelas super implementasi asli digunakan, implementasi baru hanya tersedia pada sub-kelas.

Namun yang sering terlewatkan adalah kemungkinan juga untuk menyembunyikan metode virtual.

class A
{
    public virtual void DoStuff() { // original implementation }
}

class B : A
{
    public new void DoStuff() {  //new implementation }
}

B b = new B();
A a = b;

b.DoStuff(); //calls new implementation
a.DoStuff(); //calls original implementation.

Perhatikan pada contoh di atas DoStuff menjadi beton dan tidak dapat diganti. Namun, juga memungkinkan untuk menggunakan kata kunci virtualdan secara newbersamaan.

class A
{
    public virtual void DoStuff() { // original implementation }
}

class B : A
{
    public new virtual void DoStuff() {  //new implementation }
}

class C : B
{
    public override void DoStuff() { //replacement implementation }
}

C c = new C();
B b = c;
A a = b;

c.DoStuff(); //calls replacement implementation
b.DoStuff(); //calls replacement implementation
a.DoStuff(); //calls original implementation.

Perhatikan bahwa meskipun semua metode yang terlibat bersifat virtual, penggantian pada C tidak memengaruhi metode virtual pada A karena penggunaan newdalam B menyembunyikan implementasi A.

Edit: Telah dicatat dalam komentar untuk jawaban ini bahwa hal di atas mungkin berbahaya atau setidaknya tidak terlalu berguna. Saya akan mengatakan ya itu bisa berbahaya dan akan ada di luar sana jika itu berguna.

Secara khusus, Anda bisa mendapatkan segala macam masalah jika Anda juga mengubah pengubah aksesibilitas. Sebagai contoh:-

public class Foo
{
    internal Foo() { }
    protected virtual string Thing() { return "foo"; }
}

public class Bar : Foo
{
 internal new string Thing() { return "bar"; }
}

Untuk pewaris eksternal Bar, Fooimplementasi Thing () tetap dapat diakses dan diganti. Semua legal dan dapat dijelaskan menurut aturan tipe .NET tidak pernah cukup tidak intuitif.

Saya telah memposting jawaban ini untuk memperdalam pemahaman tentang bagaimana segala sesuatu bekerja bukan sebagai saran teknik yang dapat digunakan secara bebas.

Saya pikir perbedaan utamanya adalah dengan membayangi, Anda pada dasarnya menggunakan kembali nama itu, dan hanya mengabaikan penggunaan superclass. Dengan menimpa, Anda mengubah implementasi, tetapi bukan aksesibilitas dan tanda tangan (mis. Tipe parameter dan pengembalian). Lihat http://www.geekinterview.com/question_details/19331 .

Membayangi adalah konsep VB.NET. Di C #, Shadowing dikenal sebagai Hiding. Ini menyembunyikan metode kelas turunan. Ini dilakukan dengan menggunakan kata kunci 'baru'.

Kata kunci Override digunakan untuk menyediakan implementasi yang benar-benar baru dari metode kelas dasar (yang ditandai 'Virtual') di kelas turunan.

Pada dasarnya jika Anda memiliki sesuatu seperti di bawah ini,

Class A
{
}

Class B:A
{
}

A a = new B();

Setiap metode yang Anda panggil pada objek 'a' akan dibuat dengan tipe 'a' (Di sini tipenya adalah 'A') Tetapi jika Anda menerapkan metode yang sama di kelas B yang sudah ada di Kelas A, kompiler akan memberi Anda peringatan untuk menggunakan kata kunci "Baru". Jika Anda menggunakan "Baru", peringatan itu akan hilang. Selain ini, tidak ada perbedaan antara menggunakan "Baru" atau tidak menggunakannya di kelas yang diwariskan.

Dalam beberapa situasi Anda mungkin perlu memanggil metode kelas referensi yang dipegang oleh instance tertentu pada saat itu alih-alih memanggil metode pada tipe objek. Dalam kasus di atas, referensi yang dimilikinya adalah 'B', tetapi tipenya adalah 'A'. Jadi jika Anda ingin panggilan metode harus terjadi pada 'B', maka Anda menggunakan Virtual dan menimpa untuk mencapai ini.

Semoga ini membantu...

Daniel Sandeep.

Jika ada kasus di mana Anda tidak dapat mengubah konten kelas, katakanlah A, tetapi Anda ingin menggunakan beberapa metodenya bersama dengan Anda memiliki metode yang namanya umum, Anda dapat menggunakan implementasi metode Anda sendiri dengan newkata kunci.

Inti dari penggunaannya adalah referensi dan objek harus memiliki tipe yang sama.

class A
{
    public void Test()
    {
        Console.WriteLine("base");
    }
}

class B : A
{
    public new void Test()
    {
        Console.WriteLine("sub");
    }

    public static void Main(string[] args)
    {
        A a = new A();
        B aa = new B();
        a.Test();
        aa.Test();
    }
}