Proposta C#: Verificação Estática De Objectos Dinâmicos Em Tempo De Compilação
O C# 4.0 introduz um novo tipo: dynamic. dynamic é um tipo estático que contorna os mecanismos de verificação estática de tipos.
Este novo tipo é muito útil para interoperar com:
Porque a verificação estática de tipos é contornada, isto:
dynamic dynamicValue = GetValue();
dynamicValue.Method();
é equivalente a isto:
object objectValue = GetValue();
objectValue
.GetType()
.InvokeMember(
"Method",
BindingFlags.InvokeMethod,
null,
objectValue,
null);
Aparte a memorização “escondida” do call site e alguma resolução dinâmica, dynamic apenas tem melhor aspecto. Qualquer erro de digitação só será descoberto em tempo de execução.
De facto, se estou a escrever o código, eu sei o contrato do que estou a chamar. Não seria bom se o compilador pudesse fazer alguma verificação estática de tipos na interacção com estes objectos dinâmicos?
Imagine-se que o objecto dinâmico que estou a obter na chamada ao método GetValue, alé do método sem parâmetros Method também tem uma propriedade Property do tipo string. Ist quer dizer que, do ponto de vista do código que estou a escrever, o contrato que o objecto dinâmico devolvido por GetValue implementa é:
string Property { get; }
void Method();
Com se trata de um contrato bem definido, eu poderia escrever uma interface para o representar:
interface IValue
{
string Property { get; }
void Method();
}
Se dynamic permitisse a especificação do contrato no formato dynamic(contrato), eu poderia escrever isto:
dynamic(IValue) dynamicValue = GetValue();
dynamicValue.Method();
Ist não quer dizer que o valor por GetValue tem de implementar a interface IValue. Apenas permite ao compilador verificar que dynamicValue.Method() é uma utilização válida de dynamicValue e dynamicValue.OtherMethod() não.
Se a interface IValue já existir, por alguma razão, não há qualquer problema. Mas ter de adicionar um novo tipo à assembly apenas para ser usado em tempo de compilação não me parece correcto. Por isso, dynamic podeia ser um novo tipo de especificação de tipos. Algo como:
dynamic DValue
{
string Property { get; }
void Method();
}
O código passaria a ser escrito assim;
DValue dynamicValue = GetValue();
dynamicValue.Method();
O compilador nunca geraia qualquer IL ou metadados para esta especificação de tipo. Esta especificação de tipo seria usada apenas para o compilador efectuar uma verificação estática dos objectos diâmicos. Como consequência, não faz qualquer sentido ser acessível publicamente, pelo que tal não seria permitido.
Mais uma vez, se a interface IValue (ou qualquer outra definição de tipo) já existir, pode ser usada na definição de tipo dinâmico:
dynamic DValue : IValue, IEnumerable, SomeClass
{
string Property { get; }
void Method();
}
Um benfício acrescido seria IntelliSense.
Tenho recebido reacções mistas em relação a esta proposta. O que acham? Seria algo útil?