Apa kegunaan praktis dari pengubah "baru" dalam C # sehubungan dengan bersembunyi?

Seorang rekan kerja dan saya melihat perilaku newkata kunci dalam C # yang berlaku untuk konsep persembunyian. Dari dokumentasi :

Gunakan pengubah baru untuk secara eksplisit menyembunyikan anggota yang diwarisi dari kelas dasar. Untuk menyembunyikan anggota yang diwarisi, mendeklarasikannya di kelas turunan menggunakan nama yang sama, dan memodifikasinya dengan pengubah baru.

Kami telah membaca dokumentasinya, dan kami mengerti apa yang dasarnya dan bagaimana melakukannya. Apa yang tidak bisa kami tangani adalah mengapa Anda harus melakukannya sejak awal. Pengubah sudah ada sejak 2003, dan kami berdua telah bekerja dengan .Net lebih lama dari itu dan tidak pernah muncul.

Kapan perilaku ini diperlukan dalam arti praktis (misalnya: sebagaimana diterapkan pada kasus bisnis)? Apakah ini fitur yang telah melampaui kegunaannya atau apakah fungsinya cukup tidak biasa dalam apa yang kita lakukan (khususnya kita melakukan formulir web dan aplikasi MVC dan beberapa faktor kecil WinForms dan WPF)? Dalam mencoba kata kunci ini dan bermain dengannya kami menemukan beberapa perilaku yang memungkinkannya tampak sedikit berbahaya jika disalahgunakan.

Ini terdengar agak terbuka, tetapi kami sedang mencari kasus penggunaan tertentu yang dapat diterapkan ke aplikasi bisnis yang menganggap alat khusus ini bermanfaat.

Anda dapat menggunakannya untuk meniru kovarians tipe kembali. Penjelasan Eric Lippert . Eric memberikan contoh kode ini:

abstract class Enclosure
{
    protected abstract Animal GetContents();
    public Animal Contents() { return this.GetContents(); }
}
class Aquarium : Enclosure
{
    public new Fish Contents() { ... }
    protected override Animal GetContents() { return this.Contents(); }
}

Ini adalah solusi. public override Fish Contents() { ... }tidak legal, meskipun aman.

Secara umum, Anda tidak boleh menggunakan metode persembunyian, karena membingungkan bagi konsumen kelas Anda (contoh spesifik di atas tidak menderita masalah ini). Beri nama metode baru Anda sesuatu yang lain jika Anda tidak ingin mengganti metode yang ada.

Kemungkinan situasi dunia nyata di mana Anda perlu menyembunyikan metode adalah jika penyedia kelas dasar menambahkan metode generik yang telah Anda tambahkan ke kelas turunan. Program seperti itu akan mengkompilasi (dan memberikan peringatan) tanpa kata kunci baru, tetapi menambahkan newmengatakan, "Saya tahu versi saya dari metode ini menggantikan versi kelas dasar. Ini mengerikan dan membingungkan, tetapi kami tidak dapat menggunakannya." Itu masih lebih baik daripada memaksa kelas turunan untuk mengganti nama metode mereka.

Membiarkan metode turunan diperlakukan sebagai override akan menyebabkan masalah. Mengabaikan masalah dengan penerapan kompiler, metode baru secara semantik berbeda dari metode dasar, tetapi polimorfisme akan menyebabkan metode baru dipanggil ketika diminta memanggil metode dengan nama yang sama.

Situasi ini dibahas secara rinci dalam posting ini oleh Eric Lippert.

Saya pikir itu ada jika Anda mungkin perlu melakukan sesuatu yang mungkin tidak terpikirkan oleh perancang bahasa. C # dalam banyak hal merupakan reaksi terhadap versi awal java. Dan satu hal yang dilakukan java adalah secara eksplisit pengembang pigeonhole untuk menghilangkan kemungkinan pengembang menembak diri mereka sendiri. C # mengambil pendekatan yang sedikit berbeda dan memberi pengembang sedikit lebih banyak kekuatan untuk memungkinkan pengembang kesempatan lebih banyak untuk menembak diri mereka sendiri. Salah satu contohnya adalah unsafekata kunci. newKata kunci ini adalah yang lain.

Sekarang, itu mungkin tidak berguna seperti unsafetetapi setelah Anda masuk ke spesifikasi bahasa sulit untuk keluar dari spesifikasi bahasa.

Ia memberi tahu pembaca bahwa "Saya sengaja menyembunyikan penerapan metode ini oleh kelas dasar", dan bukannya tanpa sengaja.

Anda mungkin ingin memiliki anggota sebelumnya tersedia melalui nama lain:

class VehicleClass
{
  public int AnyProperty
  {
    get; set;
  }

  public int AnyFunction() { return 0; }
} // VehicleClass

class IntermediateClass : VehicleClass
{
  public int PreviousAnyProperty
  {
    get { return AnyProperty; }
    set { AnyProperty = value  }
  }

  public int PreviousAnyFunction() { return AnyFunction(); }
} // IntermediateClass 

class CarClass : IntermediateClass
{
  public new int AnyProperty
  {
    get ; set ;
  }

  public new int AnyFunction() { return 5; }
} // class CarClass

class ExampleClass
{

  public static void Main()
  {
    using (CarClass MyCar = new CarClass())
    {
      int AnyInt1 = MyCar.PreviousAnyProperty;
      MyCar.PreviousAnyProperty = 7;

      int AnyInt2 = MyCar.PreviousAnyFunction();

      int AnyInt3 = MyCar.AnyProperty;
      MyCar.AnyProperty = 45;

      int AnyInt4 = MyCar.AnyFunction();
    }
  } // static void Main()

} // class CarClass

Tepuk tangan.

Saya merasa cukup berguna ketika membuat suite uji untuk kode lawas. Itu memungkinkan saya untuk menyembunyikan dependensi eksternal, seperti menanyakan database di dalam metode yang digunakan oleh metode lain. Untuk dapat menguji metode lain saya bisa menyembunyikan logika asli yang tergantung pada sumber daya eksternal tanpa perlu menambahkan kata kunci virtual ke metode-metode di kelas uji.