Phantom DOWNLOAD.

Resolvi publicar um utilitário — inclusive com seu código (Github) — que venho usando à algum tempo em meus projetos .NET, o Phantom.

Phantom é um utilitário que torna fácil fazer reflexão em objetos. Para quem não sabe, reflexão consiste basicamente em trabalhar com objetos sem saber seu tipo, ou seja, chamar seus métodos e propriedades.

Como usa isso?

Para iniciar o uso do Phantom basta adicionar isso na sua classe:

using Phantom;

Simples! Isso faz com que aparece alguns métodos (extension methods) em todos os objetos.

Ok, mas o que eu posso fazer?

Get e set em propriedades, invocar métodos, pegar todas as propriedades e mais em objetos que você nem sabe o Type. Sim, isso é legal!

Vou usar C# nos exemplos. Notem que sempre manipulo object e nunca um tipo especifico.

Pegando (get) valor de uma propriedade

object person = new Person { Name = "Arthur", Age = 4 };

person.Get("Name");

>> Arthur

Atribuindo (set) valor de uma propriedade

person.Set("Name", "Francine");

Pegando todas as propriedades

var properties = person.Values();

foreach(var property in properties)
{
    Console.WriteLine(property.Key + " = " + property.Value);
}

>> Name = Arthur
>> Age = 4

Bom para usar com objetos anônimos

Já falei de objetos anônimos aqui.

public void PrintName(object target)
{
    Console.WriteLine(target.Get("Name"));
}

PrintName(new { Name = "Wagner" });

>> Wagner

Importando valores de outros objetos

object animal = new Animal { Age = 20 };

person.Import(animal);

person.Get("Name");
person.Get("Age");

>> Arthur
>> 20

Invocando um método

object name = "Francine"; 

name.Invoke("ToUpper");

>> FRANCINE

Existem outras utilidades, mas por hoje é só!

Como vocês já devem ter percebido adoro scripts. Gosto de  automatizar algumas tarefas que costumo realizar varias vezes ao dia.

As vezes vou até a página da Globo.com ver o que está acontecendo no mundo. Mas tem muita informação na tela pra quem só corre o olho – e metade é Big Brother (pelo menos quando escrevi isso).

Para me ajudar fiz um script que resume a página da Globo.com pegando apenas suas imagens. Como sempre faço primeiro vou colocar o script e depois explico:

Primeiramente percebe-se que utilizei o Hpricot para fazer parse do HTML. Excelente, diga-se. A variável html serve para concatenar o HTML que o script vai gerar.

Na linha 8 faço uma leitura na página Globo.com, utilizo Hpricot e open-uri para isso. Na linha 10 busco todas as imagens da página. Na linha 11 faço uma verificação na url da imagem para ver se é absoluta (http://www.globo.com/imagem.jpg) ou relativa (/imagem.jpg), transformando todas em urls absolutas para serem visualizadas de fora do servidor da Globo.

Finalizo o HTML que geramos e na linha 17 salvo em um arquivo chamado “Agora.html”. Quem está utilizando o Windows pode descomentar a linha 19, para abrir o Internet Explorer (Eca!) com esse arquivo.

Você pode, facilmente, alterar o script e buscar as imagens de outro portal, como o Terra, por exemplo. Modifique e comente… Até mais.

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 porque 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, afim 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 as 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 oque ele está fazendo:

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 dela 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 parametros possuem valores e concateno o valor relativo a cada propriedade.

Por ultimo 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.

Ao imprimir a data atual com Console.Write(DateTime.Now) temos um resultado mais ou menos assim na tela: 07/04/2009 23:17:25. Isso acontece porque o Console utiliza o método ToString() de qualquer objeto para transformá-lo em caracteres e imprimir na tela. O objeto a ser impresso nesse caso é um DateTime que por sua vez utiliza internamente ToShortDateString() + ” ” + ToLongTimeString().

Quando se está trabalhando com muitas datas – geração de relatórios, por exemplo – fica trabalhoso e feio ficar replicando a mesma formatação de data no código, como: data.ToString(“dd-MM-yyyy [HH:mm]“) diversas vezes. Não seria mais fácil padronizar a saída de data? Isso é fácil!

var customCulture = new CultureInfo("pt-BR");
customCulture.DateTimeFormat.ShortDatePattern = "dd-MM-yyyy";
customCulture.DateTimeFormat.LongTimePattern = "[HH:mm]";

Thread.CurrentThread.CurrentCulture = customCulture;
Thread.CurrentThread.CurrentUICulture = customCulture;

O que eu fiz aí foi criar uma cultura customizável com base na pt-BR. Depois mudei as formatações de data curta e hora longa – justamente as formatações utilizadas por padrão pelo DateTime. Por ultimo é só atribuir essa cultura à thread corrente, o que geralmente abrange toda nossa aplicação.

Agora o método ToString() do DateTime vai utilizar a formatação “dd-MM-yyyy” para data (ToShortDateString) e “[HH:mm]” para hora (ToLongTimeString). Dessa forma podemos imprimir novamente no console que teremos um resultado diferente: 07/04/2009 [23:17].

Código repetitivo dificulta mudanças, gera erros e retrabalho. Portanto devemos sempre buscar alternativas quando isso acontece.

Não quero fazer uma abordagem muito técnica para explicar esse protocolo. Vou fazer isso com analogias para que todos possam entender, desde o desenvolvedor WEB – infelizmente alguns não tem nem idéia do que faz o HTTP – até sua avó. Ta bom, a sua avó talvez terá dificuldades.

Protocolo, para esse caso, é um padrão de escrita para que periféricos se entendam. Imagine que dois computadores, projetados por engenheiros que jamais se viram na vida, precisam se “entender”. Como fazer isso? Criando padrões. Na nossa própria linguagem do dia-a-dia temos diversos padrões estabelecidos. Sempre que alguém diz “tchau” você entende que a conversa acabou, isso é um padrão, um protocolo.

Ta, mas e o HTTP? Esse é um protocolo de comunicação de hypertexto, esse nome estranho nada mais é do que uma página na internet. Seu email e portal de fofocas preferido são hypertextos.

Na pratica funciona assim: Quando você digita um endereço no navegador ele precisa enviar alguma coisa para algum lugar dizendo que você quer ler alguma coisa. Imagine que você digitou o endereço do Google. Seu navegador prepara uma carta, isso mesmo, literalmente uma carta para o servidor onde fica o site do Google. O conteúdo dessa carta é mais ou menos isso:

Host: www.google.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; pt-BR; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6 (.NET CLR
3.5.30729)
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: pt-br,pt;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive

Não se apegue aos códigos, como já disse isso são apenas padrões. Esses padrões em especifico são conhecidos como HTTP. Se você não entende é porque não tem muito contato com esse tipo de linguagem, e se não é um desenvolvedor WEB não há problema algum. O importante nessa carta é o seguinte:

Bom dia Google.com,

Gostaria de ler sua página.
Estou usando o navegador Firefox na versão 3.0.6.
No momento eu aceito HTML.
Gostaria de receber o conteúdo em português, mas também entendo inglês.
Uso o padrão de caracteres (letras) ISO-8859 e UTF-8.

Seu navegador vai envelopar essa carta e enviar ao servidor do Google, que você solicitou (um dia falarei sobre TCP e outros protocolos que seriam esse envelope). Essa carta é tecnicamente conhecida como Request HTTP.

Esse servidor vai ler sua carta, porque ele lê TODAS as cartas que chegam, diferente do Papai Noel. Com base nas solicitações feitas na carta, o Google vai criar a resposta:

Location: http://www.google.com.br/
Cache-Control: private
Content-Type: text/html; charset=UTF-8
Date: Mon, 08 Feb 2009 22:00:00 GMT
Server: gws
Content-Length: 222
...

O Google está dizendo o seguinte:

Olá,

Aqui é o Google.com.
Estou enviando a página que pediu.
Você pode guardar as informações em seu computador e usa-las em outras visitas.
Estou enviando apenas texto e HTML como você pediu.
Essa carta foi feita as 22:00 horas do dia 08/02/2009 utilizando servidor GWS.
O conteúdo é formado por 222 letras, segue:
...

Coloquei três pontinhos substituindo o conteúdo da página. Esse conteúdo é um pouco mais extenso, mas não é nada de outro mundo. Nada mais é do que a forma codificada do que você vê no navegador. Essa carta de resposta também é conhecida como Response HTTP.

Claro que eu abordei de forma simplista, há muito mais o que se falar sobre esse protocolo e isso vou fazer em outros artigos. O próximo será um pouco mais técnico e sua avó realmente não vai entender. Falarei sobre Cookie e Sessão. Para saber mais detalhes e dar uma treinadinha no inglês técnico nada melhor do que a especificação oficial do HTTP, aqui.

Espero que tenha ficado um pouco mais claro, tanto para desenvolvedores quanto para usuários da internet. E que as avós hi-tech me desculpem!

Na última sexta-feira (06/02) publiquei meu primeiro artigo no iMasters. Para mim é uma grande honra colaborar com um portal que é tão importante para os profissionais brasileiros na área da internet. Espero que essa parceria dure bastante tempo e que seja bem aproveitada por todos.

No mais, sigo escrevendo, respondendo e principalmente ouvindo sugestões e aprendendo. Obrigado.

O Windows XP é um excelente sistema, mas já está ultrapassado e o tiu Balmer até quer tirá-lo das lojas. Compare com os jogos que saíram no mesmo período, Outubro de 2001, e as mesmas franquias agora em 2009. Nossa, que diferença! Precisamos de um novo sistema da plataforma Microsoft. Baixei o novo Windows com preconceitos pelas ultimas investidas deles em sistemas operacionais para usuários finais – sem citar nomes – mas no fundo esperançoso.

Queimei o DVD, abri o Boot Camp, partição de 40GB para a Microsoft, coloquei o DVD, reiniciou, bonito design do instalador… na hora de selecionar a partição de instalação já tive o primeiro problema: o Boot Camp criou uma partição FAT32 e o W7 precisa de NTFS.

Aí já me deu medo. Não preciso dizer o quão problemático é a manipulação de partições na instalação do Windows. E esse sistema ainda é Beta, mas esse não é meu computador Beta! Mas tive uma grata surpresa, foi simples e fácil. Não sei se minha mãe faria porque não tem a menor ideia do que é partição, mas é só clicar em alguns botões e está tudo pronto, partição formatada. Não precisei apertar L, D, C, F3, Scroll Lock ou qualquer outro botão que meu Macbook nem tem.

Depois disso só foi esperar ele instalar, respondi algumas perguntas como nome do usuário e outras configurações bem explicadas e comecei a usa-lo sem nenhum problema. Desliguei o note apenas antes de dormir, aí percebi que não precisei reiniciar nenhuma vez depois do termino da instalação. Se tratando de Windows isso é demais! Estava acostumado a instalar o XP e reiniciar várias vezes, até pra colocar o mouse… ta bom, exagerei no mouse. Não cheguei a usar o Boot Camp pra Windows, fiquei com preguiça de baixar a versão pra Vista que não vem no CD do Leopard.

No fim, a instalação do Windows 7 em um Macbook foi bem tranquila. Não vou fazer analise das melhorias do sistema, prós e contras, isso é fácil de achar. Se estão curiosos sugiro que instalem o Windows 7, é uma bela surpresa.

A boa noticia é que encontrei um conversor de temas do Textmate para temas do Intype, peguei o tema do Github que uso no Textmate e fiz a conversão. Ao contrário do que eu esperava, o resultado ficou muito bom. Criei um repositório no Github para manter esse tema atualizado.

Para utilizar basta fazer o download lá do repositório, pegar o arquivo GitHub.itTheme, copia-lo para o diretório themes do Intype e reiniciar o editor.

Falando um pouco mais nesses editor, não uso a ultima versão estável, uso a ultima versão instável que foi disponibilizada (download da versão Unstable 0.3.1.734). Essa versão conta com árvore de projetos, que já é uma “mão na roda” pra quem programa em Rails, principalmente.

Nada como um bom tema para nos sentir mais a vontade escrevendo nossos códigos – bem coisa de nerd mesmo. Até mais!

Extension Methods é um recurso que quem costuma trabalhar em linguagens de script, como Ruby, já está mais acostumado. Consiste em “inserir” métodos em objetos já compilados, como uma string, por exemplo. Sim, esqueça a sua classe StringHelper ou StringUtil, agora os métodos utilitários que você sempre quis poderão ser inseridos diretamente na fonte.

Vamos à prática, primeiro vou mostrar como um extension é declarado, depois o exemplo de uso. Vou fazer um exemplo que não é tão útil, mas a intenção aqui é apenas mostrar a funcionalidade.

Imaginemos que temos URLs em formato de string na nossa aplicação e precisamos ter o conteúdo destas URLs. Vou criar um extension no objeto string que lê essa URL e retorna o seu conteúdo. Vamos à implementação:

Agora o exemplo de como utilizar o método que criei:

string responseBody = "http://www.google.com".ReadUrl();

É fácil criar um extension. Primeiro precisamos de uma classe e um método static. O método extension tem uma peculiaridade, o primeiro parâmetro possui a palavra chave this seguido pelo objeto no qual o extension será “inserido”. A partir deste parâmetro, os subsequentes serão efetivamente utilizados na chamada do método. Esse primeiro parâmetro é muito importante, perceba que ele representa a instancia do próprio objeto. No exemplo, a string responseBody vai ter o conteúdo HTML da página inicial do Google.

À primeira impressão parece uma implementação complicada, mas nada mais que alguns minutos serão necessários para se familiarizar com isso.

Eu sempre fui fã das linguagens mais dinâmicas, e nessa característica as linguagens de script são a Disney. Esse recurso adicionado ao C# 3.0 nos dá flexibilidade para criar métodos que vão organizar bastante o nosso código. Em breve coloco mais artigos sobre .NET.

Para retomar os artigos de códigos rápidos e úteis – nem sempre tão úteis – utilizando Ruby (os Snapshots) vou mostrar como fazer um “cronometro” de código. Calma, vou explicar melhor.

Antes de iniciar quero lembrar a existência do modulo Benchmark, que é o mais indicado a ser utilizado neste caso. Levamos em conta então que esse post servirá apenas para estudo.

Muitas vezes quero saber quanto tempo um determinado trecho de código leva para ser executado, assim posso fazer otimizações bem focadas em determinadas linhas.

Ruby é uma linguagem que torna simples a manipulação de blocos de código, por isso criaremos um método que receberá um determinado código que alem de executar essas instruções passadas dirá quanto tempo levou para fazer isso. Seu funcionamento é bem simples, mostrando apenas o tempo real que o código levou para ser executado, não é 100% preciso, mas em linhas gerais é bem eficiente. Segue o método:

Primeiro ele verifica se foi passado o bloco de código que vai ser “analisado”. Em seguida o tempo inicial é armazenado, o código é executado (yield) e por fim diminui-se o tempo inicial do tempo no momento em que o código termina de ser executado. É impresso na tela a identificação do teste (para os casos de haver mais de um) junto com o tempo que o código levou para ser executado, em segundos.

Para testar o método usei o sleep, que faz uma interrupção no código durante um determinado tempo, no caso 318 milissegundos. Ao rodar esse teste é possível notar que nunca dá 318 milissegundos no bechmark. Isso porque os métodos sleep e o bechmark não são exatos.

É possível fazer diversas melhorias nesse método, o que é um bom exercício para estudar a linguagem. Qualquer sugestão é bem vinda.