ExpandoObject: dinamismo no .NET 4.0

Nesse artigo vamos falar um pouco sobre dynamic no .NET 4.0.

por Vinicius Quaiato

Fala galera, hoje vamos falar um pouco sobre dynamic no .NET 4.0.

Dynamic é um novo tipo introduzido no .net framework 4.0, é um tipo estático assim como os outros tipos do framework, no entanto ele ignora as verificações estáticas em tempo de compilação.
Deve-se prestar atenção, então, aos erros que podem acontecer em runtime, pois um código que não existe e seja chamado gerará um erro em tempo de execução.

Alguns podem achar que isso é um problema, esse papo todo de runtime e etc, eu já não enxergo desta maneira, vejo como uma oportunidade para novas criações.
Diversas empresas e projetos que trabalham com .net se deparam em situações onde a equipe diz:
“Ah se isso fosse diferente… Poderíamos fazer de forma mais simples ou legível…”.
Isso não é uma coisa ruim, é um sinal de que em algumas situações necessitamos de algo mais dinâmico do que o que o .net proporciona (proporcionava) até então.

Bom vamos falar um pouco do ExpandoObject.
ExpandoObject é um objeto que pode ter membros adicionados ou removidos dinâmicamente. Com ele é possível definirmos métodos e propriedades em tempo de execução.
Talvez muitos de nós não vejamos vantagens neste tipo de feature logo de início, mas para muitos será uma feature muito interessante e que proporcionará um grande avanço.

Vamos imaginar o seguinte cenário para a utilização do ExpandoObject:
Um sistema consome diversos webservices de empresas distintas de um mesmo segmento, porém, para cada usuário do sistema configuramos uma permissão diferente aos serviços oferecidos por estes webservices.
Vejamos um código de exemplo (lembrando que você precisa do Visual Studio 2010).

1 using System;
2 using System.Dynamic;
3 
4 namespace ExpandoObjectApplication
5 {
6     class Program
7     {
8         static void Main(string[] args)
9         {
10             dynamic objetoDinamico = new ExpandoObject();
11             dynamic Sistema1 = new ExpandoObject();
12             dynamic Sistema2 = new ExpandoObject();
13  
14             Sistema1.PodeAcessar = false;
15             Sistema1.AlgumaAcao = (Func)(() =>
16             {
17                 if (Sistema1.PodeAcessar)
18                     return "AlgumaAcao no Sistema1";
19                 else
20                     return "Você não pode acessar este serviço";
21             });
22             objetoDinamico.Sistema1 = Sistema1;
23  
24             Sistema2.PodeAcessar = true;
25             Sistema2.OutraAcao = (Func)(() =>
26             {
27                 if (Sistema2.PodeAcessar)
28                     return 1 + 1;
29                 else
30                     throw new Exception("Você não pode acessar este serviço");
31             });
32             objetoDinamico.Sistema2 = Sistema2;
33  
34             Console.WriteLine("objetoDinamico.Sistema1.AlgumaAcao: {0}", 
                 objetoDinamico.Sistema1.AlgumaAcao());
35  
36             Console.WriteLine("objetoDinamico.Sistema2.OutraAcao: {0}", 
                 objetoDinamico.Sistema2.OutraAcao());
37  
38             Console.ReadKey();
39         }
40     }
41 }

Na linha 2 incluímos uma referência para System.Dynamic, necessário para utilizar o ExpandoObject.
nas linhas 10, 11 e 12 criamos 3 objetos dynamic do tipo ExpandoObject. O primeiro objeto será nosso objeto de permissões. Os objetos Sistema1 e Sistema2 serão cada um a permissão e o acesso ao serviço de terceiros.
Na linha 14 nós criamos uma propriedade em Sistema1 e setamos o seu valor para false.
Nas linhas 15 a 21 estamos definindo um método para o objeto Sistema1. Este método verifica se a propriedade PodeAcessar está com o valor true e então executa o corpo do método.
Na linha 22 dizemos que a propriedade Sistema1 do objeto objetoDinamico é do tipo ExpandoObject, e setamos o seu valor atribuindo a ela o objeto Sistema1.
Nas linhas 24 a 32 fazemos as mesmas coisas para o objeto Sistema2.

O resultado pode ser conferido na imagem a seguir:

Resultado ExpandoObject

Uma das desvantagens para quem está acostumado com o Visual Studio é que os objetos dynamic não possuem intellisense. Talvez isso não seja algo ruim, ou talvez seja, depende bastante do cenário em que é utilizado.

Dynamic object intellisense

É isso galera, um outro exemplo do uso de ExpandoObject pode ser visto aqui.

Att,
Vinicius Quaiato.