Notei que, com os parâmetros opcionais em C # 4, se você especificar um parâmetro opcional em uma interface , não precisará torná-lo opcional em qualquer classe de implementação:
public interface MyInterface
{
void TestMethod(bool flag = false);
}
public class MyClass : MyInterface
{
public void TestMethod(bool flag)
{
Console.WriteLine(flag);
}
}
e portanto:
var obj = new MyClass();
obj.TestMethod(); // compiler error
var obj2 = new MyClass() as MyInterface;
obj2.TestMethod(); // prints false
Alguém sabe por que os parâmetros opcionais são projetados para funcionar dessa maneira?
Por um lado, suponho que a capacidade de substituir qualquer valor padrão especificado nas interfaces seja útil, mas para ser sincero, não tenho certeza se você deve especificar valores padrão na interface, pois isso deve ser uma decisão de implementação.
Por outro lado, essa desconexão significa que você nem sempre pode usar a classe concreta e a interface de forma intercambiável. É claro que isso não seria um problema se o valor padrão for especificado na implementação, mas se você estiver expondo sua classe concreta como interface (usando alguma estrutura do IOC para injetar a classe concreta, por exemplo), então realmente não há ponto que possui o valor padrão, pois o chamador sempre deve fornecê-lo de qualquer maneira.
MyInterface
e chamá-lo com o parâmetro opcional: ((MyInterface)obj).TestMethod();
.