Atenção: esse artigo tem uma palestra complementar. Clique e assista!

Atenção: esse artigo tem um vídeo complementar. Clique e assista!

Até o ano de 2002, a principal linguagem de desenvolvimento da Microsoft foi o Visual Basic, uma linguagem de desenvolvimento de aplicações Windows, adaptada originalmente da linguagem BASIC criada na década de 60.

Até então, era possível criar aplicações Windows com o Visual Basic através de uma ferramenta chamada Visual Studio. É claro que essa não era a única opção, tínhamos na época dezenas de outras ferramentas e linguagens de desenvolvimento (a maioria existe até hoje), como por exemplo: Delphi, Visual Fox Pro, Visual C++, Visual J++, C++ Builder, JBuilder, só para citar as mais populares.

Nessa época uma linguagem que já vinha ganhando bastante popularidade era o Java da Sun Microsystems, com o seu apelo de linguagem Orientada a Objeto e Multi-Plataforma. Além disso, também existia uma crescente demanda para o desenvolvimento de aplicações Web.

Visual Studio 2002 / .NET Framework 1.0

Foi nesse cenário que surgiu em fevereiro de 2002 a primeira versão oficial da plataforma .NET Framework. O .NET Framework 1.0 e Visual Studio 2002 (code-nome Rainer). Nasceu então a nova plataforma de desenvolvimento da Microsoft, com potencial e recursos necessários para oferecer os benefícios da orientação a objetos e o desenvolvimento de aplicações Web.

Porém, esse primeiro release da então nova plataforma de desenvolvimento da Microsoft foi pouco conhecido e utilizado, e logo deu lugar ao: Visual Studio 2003 / .NET Framework 1.1

Visual Studio 2003 / .NET Framework 1.1

Isso foi apenas um ano depois, em Abril de 2003, quando foi o lançamento desta versão, que levou o code-nome Everett. Essa sim foi uma versão amplamente utilizada pela comunidade (até hoje ainda tem gente que dá manutenção em projetos feitos no Visual Studio 2003).

Uma característica que marcou muito o início da plataforma .NET foi a sua compatibilidade com diversas linguagens de desenvolvimento. Desde o começo, o .NET ofereceu ao desenvolvedor a possibilidade de utilizar quatro linguagens: Visual Basic.NET, o novíssimo C#, C++ e uma versão da Microsoft para o Java, chamada J#.

O J# surgiu como uma opção da Microsoft para a criação de aplicações na plataforma .NET utilizando a sintaxe Java. O que seria uma ótima escolha para programadores acostumados com o VJ++, que quisessem migrar para o .NET Framework.

Além disso, a plataforma .NET veio com a ideia de que outras organizações pudessem criar ou adaptar suas linguagens para a plataforma, respeitando o Common Language Specification ou CLS.

O CLS é um conjunto básico de regras que toda linguagem que pretende ser compatível com o .NET deve seguir. Isso garante que a linguagem possa compilar seu código em uma linguagem neutra da plataforma, chamada Common Intermediate Language(CIL).

E é aí que entra o Common Language Runtime (CLR). É o CLR que vai compilar o código CIL em linguagem de máquina, compatível com o Sistema Operacional em que a aplicação está executando (Veja na Figura 1 uma ilustração desta dinâmica do .NET).

O CLR é para o .NET a mesma coisa que o Java Virtual Machine é para o Java. E foi na versão 2.0 da plataforma que tivemos a última versão do CLR.

Figura 1. Esquema de como funciona a compilação na plataforma .NET

Visual Studio 2005 / .NET Framework 2.0

Foi em Outubro de 2005 que a Microsoft lançou mais uma versão da plataforma, o .NET Framework 2.0 com o Visual Studio 2005 (code-nome Whidbey). Muita coisa foi melhorada nessa versão, tanto que as versões seguintes continuam usando “partes” do .NET 2.0, inclusive o CLR citado anteriormente.

Foi provavelmente a partir da versão 2.0 do .NET, e do Visual Studio 2005, que o desenvolvimento de aplicações Web foi amplamente popularizado. Muita gente migrou de suas antigas linguagens para o Visual Studio 2005 só para aprender e utilizar o ASP.NET.

O ASP.NET já existia na versão anterior, mas foi no .NET 2.0 que as coisas começaram a ficar mais simples. Muitas ferramentas e recursos surgiram para facilitar ainda mais o acesso ao banco de dados, e a criação de interfaces Web para interagir com Datasources. Criar aplicações Web com o ASP.NET ficou ainda mais fácil.

E antes de surgir uma nova versão da plataforma, a Microsoft lançou o ASP.NET AJAX, como um pacote a ser instalado e utilizado na versão 2.0 da plataforma. Isso aumentou ainda mais a qualidade das aplicações Web desenvolvidas com ASP.NET, materializando os benefícios da Web 2.0.

.NET Framework 3.0

Mas não demorou muito e já tivemos uma nova versão da plataforma. Foi no lançamento do Windows VISTA, onde surgiu mais uma versão do Framework, a 3.0.

Essa versão foi marcada pela inclusão das tecnologias: Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation e Windows CardSpace. Apesar de não ter sido lançado um novo Visual Studio, foi possível utilizar essas tecnologias através de pacotes que eram instalados na versão 2005, similar ao que aconteceu com o AJAX.

Como citado anteriormente, o .NET 3.0 não substituiu o 2.0, tanto que os dois convivem harmoniosamente instalados aí no seu Windows, junto também com o .NET Framework 3.5.

Visual Studio 2008 / .NET Framework 3.5

Em Novembro de 2007 foi o lançamento do .NET Framework 3.5 e do Visual Studio 2008 (code-nome Orcas). Essa é a versão atual e com a qual a maioria dos desenvolvedores .NET está trabalhando hoje.

Ela foi marcada principalmente pela introdução da linguagem LINQ, e por permitir uma fácil migração de projetos feitos na versão anterior.

Em menos de um ano, em Agosto de 2008, tivemos o lançamento do Service Pack 1 do .NET 3.5, que incrementou ainda mais essa última versão, trazendo: ADO.NET Entity Framework, ADO.NET Data Services, ASP.NET Dynamic Data, entre outras coisas.

Mas não deu dois meses depois do Service Pack 1, a Microsoft já anunciou que estava planejando e desenvolvendo a versão 4.0 do .NET Framework, e o Visual Studio 2010. E é esse o tema deste artigo que você lê agora.

Haja fôlego para acompanhar tudo isso de perto!

Visual Studio 2010 / .NET Framework 4.0

Obviamente, antes de mais nada, gostaria de dizer que tudo o que você ler aqui a respeito das novidades do .NET 4.0 e Visual Studio 2010, poderá sofrer modificações até o dia do lançamento do produto.

Como você já deve ter ouvido falar por aí, são muitas as novidades da plataforma. Essa talvez seja a versão com mais novidades desde a 2.0. Tanto, que agora teremos uma nova versão para o CLR, e a introdução da DLR (Dynamic Language Runtime), que veremos em maior detalhes adiante.

Se você quiser ter uma visão mais detalhada dos recursos, pode acessar um pôster das novidades da versão no estilo DeepZoom, através deste link aqui: http://tinyurl.com/DotNetFramework4PosterDeepZoom, ou baixar uma versão PDF em alta definição, neste outro link aqui: http://tinyurl.com/PDC2008-NETFX4PDF. Basicamente, o Universo .NET foi dividido em seis partes:

· CORE (São os namespaces que representam o núcleo do Framework)

o Aqui podemos ver a inclusão de recursos para computação paralela, o que realmente estava faltando no Framework, principalmente para atender a crescente demanda de processadores com dois ou mais núcleos.

o O próprio LINQ ganha um ParallelEnumerable, que permitirá a execução de queries em ambientes de processamento paralelo. Isso nada mais é que a inclusão do projeto PLINQ na plataforma.

o System.Xaml: o XAML ganha um namespace próprio que irá conter seus principais recursos. Similar ao que temos no System.XML para XML. Mostrando que o WPF e o Silverlight ganham um papel de destaque no núcleo da plataforma.

· Web (ASP.NET) :

o ASP.NET Web Forms 4.0 com foco no desenvolvimento client-side.

o Uma nova e reformulada versão do AJAX, chamada de 4.0, também com foco voltado para o desenvolvimento client-side.

o A inclusão do ASP.NET MVC Framework, que recentemente foi lançada como um pacote separado.

o O lançamento de uma biblioteca para gráficos no ASP.NET, que estará no namespace: System.Web.UI.DataVisualization.Charting.

· Client (Nosso antigo Windows Forms e o WPF):

o Introduz recursos para interfaces que trabalham com monitores multi-touch.

o Controles para criar interfaces baseadas no padrão Ribbon, popularizado na versão 2007 do Office.

· Communication:

o O WCF (Windows Communication Foundation) está aqui reformulado e leva o nome de Communication.

· Workflow:

o O mesmo acontece com o WF (Workflow Foundation), que além do nome novo, virá todo reformulado.

· Data:

o Nosso querido ADO.NET com várias novidades, inclusive com uma nova versão do ADO.NET Entity Framework, que promete agora ser um concorrente à altura do NHibernate.

Além desses pontos que estão evidentes, há uma enorme expectativa quanto às novas linguagens que agora terão suporte no .NET: IronPhyton, IronRuby e F#. Assim como os recursos de linguagem dinâmica que virão no C#, e na framework como um todo, com a inclusão do já citado DLR.

No Visual Studio também temos novidades marcantes, que podem ser observadas principalmente pelo fato de ele agora ser desenvolvido em WPF. Isso significa que teremos várias funcionalidades gráficas que ajudarão ainda mais o nosso dia-a-dia como desenvolvedores.

Veremos a maioria dessas novidades no decorrer do artigo. É claro que fica difícil falar em detalhes de todas, mas com certeza veremos as principais.

Baixando e Instalando a versão Beta 1

Antes de iniciar qualquer procedimento de download, é importante que você saiba que a versão baixada neste exemplo foi a que a Microsoft disponibilizou em Maio de 2009.

Além dessa versão Beta, desde Outubro de 2008 é possível baixar uma versão CTP (Community Technology Preview) no formato de máquina virtual, mas que não possui nem metade das novidades que temos nesta versão Beta.

Então, se você tem intenção de verificar essas funcionalidades na prática, tenha certeza de que está baixando a versão Beta e não a CTP. Além disso, por favor, não instale essa versão Beta em sua máquina de desenvolvimento. De preferência utilize uma máquina virtual, ou algum equipamento que possa ser utilizado exclusivamente para isso.

Versões CTP ou Beta de um produto são lançadas com o objetivo de coletar feedback da comunidade. Com elas você pode testar e avaliar aquilo que eles estão planejando para a versão final, podendo inclusive fazer suas críticas e sugestões.

Através do site oficial do Visual Studio (http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx) você tem acesso a todas as possíveis edições da versão Beta 1 do Visual Studio 2010 e .NET Framework 4.0.

Para este artigo iremos utilizar a conhecida edição Professional, que pode ser instalada sob demanda (pela internet) através deste link aqui: http://go.microsoft.com/fwlink/?LinkId=147408. Basta baixar este executável que tem cerca de 5.2MB, e executá-lo, no computador ou máquina virtual onde você vai realizar os testes.

É importante que você tenha acesso à internet, pois a instalação é feita inteiramente sob demanda, e irá levar um bom tempo (também existe versão disponível para download). Com a instalação do Visual Studio 2010 Beta, o .NET Framework 4.0 Beta já é instalado automaticamente.

Visual Studio 2010 em WPF

Se você chegou até aqui, conseguiu baixar e instalar a versão Beta, basta agora executar o Visual Studio 2010, que estará disponível no menu Start do seu Windows.

Ao abrí-lo, como não poderia ser diferente, a primeira tela que temos é a Start Page. Você vai notar que tanto a Start Page quanto todo o ambiente do Visual Studio, está todo reformulado em WPF, veja na Figura 2.

Note que agora as seções da Start Page estão divididas por um menu lateral. Em Welcome temos acesso ao material de apoio do Beta, e também aos Fórums onde podemos dar nosso feedback sobre a nova versão da plataforma.

Em Projects podemos criar novos projetos, abrir os já existentes ou acessar os mais recentes. Este último veio com alguns recursos legais, como a possibilidade de remover um item da lista, ou mantê-lo permanentemente (veja na própria Figura 2).

Em Visual Studio temos acesso ao MSDN Library, mais fóruns, recursos do MSDN, e acesso aos Settings do Visual Studio. E as últimas notícias do MSDN aparecem agora lá embaixo, em um banner.

Mas o mais interessante dessa Start Page é que ela é um arquivo XAML aberto, que podemos customizar. Você pode, por exemplo, criar uma nova opção de Menu aí do lado, com informações e recursos específicos para a sua equipe de desenvolvimento.

Lá na sessão Welcome você tem uma opção chamada Customize the Start Page, que lhe direciona a um artigo do time de desenvolvimento do Visual Studio, que só trata deste assunto: http://blogs.msdn.com/vsxteam/archive/2009/05/20/visual-studio-2010-beta-1-start-page-customization.aspx.

Ao pedir para criar um novo projeto, lá na sessão Projects, você vai ver mais novidades em WPF. Veja na Figura 3, que a página para criação de novos projetos também está de cara nova. Note que ainda podemos escolher qual será o Framework utilizado na criação do projeto, agora com a versão 4.0 disponível.

Ainda nesta janela temos mais informações sobre o template selecionado, que são exibidas do lado direito. No lado esquerdo nossos templates estão agora classificados em três opções: os mais recentes; os templates instalados; e a novidade que são os templates Online. Veja no exemplo da Figura 4 que vamos ter acesso à templates que estarão disponíveis na Web. Isso sugere uma forma de colaboração de templates de projetos muito interessante.

E finalmente, ao criarmos um projeto novo, podemos ver como fica a cara do nosso querido Visual Studio feito agora em WPF, veja aqui na Figura 5. Note que as coisas continuam nos mesmos lugares (ainda bem né). As diferenças aqui estão essencialmente no visual gráfico.

Figura 2. Nova Start Page no Visual Studio 2010

Figura 3. Nova Janela de New Project

Figura 4. Templates Online

Figura 5. Ambiente do Visual Studio 2010 em WPF

Quatro pequenas e úteis novidades do Visual Studio 2010

O WPF não está presente só na Start Page e nas características gráficas do Visual Studio, você poderá vê-lo em ação no lugar mais comum do Visual Studio, no editor de código.

Abra a solution DinnerNow – Web, que está aí na lista de projetos recentes. Em seguida abra uma classe qualquer. Com o mouse posicionado sobre o código, pressione a tecla CTRL e mova o botão de scroll do mouse. Você verá que é possível aumentar e diminuir o tamanho do texto apenas com esse movimento (veja na Figura 6).

Figura 6. Aumentando ou diminuindo o Zoom do código-fonte

Mas também existem novidades no editor de código que vão além do WPF. Veja por exemplo, que se você marcar qualquer elemento do código (classe, objeto, método, propriedade etc.), todas as referências deste elemento serão destacadas na janela de código que está aberta. E você pode navegar entre essas referências através da tecla de atalho CTRL+SHIFT+Seta Abaixo. Confira na Figura 7.

Figura 7. Encontrando e navegando pelas referências de um elemento no código

Outra novidade é que se você clicar com o botão direito sobre um método, vai encontrar a opção View Call Hierarchy, que exibe a estrutura hierárquica de chamadas, a partir do método em questão. Veja um exemplo na Figura 8.

Figura 8. Hierarquia de chamadas a partir do método selecionado

Essa hierarquia é uma ótima forma de identificarmos rapidamente onde o método é chamado, e que chamadas este método realiza em outras partes do projeto. Seria algo semelhante à opção Find All References que já existe, porém com informações muito mais completas das chamadas, e com a possibilidade de navegarmos nessa estrutura.

E por fim, a novidade mais simples e útil de todas, (e que sinceramente, já deveria existir desde a primeira versão), o Quick Search.

Sabe aqueles projetos com centenas de itens, onde perdemos um precioso tempo na Solution Explorer, só procurando pelo item que precisamos abrir? Pois é, agora no Visual Studio 2010 vamos ganhar um Quick Search que vai simplificar e muito essa tarefa.

Basta estar com alguma janela de código aberta e utilizar o atalho: CTRL + , (sim, é CTRL + vírgula). Isso irá chamar a janela de Quick Search, que como você pode conferir na Figura 9, irá buscar qualquer item do projeto que satisfaça a condição textual.

Figura 9. Exemplos de QuickSearch

Note que além de uma pesquisa textual simples, podemos fazer uma pesquisa apenas das letras maiúsculas utilizadas no padrão de nomenclatura CamelCase. Veja que só a utilização das siglas como UG irá trazer como resultado da pesquisa o método UpdateGrupos. Ao Selecionar o item desejado e clicar em OK, será aberto o arquivo onde o item selecionado se encontra.

Extensibilidade do Editor de Código

Essas foram apenas algumas inovações que foram adicionadas ao Editor. Mas a grande novidade no ambiente de desenvolvimento do Visual Studio 2010 está na sua extensibilidade. Essa palavra estranha significa que você terá a possibilidade de customizar o seu ambiente, da maneira que lhe for mais conveniente. E quando dizemos ambiente, também estamos falando dos recursos que temos disponível no editor de códigos da ferramenta.

O assunto “extensibilidade” é bem amplo e merece um artigo a parte. Ele não é totalmente novo, pois já é um conceito que vem sendo amadurecido no decorrer das versões do Visual Studio. Você pode inclusive, conferir uma área do site do MSDN só sobre extensibilidade do Visual Studio: http://msdn.microsoft.com/en-us/vsx/default.aspx.

E quando o assunto é extensibilidade não podemos deixar de falar no MEF. MEF é a sigla de Managed Extensibility Framework, que é um projeto da Microsoft em desenvolvimento e de código aberto. Você encontra o MEF no Codeplex: http://mef.codeplex.com/

O MEF vem com o objetivo de, entre outras coisas, facilitar o desenvolvimento de aplicações que estendem funcionalidades do Visual Studio. Então, se você se interessa no assunto Extensibilidade, o MEF é parada obrigatória.

ASP.NET WebForms 4.0: ClientIDMode

Ultimamente muito tem se falado sobre o ASP.NET MVC, que foi recentemente lançado. Para quem não conhece, o ASP.NET MVC é a Framework da Microsoft para a implementação do padrão MVC no ASP.NET.

Apesar de ele ser parte integrante da versão 4.0 do ASP.NET, não vou falar muito sobre ele aqui. Nesta mesma edição temos um artigo inteiro só sobre ele.

Mas o fato de eu estar citando o ASP.NET MVC, é devido à polêmica que ele tem gerado desde da época do seu desenvolvimento.

O ASP.NET MVC dá ao desenvolvedor um maior controle sobre o código HTML que sua aplicação deve gerar no cliente. Além disso, ele permite uma implementação muito mais efetiva de testes unitários.

Em contrapartida, o ASP.NET MVC é radicalmente diferente dos tradicionais WebForms do ASP.NET. Com o MVC precisamos entender muito mais de HTML, Javascript e CSS. Todos os Server-controls que estamos acostumados a utilizar em WebForms, não funcionam no MVC. Isso só pra citar algumas diferenças.

Com toda essa diferença, surgiu a seguinte questão: Os WebForms vão morrer? A resposta oficial da Microsoft é NÃO! Muito pelo contrário, os WebForms vão ganhar novas funcionalidades na versão 4 da plataforma.

Talvez em uma resposta ao MVC, que prega essa necessidade latente de se ter maior controle sobre o HTML gerado no Cliente, os WebForms vão ganhar alguns recursos que permitem algo similar. Um exemplo disso são as novas opções para se configurar o ClientID dos controles.

Um grande problema dos WebForms, que ficou mais evidente com o surgimento das MasterPages, é o complexo ID gerado automaticamente para os controles do lado do cliente. Pense em um DropDonwList simples em uma página que usa uma MasterPage, como mostra a Listagem 1.

Listagem 1. DropDownList em página com MasterPage

<asp:Content ID="Content2" ContentPlaceHolderID="ContentPlaceHolder1" runat="server">
        <asp:DropDownList ID="ddl_Tipo" runat="server">
            <asp:ListItem Text="Tipo 1" Value="1">asp:ListItem>
            <asp:ListItem Text="Tipo 2" Value="2">asp:ListItem>
            <asp:ListItem Text="Tipo 3" Value="3">asp:ListItem>
        asp:DropDownList>
asp:Content>

Como sabemos, a propriedade ID define o ID do controle no servidor, mas no client o nosso controle vai ganhar um ID novo, gerado pelo ASP.NET. Veja na Figura 10.

Figura 10. ID gerado para o DropDownList no Client

Esse ID é gerado de acordo com a posição do controle na página, e isso pode ser um problema se você precisa acessar esse controle com alguma linguagem script no client, como JavaScript. Não só pela complexidade do ID, mas também pela possibilidade de ele ser alterado, caso você altere a sua posição na página.

A solução que a versão 4.0 da plataforma vai trazer é simples e eficaz. Basta definirmos a propriedade ClientIDMode como Static, assim como você pode ver na Figura 11.

Figura 11. Nova propriedade ClientIDMode

Essa nova propriedade permite configurar como queremos que o ClientID seja gerado. Colocando ela como Static, estamos definindo que o ClientID será igual ao próprio ID do controle, confira o resultado na Figura 12.

Figura 12. ClientID mantido como o ID do controle

Além disso, a propriedade ClientIDMode permite outras configurações, como o Predictable, que oferece a possibilidade de definirmos um prefixo na propriedade ClientID (que agora não é mais read-only), seguido de um número sequencial, o que pode ser útil para controles gerados dinamicamente.

ASP.NET WebForms 4.0: Chart

Um novo tipo de controle foi criado nesta versão 4 do ASP.NET, o Chart. Como você pode ver na Figura 13, temos agora esse novo controle para gráficos na seção Data da ToolBox. Note que ele é tão fácil de usar quanto qualquer outro controle de dados que já estamos acostumados a usar, como por exemplo, o GridView.

Figura 13. Controle Chart do ASP.NET

Note que podemos ligar o gráfico com qualquer tipo de Data Source disponível no ASP.NET. Em seguida basta definir o tipo do Gráfico e configurar os valores que são exibidos. Na janela de propriedades temos mais uma série de possibilidades de configuração. Esse controle vai ajudar muita gente que acaba tendo que recorrer a pacotes de terceiros para construir seus gráficos na Web.

ASP.NET Routing, AJAX 4.0

Outra novidade interessante, é que assim como é no ASP.NET MVC, nos WebForms também poderemos criar aplicações baseadas em Rotas (ASP.NET Routing), ao invés de links estáticos para as páginas .aspx. Esse é um dos diferenciais do ASP.NET MVC que também estará disponível nos WebForms.

A possibilidade de criar aplicações WebForms com o roteamento bi-direcional traz dois grandes benefícios: uma organização de URLs mais inteligente e fácil para que haja interação do próprio usuário final, e o uso de chamadas dinâmicas, ao invés das chamadas estáticas (hard-coded) que fazemos hoje nas nossas aplicações WebForms.

E comprovando a tendência de que o desenvolvedor de aplicações Web precisa ter um controle maior sobre o desenvolvimento do lado do cliente, a nova versão do AJAX terá como principais novidades os recursos chamados de Client-Side.

O ASP.NET AJAX que conhecemos hoje está fortemente acoplado ao conceito dos WebForms, o que o torna uma biblioteca AJAX focada em controles Server-Side. Com a chegada do ASP.NET MVC Framework, onde não temos mais os controles Server-Side, como fica a questão do AJAX?

O AJAX 4.0 vem, entre outras coisas, para resolver essa questão. O objetivo é ter uma única biblioteca AJAX no ASP.NET, que atenda aos dois mundos: WebForms e MVC. Sendo assim, a principal novidade que vamos ter no AJAX 4.0 são recursos que podemos utilizar diretamente em linguagem HTML e JavaScript.

Maiores informações e o download do Preview 4 do ASP.NET AJAX 4.0, você encontra no CodePlex: http://www.codeplex.com/aspnet

Essas são apenas amostras do que está por vir no ASP.NET 4.0. É uma prova de que os WebForms continuam mais fortes do que nunca.

Web One Click Deployment

A exemplo do que aconteceu já a algumas versões atrás com as aplicações Windows Forms, no Visual Studio 2010 vamos ganhar um Web One Click Deployment para aplicações ASP.NET. Isso significa que poderemos com um único clique, publicar nossas aplicações Web diretamente no servidor de produção.

Isso também implica em uma série de novidades que teremos no arquivo de configuração Web.config. Agora poderemos ter várias versões dele para mesma aplicação, uma versão para cada “estágio” do desenvolvimento.

Sabe aquele combo-box que temos na frente do botão run no Visual Studio, onde podemos mudar de Debug para Release? No VS2010 poderemos ter uma versão do Web.config para cada uma dessas configurações. Veja na Figura 14.

Figura 14. Versões do Web.config para cada configuração da solution

E isso vai além de termos uma cópia do Web.Config para cada versão. Nós podemos definir para cada versão, transformações que devem ser aplicadas ao Web.config original, como a substituição da ConnectionString, ou o desligamento do Debug.

C#4 X VB10

Uma característica que você já deve ter notado nas novidades demonstradas até aqui, é que há uma crescente tendência em simplificar e facilitar o trabalho com a nova versão da plataforma. E com o C#4 e VB10 não poderia ser diferente.

A grande novidade nas linguagens do .NET Framework será talvez, a inclusão dos recursos de linguagem dinâmica, que foi citado anteriormente. Porém, uma característica interessante é que as duas principais linguagens da plataforma (C# e VB.NET) vão se tornar mais equivalentes.

Recursos que existiam apenas no VB9 ou só no C#3, vão agora existir nas duas linguagens. E a grande maioria das novidades que virão com a nova versão da plataforma, também irá contemplar as duas linguagens.

Em abril deste ano (14, 15 e 16 de Abril/2009) ocorreu o Simpósio Lang.NET, onde se falou muito das novidades da plataforma e das linguagens: http://www.langnetsymposium.com/. Vale a pena entrar no site e baixar as palestras.

Tomei a liberdade de retirar uma tabela da palestra de abertura (Key Note) do Jason Zander. Essa tabela mostra exatamente as novidades que existiam no C# 3 e agora vão existir no VB10, o que tinha no VB9 e agora virá no C#4, e as novidades que serão inclusas nas duas linguagens. Confira na Figura 15.

Figura 15. Novidades do C#4 e VB10. Retirado do www.langnetsymposium.com

Infelizmente não dá para falar de todas as novidades aqui. Mas para alegria dos fãs da linguagem C#, vou mostrar o que é e como funcionam os parâmetros opcionais e nomeados (Named/Optional Parameters).

Veja o código demonstrado aqui na Listagem 2. Aqui não há nada de novo. Note que temos um método chamado ExcluirRegistro, que recebe o parâmetro ExibePergunta to tipo bool. Se o parâmetro for igual a true, o software deve perguntar ao usuário se ele realmente deseja excluir o registro.

Listagem 2. Sobrecarga de método que encapsula um parâmetro opcional

// Método para excluir registro
 private void ExcluirRegistro( bool ExibePergunta )
 {
 DialogResult PodeExcluir = DialogResult.Yes;
  if (ExibePergunta)
  {
  PodeExcluir = MessageBox.Show(
  "Deseja Realmente Excluir",
  "Excluindo...",
  MessageBoxButtons.YesNo);
 }
 
  if (PodeExcluir == DialogResult.Yes)
  {
 /// Código para excluir registro
  }
 }
 
 // Sobrecarga com parâmetro default 
 private void ExcluirRegistro()
 {
 this.ExcluirRegistro(true);
 }

Caso ExibePergunta seja igual a false, a pergunta deve ser omitida e o registro excluído de qualquer maneira.

Mas ao final desta mesma listagem você verá que temos uma sobrecarga do método ExcluirRegistro, que não possui nenhum parâmetro. Essa é a forma que temos hoje de simular um parâmetro opcional. Com essa sobrecarga do método, se omitirmos a passagem do parâmetro ExibePergunta, a pergunta será exibida.

No C#4 temos uma forma mais elegante de definir parâmetros opcionais, reduzindo a quantidade de código necessário em nossas aplicações. Veja na Listagem 3, como esse mesmo exemplo ficaria com o uso dos parâmetros opcionais do C#4.

Listagem 3. Método declarado com parâmetro opcional

// Método para excluir registro - com parâmetro opcional
 private void ExcluirRegistro( bool ExibePergunta = true)
 {
 DialogResult PodeExcluir = DialogResult.Yes;
  if (ExibePergunta)
  {
  PodeExcluir = MessageBox.Show(
  "Deseja Realmente Excluir",
  "Excluindo...",
  MessageBoxButtons.YesNo);
 }
 
  if (PodeExcluir == DialogResult.Yes)
  {
 /// Código para excluir registro
  }
 }

Observe que o parâmetro é declarado na assinatura do método, já com um valor inicial. Isso significa que podemos omitir a passagem deste parâmetro na chamada do método, e não precisamos mais daquela sobrecarga utilizada no exemplo anterior.

Quando optamos por não informar o parâmetro ExibePergunta, o comportamento do método será o mesmo se estivéssemos passando para este parâmetro o valor true.

Outra novidade que vem acompanhando os parâmetros opcionais é o chamado Parâmetro Nomeado, ou Named Parameter. Veja na Listagem 4 um exemplo de como chamar o método ExcluirRegistro da Listagem 3.

Listagem 4. Nomeando parâmetros antes de chamar o método, como boa prática

private void button1_Click(object sender, EventArgs e)
 { 
 bool ExibePergunta = false;
  this.ExcluirRegistro(ExibePergunta);
 }

É claro que não é necessário a criação do objeto ExibePergunta, bastaria passar o valor false diretamente na chamada do método.

Porém, essa é uma boa prática de programação, onde criamos um objeto do mesmo tipo do parâmetro que devemos passar. Assim, para quem lê, fica claro o significado do valor que estamos passando na chamada do método.

Os Named Parameters do C#4 vêm para melhorar essa prática. Se é importante deixar explícito no código o teor dos valores passados por parâmetros, podemos exibir os nomes dos parâmetros na própria chamada do método. Veja na Figura 16 como isso é feito, e como o próprio IntelliSense mostra os nomes dos parâmetros.

Figura 16. Exemplo de como utilizar parâmetros nomeados

Uma combinação entre os parâmetros nomeados com os parâmetros opcionais pode ainda evitar algumas boas linhas de código. Imagine aqueles métodos com uma longa lista de parâmetros, a maioria deles opcionais, onde devemos passar valores nulos quando não são utilizados. Estes são os casos mais beneficiados por estas duas novidades do C#4.

Entity Framework 4: Complex Types

O Service Pack 1 do .NET 3.5 trouxe uma feature muito interessante para o desenvolvimento de software orientado a objetos com bancos de dados relacionais. Foi o ADO.NET Entity Framework. O EF é uma ferramenta OR/M (Mapeamento Objeto Relacional) e veio com a proposta de fazer frente ao já conhecido NHibernate, ferramenta OR/M originada no Java (Hibernate) e que tem grande aceitação no .NET.

E como toda primeira versão, de qualquer que seja o produto, o Entitty Framework foi muito criticado, por conta é claro, de vários problemas encontrados. Eis então que seremos agraciados com uma segunda versão do Entity Framework, agora no .NET 4.0.

Para que não haja confusão, é importante notar que a segunda versão do Entity Framework é chamada de EFv4. Mas isso se deve ao fato de ela estar sendo distribuída junto com o .NET 4.0. Nesta versão teremos muitas novidades.

Vamos começar vendo o que são os Complex Types. Estando com um projeto aberto no Visual Studio 2010, clique com o botão direito sobre ele na Solution Explorer e escolha a opção Add New Item.

Como você pode ver na Figura 17, a janela de New Item foi modificada um pouco, seguindo as novidades que vimos na janela de New Project, lá na Figura 3. Na seção Data escolha o template ADO.NET Entity Data Model, defina um nome para o modelo e clique em Add.

Figura 17. Criando novo modelo com o template ADO.NET Entity Data Model

Em seguida, assim como era na versão anterior, é iniciado um Wizard que lhe pergunta se você quer criar um modelo vazio, ou criá-lo baseado em um banco de dados existente. Escolha a opção Empty Model para criarmos um modelo vazio, e clique em Finish.

Complex Types não chegam a ser entidades, mas são agrupamentos de campos que podemos utilizar em nossos modelos. Veja na Figura 18 que já foi criada uma entidade chamada Cliente com algumas propriedades do tipo Scalar. Se você clicar com o botão direito sobre uma área vazia do modelo, verá como mostra a Figura 18, que temos uma opção chamada Add / Complex Type.

Figura 18. Adicionando um tipo complexo no modelo de entidades

Um tipo complexo, quando criado, aparece na janela Model Browser, e podemos modificar seu nome através da janela de propriedades. Se você clicar com o botão direito sobre o tipo, verá que pode adicionar propriedades do tipo Scalar nele, e criar a sua “sub-estrutura” desejada. Neste exemplo, como pode ser visto na Figura 19, estamos criando um tipo complexo com o nome de Endereco.

Figura 19. Complex Type

Você já pode ver que podemos adicionar propriedades a um tipo complexo, e neste exemplo é exatamente isso que iremos fazer, adicionando todas as propriedades que um endereço pode ter. Em seguida você pode adicionar na Entidade de Clientes uma “propriedade complexa”, e defini-la como sendo do tipo Endereco.

Como sabemos é muito comum termos tipos complexos como o de endereços, que podem ser reutilizados em diversas entidades, e é esse o objetivo dessa funcionalidade.

Entity Framework 4: Model First Development

Talvez uma das funcionalidades mais importantes do EFv4 é o conceito de Model First Development.

Como vimos anteriormente, é característico da primeira versão do EF que ao criarmos um novo modelo, temos duas opções. Podemos criar um modelo a partir de um banco de dados, similar ao que é possível fazer com o LINQ to SQL ou os Typed Datasets. Ou podemos criar um modelo vazio, e depois realizar o mapeamento Objeto/Relacional, com um banco de dados já existente.

O conceito de Model First Development, prega que primeiro criamos o nosso modelo de entidades, e depois criamos o nosso banco de dados baseado nesse modelo. No EFv4 temos agora essa possibilidade.

Quando criamos um modelo vazio, como o que fizemos no exemplo anterior, temos a possibilidade de gerar o script para a criação de um banco de dados baseado neste modelo. Veja por exemplo o modelo da Figura 20, que é uma evolução do exemplo anterior.

Figura 20. Opção de gerar o banco de dados através do modelo (Model First development)

Você pode ver que temos três entidades, uma associação, uma herança e o tipo complexo que pode ser observado na janela Model Browser. Se clicarmos com o botão direito sobre uma área vazia do modelo, temos a opção Generate Database Script from Model.

Ao escolhermos essa opção, um Wizard é iniciado para que possamos criar o nosso script. Na primeira etapa do Wizard é solicitada uma ConectionString, que indica que o banco de dados precisa existir para que o script seja criado.

Em seguida o script para a criação de uma estrutura relacional, que mapeia o modelo de entidades, é gerado. Você pode conferir na Listagem 5, o script gerado para o modelo deste exemplo. Como você pode notar nesta listagem, temos três tabelas: uma para Clientes, outra para Transportadoras e uma terceira para ClientesVIP.

A estrutura é adaptada para comportar os tipos complexos e a herança, que não existem no modelo relacional, permitindo a criação de um modelo orientado a objetos e depois um banco de dados relacional baseado neste modelo. Este é o Model First Development.

Listagem 5. Script para criação de tabelas baseado no Model First Development

-- --------------------------------------------------
 -- Date Created: 05/27/2009 23:39:58
 -- Generated from EDMX file: C:\Fontes\VS2010\WebApplication1\WebApplication1\Model1.edmx
 -- --------------------------------------------------
 
 SET QUOTED_IDENTIFIER ON;
 SET ANSI_NULLS ON;
 GO
 
 USE [VentoNorte]
 GO
 IF SCHEMA_ID('dbo') IS NULL EXECUTE('CREATE SCHEMA [dbo]')
 GO
 
 -- Creating table 'ClienteSet'
 CREATE TABLE [dbo].[ClienteSet] (
  [Id] int NOT NULL,
  [Nome] nvarchar(max) NOT NULL,
  [Telefone] nvarchar(max) NOT NULL,
  [Endereco_Logradouro] nvarchar(50) NOT NULL,
  [Endereco_Bairro] nvarchar(30) NOT NULL,
  [Endereco_Cidade] nvarchar(30) NOT NULL,
  [Endereco_UF] nvarchar(2) NOT NULL,
  [Endereco_CEP] nvarchar(9) NOT NULL,
  [Transportadora_1_Id] int NOT NULL
 );
 GO
 -- Creating table 'TransportadoraSet'
 CREATE TABLE [dbo].[TransportadoraSet] (
  [Id] int NOT NULL,
  [Nome] nvarchar(max) NOT NULL
 );
 GO
 -- Creating table 'ClienteSet_ClienteVIP'
 CREATE TABLE [dbo].[ClienteSet_ClienteVIP] (
  [Contato] nvarchar(max) NOT NULL,
  [Email] nvarchar(max) NOT NULL,
  [Id] int NOT NULL
 );
 GO
 
 -- --------------------------------------------------
 -- Creating all Primary Key Constraints
 -- --------------------------------------------------
 
 -- Creating primary key on [Id] in table 'ClienteSet'
 ALTER TABLE [dbo].[ClienteSet] WITH NOCHECK
 ADD CONSTRAINT [PK_ClienteSet]
  PRIMARY KEY CLUSTERED ([Id] ASC)
  ON [PRIMARY]
 GO
 -- Creating primary key on [Id] in table 'TransportadoraSet'
 ALTER TABLE [dbo].[TransportadoraSet] WITH NOCHECK
 ADD CONSTRAINT [PK_TransportadoraSet]
  PRIMARY KEY CLUSTERED ([Id] ASC)
  ON [PRIMARY]
 GO
 -- Creating primary key on [Id] in table 'ClienteSet_ClienteVIP'
 ALTER TABLE [dbo].[ClienteSet_ClienteVIP] WITH NOCHECK
 ADD CONSTRAINT [PK_ClienteSet_ClienteVIP]
  PRIMARY KEY CLUSTERED ([Id] ASC)
  ON [PRIMARY]
 GO
 
 -- --------------------------------------------------
 -- Creating all Foreign Key Constraints
 -- --------------------------------------------------
 
 -- Creating foreign key on [Transportadora_1_Id] in table 'ClienteSet'
 ALTER TABLE [dbo].[ClienteSet] WITH NOCHECK
 ADD CONSTRAINT [FK_TransportadoraCliente]
  FOREIGN KEY ([Transportadora_1_Id])
  REFERENCES [dbo].[TransportadoraSet]
  ([Id])
  ON DELETE NO ACTION ON UPDATE NO ACTION
 GO
 -- Creating foreign key on [Id] in table 'ClienteSet_ClienteVIP'
 ALTER TABLE [dbo].[ClienteSet_ClienteVIP] WITH NOCHECK
 ADD CONSTRAINT [FK_ClienteVIP_inherits_Cliente]
  FOREIGN KEY ([Id])
  REFERENCES [dbo].[ClienteSet]
  ([Id])
  ON DELETE NO ACTION ON UPDATE NO ACTION
 GO
 
 -- --------------------------------------------------
 -- Script has ended
 -- --------------------------------------------------

Conclusão

Infelizmente não foi possível ver nem metade das novidades que a nova versão da plataforma .NET nos trará. Só pra citar alguns assuntos importantes que ficaram de fora, temos: as linguagens F#, IronRuby e IronPhyton; as novidades em torno do Visual Studio Team System, com diversas novas ferramentas para gerenciamento de projetos; a nova versão do Workflow Foundation (WF), que também está toda reformulada em WPF; as novidades do WCF; as questões das linguagens dinâmicas, com o DLR e o próprio Dynamic C#, entre diversos outros assuntos.

Mas dá pra você ter uma ideia de que o Visual Studio 2010 e o .NET Framework 4.0 vão ser uma grande versão da plataforma de desenvolvimento da Microsoft. Não dá nem pra pensar em deixar de acompanhar esse lançamento.

Se você quiser acompanhar de perto essas e outras novidades que a Microsoft nos reserva para essa versão, sugiro que fique atento aos vídeos do Channel 9, que possui uma série só voltada para as novidades do VS2010 e .NET 4.0, e pode ser acessado através deste link: http://channel9.msdn.com/shows/10-4/. Além disso, recentemente foi anunciado que o TechEd 2009 será em Agosto ou Setembro, e é outra ótima oportunidade para conferir de perto as novidades que teremos no Visual Studio 2010 e .NET 4.0.

Grande abraço e até a próxima!