Perché i parametri opzionali C # 4 definiti sull'interfaccia non vengono applicati sulla classe di implementazione?

Ho notato che con i parametri opzionali in C # 4 se si specifica un parametro facoltativo su un'interfaccia che non si desidera , è necessario rendere quel parametro facoltativo su qualsiasi classe di implementazione:

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

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

e quindi:

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

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

Qualcuno sa perché i parametri opzionali sono progettati per funzionare in questo modo?

Da un lato suppongo che la capacità di sovrascrivere i valori predefiniti specificati sulle interfacce sia utile anche se ad essere onesti non sono sicuro che dovresti essere in grado di specificare i valori predefiniti sull'interfaccia in quanto dovrebbe essere una decisione di implementazione.

D'altra parte, questa disconnessione significa che non è sempre possibile utilizzare la classe concreta e l'interfaccia in modo intercambiabile. Questo, naturalmente, non sarebbe un problema se il valore predefinito è specificato sull'implementazione, ma quindi se stai esponendo la tua classe concreta come interfaccia (usando un framework IOC per iniettare la classe concreta per esempio) allora davvero non c'è punto avendo il valore predefinito come il chiamante dovrà sempre fornirlo comunque.

AGGIORNAMENTO: Questa domanda è stata l'oggetto del mio blog il 12 maggio 2011. Grazie per l'ottima domanda!

Supponi di avere un'interfaccia come descrivi e un centinaio di classi che la implementano. Quindi si decide di rendere facoltativo uno dei parametri di uno dei metodi dell'interfaccia. Stai suggerendo che la cosa giusta da fare è che il compilatore costringa lo sviluppatore a trovare tutte le implementazioni di quel metodo di interfaccia e rendere facoltativo anche il parametro?

Supponiamo di averlo fatto. Supponiamo ora che lo sviluppatore non avesse il codice sorgente per l'implementazione:

// 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

Come dovrebbe fare l'autore di D per farlo funzionare? Sono obbligati nel tuo mondo a chiamare l'autore di B al telefono e chiedere loro di inviare loro una nuova versione di B che rende il metodo un parametro opzionale?

Non volerà. Cosa succede se due persone chiamano l'autore di B e uno di loro vuole che il valore predefinito sia vero e uno di loro vuole che sia falso? E se l'autore di B si rifiuta semplicemente di suonare insieme?

Forse in quel caso sarebbero tenuti a dire:

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

La funzionalità proposta sembra aggiungere molti inconvenienti al programmatore senza un corrispondente aumento del potere rappresentativo. Qual è il vantaggio convincente di questa funzione che giustifica l'aumento dei costi per l'utente?

AGGIORNAMENTO: Nei commenti seguenti, supercat suggerisce una funzionalità linguistica che aggiungerebbe realmente potere alla lingua e consentirebbe alcuni scenari simili a quello descritto in questa domanda. Cordiali saluti, quella caratteristica - implementazioni predefinite di metodi nelle interfacce - verrà aggiunta a C # 8.

Un parametro facoltativo è appena taggato con un attributo. Questo attributo indica al compilatore di inserire il valore predefinito per quel parametro nel sito di chiamata.

La chiamata obj2.TestMethod();viene sostituita da obj2.TestMethod(false);quando il codice C # viene compilato in IL e non in JIT-time.

Quindi in un certo senso è sempre il chiamante a fornire il valore predefinito con parametri opzionali. Ciò ha conseguenze anche sul controllo delle versioni binario: se si modifica il valore predefinito ma non si ricompila il codice chiamante, continuerà a utilizzare il vecchio valore predefinito.

D'altra parte, questa disconnessione significa che non è sempre possibile utilizzare la classe concreta e l'interfaccia in modo intercambiabile.

Non puoi già farlo se il metodo di interfaccia è stato implementato esplicitamente .

Poiché i parametri predefiniti vengono risolti in fase di compilazione, non in fase di esecuzione. Quindi i valori predefiniti non appartengono all'oggetto chiamato, ma al tipo di riferimento attraverso il quale viene chiamato.

I parametri opzionali sono un po 'come una sostituzione macro da quello che ho capito. Non sono realmente opzionali dal punto di vista del metodo. Un artefatto di ciò è il comportamento che vedi dove ottieni risultati diversi se esegui il cast su un'interfaccia.