O dia começou cedo, aproveitei uma hora para fazer um hands-on lab com a Web Service Software Factory. Como acontece com outros, nem sempre se explica o raciocínio de cada passo, mas o essencial da criação dos tipos, mensagens, os contratos, etc., está bem explicitado.
Depois disto, fui à sessão de C# 3.0 do Anders Hejlsberg, criador do C#, Linq, etc. Já tinha visto a sessão antes, mas vale sempre a pena. Começou com uma perspectiva histórica: a primeira versão, com a .Net Framework 1.0, já tem quase 8 anos desde que começou a ser pensada, a primeira abordagem a Managed Code. Na versão 2.0, fez-se tudo que se queria ter feito na anterior mas não houve tempo, com grande destaque para os generics. Na versão 3.0, que aí vem, é onde se tem finalmente espaço para inovar, muito baseado nos alicerces mais sólidos da 2.0.
Os objectivos de design do 3.0 são/eram:
- Integrar objectos, dados relacionais, e Xml
- Tornar a linguagem mais consisa
- Adicionar potencialidades de linguagens funcionais (como lamba expressions)
- Não fazer a linguagem dependente de API's específicas
- 100% retro-compatibilidade
Quais as novidades, então?
- Local variable type inference – conveniência sintática que permite não ter de repetir o tipo que está a ser declarado, usando a keyword var. Exemplo: var d = new Dictionary<int, Order>(); em vez de Dictionary<int, Order> d = new Dictionary<int, Order>();Notar que a variável d é strongly-typed, a novidade trata-se de mera conveniência sintática.
- Extension Methods - possibilidade de adicionar métodos a quaisquer classes existentes, como se lhes pertencessem. Isto evita termos de fazer métodos estáticos para adicionar funcionalidade. Exemplo: em vez de public static string MyContactenate(string s1, string s2), podemos fazer: public static string MyConcatenate(this string s1, string s2); e agora podemos chamar desta forma: s1.MyConcatenate(s2);
Mais uma vez, trata-se de uma conveniência sintática, mas muito interessante.
- Lamba Expressions – durante a licenciatura aprendi uma linguagem funcional chamada ML, em que reinam coisas chamadas lamba expressions. Apesar do aspecto relativamente académica, é um mecanismo muito interessante e poderoso em várias situações (convido-vos a investigar). O C# 3.0 inclui expressões lamba, que permite fazer coisas como: customers.FindAll(c => c.PostalCode == 1000). A lamba expression aqui seria algo como ?c.c.PostalCode == 1000 . Pouco intuitivo talvez, mas muito poderoso.
- Object Initializers – fácil de explicar com um exemplo. Consiste na possibilidade de inicializar objectos com invocações implícitas a propriedades: Ponto p = new Ponto{X=100, Y=50}; , em que X e Y são propriedades da classe P. Outra conveniência sintática.
- Collection Initializers – parecido com o anterior, ilustrado mais uma vez com um exemplo: List<int> = new List<int> (10, 100, 20, 40);
- Query Expressions – talvez o aspecto mais visível do C# 3.0, quando se investiga o Linq (Language Integrated Query), consiste na possibilidade de escrever "statements" de acesso a dados como se fossem Sql em C#, para aceder a arrays, xml's, bases de dados, etc. (qualquer coisa que suporte IEnumerable<T>). Este tema é enorme, e recomendo a todos que investiguem o assunto. Mais uma vez, são uma conveniência sintática, uma vez que os Select/Where/GroupBy são convertidos para invocações a métodos antes da compilação para IL.
- Anonymous Types – usado, por exemplo, quando se faz uma query à BD e se devolvem apenas 2 dos campos de uma tabela. É criado um tipo automaticamente, strongly-types, para guardar o resultado. Exemplo: select new { Name = p.Name, Address = p.Address }; cria um tipo anónimo (sem nome...) com 2 campos do tipo string.
- Expression Trees – quem conhece desenvolvimento de compiladores e análise sintática de expressões adivinha rapidamente o que isto é. A referência é a classe Expression<T> e o namespace System.Expressions .
- Automatic Properties – outra conveniência sintática, permite criar automaticamente properties, da seguinte forma: public string Name { get; set; } cria a variável privada e métodos set e get.
A sessão teve algumas demos de Linq, impressionantes como sempre, e que podem tb ser vistas no Channel9 (vejam tudo o que está lá com o Anders). Foi uma boa sessão. A questão que se levanta é: todos estes mecanismos vão mesmo ser usados, de forma generalizada? Coisas como Lamba Expressions e o Query Expressions são poderosas, mas não são de compreensão imediata. Logo se verá, afinal ainda vamos no 2.0 . J
[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/joaomartins e http://blogit.create.pt/blogs/joaomartins]