Mengapa parameter opsional C # 4 didefinisikan pada antarmuka tidak diberlakukan pada kelas implementasi?

Saya perhatikan bahwa dengan parameter opsional di C # 4 jika Anda menentukan parameter opsional pada antarmuka yang Anda tidak perlu t membuat parameter itu opsional pada setiap kelas pelaksana:

public interface MyInterface
{
    void TestMethod(bool flag = false);
}

public class MyClass : MyInterface
{
    public void TestMethod(bool flag)
    {
        Console.WriteLine(flag);
    }
}

dan oleh karena itu:

var obj = new MyClass();        
obj.TestMethod(); // compiler error

var obj2 = new MyClass() as MyInterface;
obj2.TestMethod(); // prints false

Adakah yang tahu mengapa parameter opsional dirancang untuk bekerja seperti ini?

Di satu sisi saya kira kemampuan untuk menimpa nilai default apa pun yang ditentukan pada antarmuka berguna meskipun jujur ​​saya tidak yakin apakah Anda bahkan dapat menentukan nilai default pada antarmuka karena itu harus menjadi keputusan implementasi.

Di sisi lain, pemutusan ini berarti Anda tidak bisa selalu menggunakan kelas konkret dan antarmuka secara bergantian. Ini tentu saja, tidak akan menjadi masalah jika nilai default ditentukan pada implementasi, tetapi kemudian jika Anda mengekspos kelas beton Anda sebagai antarmuka (menggunakan beberapa kerangka kerja IOC untuk menyuntikkan kelas beton misalnya) maka benar-benar tidak ada titik memiliki nilai default sebagai penelepon harus selalu memberikannya.

UPDATE: Pertanyaan ini adalah topik blog saya pada 12 Mei 2011. Terima kasih atas pertanyaannya!

Misalkan Anda memiliki antarmuka seperti yang Anda gambarkan, dan seratus kelas yang mengimplementasikannya. Kemudian Anda memutuskan untuk membuat salah satu parameter dari salah satu metode antarmuka menjadi opsional. Apakah Anda menyarankan bahwa hal yang benar untuk dilakukan adalah kompilator memaksa pengembang untuk menemukan setiap implementasi metode antarmuka itu, dan menjadikan parameter opsional juga?

Misalkan kita melakukan itu. Sekarang anggap pengembang tidak memiliki kode sumber untuk implementasi:

// in metadata:
public class B 
{ 
    public void TestMethod(bool b) {}
}

// in source code
interface MyInterface 
{ 
    void TestMethod(bool b = false); 
}
class D : B, MyInterface {}
// Legal because D's base class has a public method 
// that implements the interface method

Bagaimana seharusnya penulis D membuat karya ini? Apakah mereka diharuskan di dunia Anda untuk memanggil pembuat B di telepon dan meminta mereka mengirimkan versi B yang baru yang membuat metode ini memiliki parameter opsional?

Itu tidak akan terbang. Bagaimana jika dua orang memanggil penulis B, dan salah satu dari mereka ingin defaultnya benar dan salah satunya ingin itu salah? Bagaimana jika penulis B menolak untuk ikut bermain?

Mungkin dalam kasus itu mereka akan diminta untuk mengatakan:

class D : B, MyInterface 
{
    public new void TestMethod(bool b = false)
    {
        base.TestMethod(b);
    }
}

Fitur yang diusulkan tampaknya menambah banyak ketidaknyamanan bagi programmer tanpa peningkatan yang sesuai dalam kekuatan representatif. Apa manfaat menarik dari fitur ini yang membenarkan peningkatan biaya bagi pengguna?

UPDATE: Dalam komentar di bawah ini, supercat menyarankan fitur bahasa yang benar-benar akan menambah daya ke bahasa dan mengaktifkan beberapa skenario yang mirip dengan yang dijelaskan dalam pertanyaan ini. FYI, fitur itu - implementasi standar metode dalam antarmuka - akan ditambahkan ke C # 8.

Parameter opsional baru saja ditandai dengan atribut. Atribut ini memberi tahu kompiler untuk memasukkan nilai default untuk parameter itu di situs panggilan.

Panggilan obj2.TestMethod();diganti dengan obj2.TestMethod(false);ketika kode C # dikompilasi ke IL, dan bukan pada waktu JIT.

Jadi dengan cara itu selalu penelepon memberikan nilai default dengan parameter opsional. Ini juga memiliki konsekuensi pada versi biner: Jika Anda mengubah nilai default tetapi tidak mengkompilasi ulang kode panggilan itu akan terus menggunakan nilai default lama.

Di sisi lain, pemutusan ini berarti Anda tidak bisa selalu menggunakan kelas konkret dan antarmuka secara bergantian.

Anda sudah tidak dapat melakukan itu jika metode antarmuka diterapkan secara eksplisit .

Karena parameter default diselesaikan pada waktu kompilasi, bukan runtime. Jadi nilai default bukan milik objek yang dipanggil, tetapi ke tipe referensi yang dipanggil.

Parameter opsional seperti substitusi makro dari yang saya mengerti. Mereka tidak benar-benar opsional dari sudut pandang metode. Artefak dari itu adalah perilaku yang Anda lihat di mana Anda mendapatkan hasil yang berbeda jika Anda menggunakan antarmuka.