C# 4.0 introduz um novo tipo: dinâmico, que é um tipo estático, mas uma instância de objeto desse tipo consegue contornar o processo de verificação de tipos estáticos. Na maioria dos casos, o tipo funciona como uma classe de objetos. Na época da compilação, uma instância de uma classe dinâmica suporta qualquer operação, então não há necessidade de se preocupar se o objeto foi retirado de uma API COM, ou de uma linguagem dinâmica como IronPython, do DOM HTML, do reflection ou de algum outro lugar do programa. No entanto, se o código fizer algo inválido, o erro é detectado em tempo de execução.
Por exemplo, o exemplo exampleMethod1 no trecho de código a seguir tem apenas um parâmetro, e o compilador pode identificar que ele é inválido ao chamar ec.exampleMethod1(10,4) em tempo de compilação; Isso é um erro de compilação. A segunda chamada dynamic_ec.exampleMethod1(10,4) não é verificada para tipos estáticos. Portanto, o compilador não reporta erros de compilação. No entanto, o inseto não se esconde para sempre; Ele será capturado em tempo de execução e acionará uma exceção em tempo de execução.
static void Main(string[] args){
ExampleClass ec = nova ExampleClass();
dinâmica dynamic_ec = nova ExampleClass();
dynamic_ec.exampleMethod1(10, 4);
dynamic_ec.someMethod ("algum argumento", 7, nulo);
dynamic_ec.nonexistentMethod();
}
classe ExemploClasse {
ExampleClass() { }
public ExampleClass(int v) { }
exemplo public voidMethod1(int i) { }
exemplo de void públicoMétodo2(string str) { }
}
Aqui está um exemplo de usar dinâmica para chamar IronPython:
usando IronPython.Hosting;
usando Microsoft.scrip{filtering}ting. Apresentação;
Console.WriteLine("Carregando random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
Aleatório dinâmico = Py. UseFile("random.py");
Console.WriteLine("random.py carregado!");
var itens = Enumerável. Range(1, 7). ToArray();
para (int s = 0; s < 10000; s++) {
random.shuffle(itens);
Console.Write("Sequence {0}: ", s);
foreach (int i em itens) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
Para objetos ou expressões de dinâmica de tipos, o papel do compilador é encapsular as ações que cada expressão deve realizar e, no momento da execução, verificar as informações armazenadas, e quaisquer instruções inválidas dispararão uma exceção em tempo de execução.
O tipo de resultado da maioria das operações dinâmicas também é dinâmico. Por exemplo, se você passar o ponteiro do mouse sobre o testSum no exemplo a seguir, o prompt inteligente exibirá um testSum dinâmico (variável local).
dinâmica d = 1;
var testSum = d + 3;
Passe o ponteiro do mouse sobre o testSum abaixo.
System.Console.WriteLine(testSum);
Conversão de tipos
A transição entre instâncias do tipo Dinâmico e outros tipos de instâncias é simples, e os desenvolvedores podem facilmente alternar entre comportamentos dinâmicos e não dinâmicos. Qualquer instância pode ser convertida implicitamente em uma instância do tipo dinâmico, veja o seguinte exemplo:
dinâmica d1 = 7;
dinâmica d2 = "uma corda";
dinâmica d3 = System.DateTime.Today;
dinâmico d4 = System.Diagnostics.Process.GetProcesses();
Por outro lado, uma conversão implícita pode ser aplicada dinamicamente a qualquer expressão de dinâmica de tipos.
E vice-versa, qualquer expressão de dinâmica de tipos também pode ser implicitamente convertida para outros tipos.
int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Problema de sobrecarga com parâmetros de tipo dinâmico no método
Se um método é chamado de passes a um objeto de tipo dinâmico, ou o objeto chamado é de tipo dinâmico, então o julgamento de sobrecarga ocorre em tempo de execução e não em tempo de compilação.
DLR em tempo de execução de linguagem dinâmica
O tempo de execução dinâmico da linguagem é . NET Framework 4 Beta 1 é um novo conjunto de APIs que oferecem suporte para tipos dinâmicos em C# e também implementam linguagens de programação dinâmicas como IronPython e IronRuby.
Interoperabilidade COM
O C# 4.0 inclui vários recursos que melhoram a interoperabilidade com interfaces tradicionais da API COM, como a automação do Office. Tipos dinâmicos, parâmetros nomeados e parâmetros opcionais também fazem parte da melhoria.
Muitos métodos COM permitem que seus parâmetros e valores de retorno sejam de tipo objeto, então, para linguagens fortemente tipadas como C#, é necessária muita conversão forçada de tipo. No entanto, em C# 4.0, se você adicionar a opção /link em tempo de compilação, o tipo dinâmico tem um novo efeito: torna o tipo de objeto (tipo de parâmetro ou tipo de retorno) na assinatura do método da interface COM considerado dinâmico, evitando assim muita conversão de tipos. Por exemplo, a seguinte afirmação contrasta com isso.
Não é usado de forma dinâmica.
((Excel.Range)excel. Células[1, 1]). Value2 = "Nome";
Excel. Alcance = (Excel. Intervalo)excel. Células[1, 1];
Foi uma experiência dinâmica.
Excel. Células[1, 1]. Valor = "Nome";
Excel. Alcance de alcance = excel. Células[1, 1]; |
Publicado em 07/07/2016 10:23:00
|
|
|
