Quando a Microsoft anunciou os tipos anônimos (Anonymous Types) eu fiquei bastante contente, era possível criar tipos rapidamente de uma forma muito fácil. Para quem ainda não conhece essa nova funcionalidade aqui vai o link.

Olhando a sintaxe de construção de um tipo anônimo logo associei aos arrays associativos das linguagens de script, conhecidos como Hash. O C# sempre teve o objeto Hashtable, mas não é flexível comparando com linguagens como Ruby ou Javascript. Só pra exemplificar o que estou dizendo:

No Ruby posso chamar um método passando um hash como parâmetro, sintaxe bastante utilizada no Ruby on Rails, dessa forma:

link_to("Profile", :controller => "profiles", :action => "show")
link_to("Profile", :controller => "profiles", :id => @id)

Nas duas linhas de exemplo os dois últimos itens formam uma Hashtable, no caso do Ruby se chama Hash. Do lado do método também fica fácil de capturar o que foi passado. Com tipos anônimos do C# podemos fazer uma sintaxe bem próxima, que ficaria assim:

LinkTo("Profile", new { Controller = "profiles", Action = "show" });
LinkTo("Profile", new { Controller = "profiles", Id = id });

Mas por que utilizar essa forma de passar parâmetros?

É elegante e limpo em alguns casos. Alguns métodos realizam funções onde é necessário informar MUITOS parâmetros para que se tenha um bom nível de customização da ação que será realizada. E como alguns parâmetros são opcionais acabamos tendo que criar várias sobrecargas para o mesmo método, a fim de facilitar a vida de quem vai usar.

No exemplo acima estamos utilizando um método cria um link HTML em um ambiente MVC. Como são muitos parâmetros (texto, controller, action, style, class, id, querystring) e raramente usaremos todos, utilizamos um tipo anônimo para informar os parâmetros "opcionais". Assim não precisaremos encher a nossa classe com sobrecargas do método LinkTo.

Outro ganho que temos é na hora de adicionar mais um parâmetro ao método. Adicionamos no tipo anônimo e não precisamos alterar as chamadas na aplicação inteira. Mesmo com refactoring isso às vezes é problemático.

Ok! Agora, como crio meu próprio método?

Para ver como funciona vamos implementar um método que cria links, parecido com o que exemplifiquei antes. Primeiro veremos como fica o método que vou chamar de "CriaLink", depois explico o que ele está fazendo:

public static object GetPropertyValue(this object obj, string propertyName)
{
    try
    {
        return obj.GetType().GetProperty(propertyName).GetValue(obj, null);
    }
    catch
    {
        return null;
    }
}

public string CriaLink(string titulo, object parametros)
{
    var para = (string) parametros.GetPropertyValue("Para");
    var descricao = (string) parametros.GetPropertyValue("Descricao");
    var borda = (int?) parametros.GetPropertyValue("Borda");

    var linkBuilder = new StringBuilder();

    linkBuilder.Append("<a");

    if(!String.IsNullOrEmpty(para))
    {
        linkBuilder.AppendFormat(" href='{0}'", para);
    }

    if(!String.IsNullOrEmpty(descricao))
    {
        linkBuilder.AppendFormat(" title='{0}'", descricao);
    }

    if(borda != null && borda > 0)
    {
        linkBuilder.AppendFormat(" style='border: {0}px solid silver'", borda);
    }

    linkBuilder.AppendFormat(">{0}</a>", titulo);

    return linkBuilder.ToString();
}

CriaLink("Google", new { Para = "http://www.google.com", Descricao = "Clique aqui para acessar o Google.", Borda = 2 });
// <a href='http://www.google.com' title='Clique aqui para acessar o Google.' style='border: 2px solid silver'>Google</a>

CriaLink("Globo", new { Para = "http://www.globo.com", Borda = 2 });
// <a href='http://www.globo.com' style='border: 2px solid silver'>Globo</a>

CriaLink("Home", new { Para = "/Index.html", Descricao = "Voltar para a página inicial." });
// <a href='/Index.html' title='Voltar para a página inicial.'>Home</a>

Criei um extension method de nome GetPropertyValue na classe Object para quem não sabe do que se trata extension methods falei sobre isso aqui. Esse método busca o valor da propriedade de qualquer objeto passando apenas seu nome. Isso vai ser muito útil para tratar os tipos anônimos.

Já na implementação do método "CriaLink" primeiramente busco os valores das possíveis propriedades atribuídas ao tipo anônimo passado por parâmetro, que é do tipo Object porque não é possível prever um tipo anônimo. O método GetPropertyValue já se responsabiliza por saber se existe ou não a propriedade, no caso de ela não existir o resultado é null.

Depois fica mais simples. Apenas criei uma StringBuilder para concatenar a tag de link que vou criar. Testo se as variáveis provenientes dos parâmetros possuem valores e concateno o valor relativo a cada propriedade.

Por último, mostro como podemos utilizar o método que criamos e o resultado obtido.

Já falei aqui o quanto sou fã da flexibilidade das linguagens de script. O C# tem incorporado algumas funcionalidades dessas linguagens e, mesmo assim, ao contrário do que eu imaginava, consegue manter sua característica de ser fortemente tipado. Temos que aproveitar isso e tornar nosso código mais inteligente.

Espero que tenham gostado e qualquer duvida ou sugestão é só entrar em contato ou comentar aqui mesmo. Até mais.