Suporte a Múltiplos Frameworks (Série de posts sobre VS 2010 e .NET 4.0)

Este é o terceiro de uma série de posts que estou escrevendo sobre o próximo lançamento do VS 2010 e .NET 4.

O post de hoje discute o suporte melhorado a múltiplos frameworks no VS 2010 – o qual permite a você usar e ter como alvo múltiplas versões do .NET. Nós realizamos um trabalho de arquitetura significante no VS 2010 para permitir vários novos recursos relacionados ao suporte de múltiplos frameworks, e para prover uma experiência muito melhor.

Entendendo o suporte Lado-a-Lado (Side-by-Side)

O VS 2010 pode ser instalado "lado a lado" com versões anteriores do Visual Studio. Isto significa que você pode instalá-lo na mesma máquina que já possui o VS 2008/VS 2005/VS 2003 – e usar todas as versões ao mesmo tempo se você assim quiser.

O .NET 4.0 também pode ser instalado "lado a lado" com versões prévias do .NET na mesma máquina. O .NET 4.0 tem um novo número de versão para ambas as bibliotecas do framework como também para o motor (engine) da CLR – o que significa que este pode ser executado completamente independente do .NET 2.0, 3.0 e 3.5. Assim você pode instalar o .NET 4 em uma máquina que já possui o .NET 2.0/3.0/3.5 instalado, e configurar algumas aplicações para rodar usando o .NET 4.0 e outras para rodar usando versões mais antigas do .NET (a ferramenta de administração do IIS permite que você configure isto para aplicações ASP.NET). Esta abordagem permite a você usar o .NET 4 para novas aplicações - sem ter que necessariamente testar e atualizar todas as suas aplicações já existentes.

Suporte a Múltiplos Frameworks no VS 2008

O VS 2008 foi o primeiro lançamento do Visual Studio que inclui o suporte a múltiplas versões do .NET. Isto permitiu a você o uso do VS 2008 para criar e editar não somente projetos que faziam uso do .NET 3.5, mas também projetos que usavam o .NET 3.0 e .NET 2.0. Este recurso permitiu que os desenvolvedores fizessem o upgrade mais rapidamente para os novos recursos das ferramentas do Visual Studio – sem forçar a necessidade da instalação de novas versões do .NET nos servidores  clientes ou de produção que rodavam suas aplicações.

O suporte a múltiplos frameworks do VS 2008 foi capaz de tirar vantagem do fato de que o .NET 2.0, .NET 3.0 e .NET 3.5 rodam por cima da mesma versão do CLR – e que a diferença principal entre as versões do .NET estava em suas bibliotecas que compõem o framework. Como resultado disso, os compiladores do Visual Studio foram capazes de gerar o mesmo código IL de saída, o degugger (depurador de código) foi capaz de debuggar tendo em vista o mesmo motor do CLR, e o suporte para múltiplos frameworks da IDE estava primeiramente focado em filtrar novos assemblies e modelos de projeto no momento de exibí-los quando estes não fossem suportados em uma dada versão do .NET.

Esta experiência de múltiplo suporte funcionou – embora não fosse perfeita. A Intellisense fornecida dentro do VS 2008 sempre mostra os tipos e membros para a versão .NET 3.5 de uma biblioteca do framework (mesmo se você estiver usando o .NET 2.0). Isto significa que você pode às vezes inadvertidamente terminar usando um método que faz parte somente da ASP.NET 3.5 mesmo estando trabalhando em um projeto que faz uso da ASP.NET 2.0.

Suporte a Múltiplos Frameworks no VS 2010

Nós fizemos algumas grandes mudanças arquiteturais no VS 2010 para permitir um suporte a múltiplos frameworks muito melhor e mais preciso.

O VS 2010 agora traz o que nós chamamos de "assemblies de referência" para cada versão do .NET. Um "assembly de referência" contém somente os metadados de um assembly particular do framework
– e não contém sua implementação real (tornando o seu tamanho muito menor no disco). Este metadado é o suficiente para garantir que o VS 2010 sempre forneça 100% de intellisense de maneira precisa quando o VS tiver como alvo uma versão particular do .NET framework. Isto também significa que as propriedades expostas no grid de propriedades dentro dos designers, listas de API dentro do Browser de Objetos, e todos os outros vários lugares dentro da IDE possam refletir de maneira precisa a assinatura exata da versão da API.

Nós também atualizamos o degugger do VS 2010, o profiler e os compiladores para que fôssemos capazes de suportar múltiplas versões do CLR.

Usando o Suporte a Múltiplos Frameworks do VS 2010

Para entendermos melhor como estes novos recursos de múltiplos frameworks funcionam, vamos criar uma nova aplicação Web ASP.NET usando o VS 2010. Para fazermos isto nós podemos usar o comando do menu "File->New Project" para chamarmos a janela de diálogo "New Project". Nós usaremos o controle combobox de versão para filtrarmos os modelos de projeto para somente mostrarmos aqueles que são suportados pelo .NET 2.0. Nós então criaremos um novo projeto ASP.NET 2.0 Web Application:

 

Devido a termos como alvo o .NET 2.0 neste projeto, o VS 2010 irá automaticamente filtrar a caixa de ferramentas (toolbox) e a intellisense para que estes somente nos permitam usar os controles que foram lançados na ASP.NET 2.0. Diferentemente do VS 2008, o grid de propriedades irá agora automaticamente filtrar as propriedades, nos mostrando somente aquelas propriedades que eram suportadas no "controle botão" da ASP.NET 2.0:

Ao escrever código, o VS 2010 irá agora também somente mostrar intellisense para os tipos e métodos/propriedades/eventos suportados pelo .NET 2.0. A seguir você pode ver a intellisense para o objeto "Response" da ASP.NET 2.0 quando nós digitamos "Response.Re":

 

Quando nós executamos a aplicação usando o web-server que acompanha o VS, esta será executada usando a versão 2.0 da ASP.NET (e o debugger do VS 2010 irá debuggar o processo do CLR 2.0):

Mudando um Projeto do .NET 2.0 para o .NET 4.0

Nós podemos opcionalmente mudar o framework usado por nosso projeto para que o projeto passe a usar uma versão posterior do .NET. Para tanto precisamos clicar com o botão direito do mouse sobre o projeto dentro do "Solution Explorer". Isto trará a janela de diálogo que mostra suas propriedades. Nós podemos selecionar na combobox "target framework" (framework alvo) dentro da janela de diálogo a versão do .NET framework que queremos usar:

Nós podemos escolher entre as diferentes versões do .NET framework disponíveis na janela acima. Incluída na lista está a versão do perfil "Server Core" que suporta a versão sem GUI do Windows Server 2008 R2 – a qual não suporta certas APIs. Já que os assemblies de referência que usamos para os metadados e intellisense podem suportar qualquer versão ou lançamento, nós até mesmo seremos capazes de distribuir versões destes assemblies em futuros service packs (pacotes de atualização) caso estes assemblies incluam novas APIs (permitindo assim 100% de precisão).

Para este passo a passo, nós escolheremos modificar um projeto para que este passe a usar o .NET 4.0. Quando nós fazemos isto, o VS 2010 irá automaticamente atualizar os assemblies de referência usados pelo projeto e o arquivo web.config do nosso projeto para que eles reflitam de maneira correta a nova versão do framework.

Uma vez feita esta modificação, o VS 2010 irá filtrar a caixa de ferramentas e a linguagem de marcação usada pela intellisense para nos mostrar todos os novos controles e propriedades disponíveis na versão 4.0 da ASP.NET. Por exemplo, o grid de propriedades a seguir mostra a nova propriedade "ClienteIDMode" disponível em todos os controles da ASP.NET 4.0 - a qual dá a você a habilidade de controlar como os id's dos controles no lado do cliente são gerados, evitando assim ids do cliente feios (este é um novo recurso da ASP.NET 4.0 que detalharei em um próximo post):

Agora que nós fizemos o upgrade do projeto para que este passe a usar o .NET 4.0, o VS 2010 irá nos mostrar o código intellisense para novos tipos e métodos/propriedades/eventos em tipos do .NET 4.0. Por exemplo, a seguir você pode ver alguns dos novos métodos de redirecionamento disponíveis no objeto "Response" da ASP.NET 4.0 (os quais previamente não apareceram quando o projeto tinha como alvo o .NET 2.0):

 

O novo método Response.RedirectPermanent() acima torna fácil enviar repostas "HTTP 301 Moved" – as quais podem evitar que seu site acumule links inválidos nos motores de busca. O motor de Roteamento de URLs é agora suportado por ambos os tipos de aplicação ASP.NET Web Forms e ASP.NET MVC e o novo método Response.RedirectToRoute() permite a você redirecionar de maneira fácil para uma rota declarada com o auxílio do motor.

E por último, quando nós executarmos a aplicação usando o web-server integrado, o VS 2010 irá agora executar a aplicação usando a versão 4.0 da ASP.NET:

Sumário

O suporte a múltiplos frameworks do VS 2010 permite a você trabalhar em projetos que têm como alvo o .NET 4.0, .NET 3.5, .NET 3.0 e .NET 2.0. Isto permitirá a você tirar vantagem dos novos recursos das ferramentas, sem ter que imediatamente atualizar os clientes e servidores que executam suas aplicações para o .NET 4.0. O suporte melhorado a múltiplos frameworks irá garantir que esta experiência seja ainda melhor e mais precisa que antes.

Espero que ajude,

Scott

P.S. Além de escrever posts neste blog, eu tenho usado o Twitter mais recentemente para disponibilizar posts rápidos e compartilhar links. Você pode me seguir no Twitter em http://www.twitter.com/scottgu (@scottgu é o meu nome no Twitter).

 

Texto traduzido do post original por Leniel Macaferi.

No Comments