ScottGu's Blog em Português : ASP.NET

Minhas apresentações na Europa (Dezembro 2009)

Leniel Macaferi — Sun, 06 Dec 2009 23:04:00 GMT

Esta semana passada eu estive viajando pela Europa dando um monte de apresentações (aproximadamente 5 horas em cada país) - Noruega na terça-feira, Suécia na quarta-feira, Dinamarca na quinta-feira, e Bélgica, na sexta-feira. Estarei fazendo uma apresentação no BizSpark Camp na França na próxima terça-feira.

As coisas correram bem nas palestras, e eu me diverti pra valer ao conhecer muito pessoal novo (mais de 3.000 compareceram às palestras!). A seguir está uma foto da minha palestra na Bélgica - onde todos compareceram usando uma camisa vermelha :-)

Download das Palestras

Minhas palestras foram filmadas em alguns locais - e eu vou atualizar esse post com links para os vídeos, assim que estes estiverem on-line.

A seguir estão as cópias dos meus slides + demos:

ASP.NET 4 VS 2010 e Desenvolvimento Web: Slides + Demos + Posts

ASP.NET MVC 2,0: Slides + Passo a passo

Silverlight 4: Slides (aviso: download grande)

Espero que ajude,

Scott

P.S. Além do blog, eu também estou agora utilizando o Twitter para atualizações rápidas e para compartilhar links. Siga-me em: twitter.com/scottgu

Texto traduzido do post original por Leniel Macaferi.

Microsoft AJAX CDN - Agora com suporte ao SSL

Leniel Macaferi — Sun, 29 Nov 2009 22:55:00 GMT

Em setembro eu escrevi sobre a nova Microsoft AJAX CDN (Content Delivery Network - Rede de Entrega de Conteúdo) serviço que a equipe da ASP.NET está agora oferecendo. A CDN fornece suporte ao cache de borda para as bibliotecas AJAX (incluindo jQuery e ASP.NET AJAX). O serviço está disponível de graça, não requer qualquer registro, e pode ser usado tanto para fins comerciais e não-comerciais. A CDN oferece uma ótima maneira de acelerar seus web-sites externos.

Suporte ao SSL é Agora Oferecido

Uma das características em setembro que nós dissemos que estava chegando (mas que não estava disponível no lançamento inicial) foi o suporte ao SSL para scripts servidos por fora da CDN. Isso é necessário para cenários em que você tem páginas do seu site que usam SSL, e você quer fazer referência a uma biblioteca de script da CDN da Microsoft e evitar que a mensagem de aviso "Esta página contém itens seguros e não-seguros" seja exibida aos usuários finais que visitam o seu site.

O suporte ao SSL está habilitado com os scripts hospedados na Microsoft AJAX CDN. Basta usar um "https" com quaisquer referências de script em seu site que apontam para a CDN, e eles serão agora servidos sobre SSL. Por exemplo, a seguir é mostrado como você pode referenciar jQuery sobre o SSL:

A documentação da Microsoft AJAX CDN foi atualizada recentemente com mais detalhes sobre ela. Você pode visitá-la aqui para saber mais. A documentação lista todas as bibliotecas atualmente oferecidas através da CDN. Estamos constantemente adicionando mais bibliotecas na CDN e atualizaremos a documentação com novas bibliotecas assim que elas estiverem disponíveis.

Espero que ajude,

Scott

PS Além do blog, eu também estou agora utilizando o Twitter para atualizações rápidas e para compartilhar links. Siga-me em: twitter.com/scottgu

Texto traduzido do post original por Leniel Macaferi.

Melhorias na janela de diálogo Adicionar Referência (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Thu, 29 Oct 2009 04:12:00 GMT

[Além do blog, agora estou usando o Twitter para atualizações rápidas e para compartilhar links. Siga-me em: twitter.com/scottgu (@ ScottGu é o meu nome no twitter)]

Este é o décimo segundo 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 cobre uma pequena, mas agradável mudança que está chegando com o VS 2010 - uma janela de diálogo "Adicionar Referência" que carrega rapidamente.

Janela de diálogo Adicionar Referência no VS 2008

O desempenho lento da janela de diálogo "Adicionar Referência" em versões anteriores do Visual Studio tem sido uma queixa comum que muitos desenvolvedores (incluindo você) têm reclamado.

Versões anteriores do VS abriam a janela de diálogo "Adicionar Referência" na aba ".NET" por padrão - e quando essa tab era carregada, o VS simultaneamente varria o cache de assemblies global (GAC) retornando informações sobre os assemblies do .NET. Em virtude da varredura feita no GAC usar a thread da interface do usuário, a IDE ficava congelada até que a varredura fosse concluída - o que significa que você não podia cancelar a operação, mesmo se você não quisesse utilizar aquela tab.

Como as varreduras feitas no GAC podem na maioria das vezes levar algum tempo (se você tiver muitos assemblies instalados e/ou um disco rígido lento), você pode ter que esperar um bom tempo para a janela de diálogo responder.

Janela de diálogo Adicionar Referência no VS 2010

O lançamento do Beta 2 do VS 2010 introduz algumas alterações bem-vindas ao comportamento da janela de diálogo "Adicionar Referência", que melhora significativamente seu desempenho.

A primeira melhoria é que a janela de diálogo "Adicionar Referência" no VS 2010 agora por padrão abre na tab "Projetos" ao invés da tab .NET. Isto significa que a janela de diálogo sempre carrega rapidamente. Se você quiser configurar uma referência projeto-para-projeto, ou navegar no sistema de arquivos para selecionar um arquivo assembly (DLL), etc, você pode agora selecionar essas tabs imediatamente, sem ter que esperar que algo seja carregado.

A segunda melhoria é que as tabs .NET e COM agora carregam de forma assíncrona e não bloqueiam a thread da interface do usuário enquanto as suas listas são preenchidas. Isto significa que se você clicar acidentalmente nas tabs você não ficará bloqueado esperando pelo carregamento delas - com o VS 2010, você pode agora clicar em "Cancelar" para fechar a janela de diálogo ou clicar em outra tab.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Melhorias para Intellisense de Código do VS 2010 (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Fri, 23 Oct 2009 03:47:00 GMT

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

No post de hoje eu vou cobrir uma pequena melhoria, mas muito útil para a Intellisense de código com o VS 2010 - que é a sua capacidade de filtrar de forma mais eficaz a completação de código (intellisense) para tipos e membros. Isto lhe permite encontrar e usar mais facilmente as APIs quando você escreve código.

Intellisense de Código com o VS 2008

Para ajudar a ilustrar essas melhorias da intellisense que estão chegando com o VS 2010, vamos começar criando um cenário simples no VS 2008 onde queremos escrever algum código para habilitar um cenário de edição com um controle GridView.

Podemos começar escrevendo "GridView1.Edit" para ativar a Intellisense para vermos quais membros de Edição estão disponíveis no controle. Fazendo isso com o VS 2008 faz com que a lista de opções da Intellisense apareça e filtre a localização atual na lista suspensa para os membros que começam com a palavra "Edit":

Isto é ótimo se o método / propriedade / evento que queremos trabalhar começa com "Edit" - mas não nos ajuda muito se o membro "Edit" que estamos procurando começa com outra nome (por exemplo: o evento "RowEditing" ou o método de ajuda "SetEditRow()"). Temos que rolar manualmente para cima e para baixo, procurando por outros membros de edição, ou recorrer ao navegador de objetos ou sistema de ajuda para encontrá-los.

Intellisense de Código com o VS 2010

Vamos agora tentar o mesmo cenário com o VS 2010. Quando nós digitamos "GridView1.Edit" no VS 2010 vamos descobrir que a propriedade EditIndex é ainda realçada por padrão. Mas a lista de Intellisense também foi filtrada para que ela lhe permita localizar rapidamente todos os outros membros que tenham a palavra "Edit" em qualquer parte deles:

Isso nos permite ver rapidamente todos os métodos/propriedades/eventos relacionados com edição e mais rapidamente encontrar o que estamos procurando.

Buscando por Palavras-chave

Este novo recurso de filtragem da intellisense do VS 2010 é útil para a busca de qualquer membro - independentemente de qualquer palavra usada no início do nome. Por exemplo, se queremos habilitar a paginação em um DataGrid e não conseguimos lembrar como fazer isto, nós poderíamos apenas digitar "GridView1.Paging" e teríamos tudo filtrado automaticamente, restando somente os membros que têm a palavra paging (paginação). Observe a seguir como nenhum membro da classe GridView realmente começa com a palavra "Paging" - mas ainda estou encontrando os dois membros que têm a palavra paginação posteriormente em seus nomes:

Procurando por Tipos

Esta nova capacidade de filtragem da intellisense do VS 2010 também é útil para encontrar rapidamente as classes e tipos. Por exemplo, quando nós digitamos "List" para declarar uma variável, o editor irá fornecer a filtragem automática para mostrar todos os tipos que têm a palavra "List" em algum lugar de seus nomes (incluindo IList<> e SortedList<> - que não começam com List):

Isto torna muito mais fácil encontrar nomes de tipos que você pode não lembrar por completo - sem ter que recorrer à pesquisa através do navegador de objetos e/ou usar a documentação de ajuda.

Intellisense para Pascal Case

As regras para nomes do .NET Framework especificam que nomes de tipos e membros devem estar no formato "Pascal Case" por padrão. Isto significa que cada palavra em um tipo ou membro deve começar com uma letra maiúscula (por exemplo: PageIndexChanged).

O suporte à filtragem da Intellisense do VS 2010 agora permite a você tirar proveito deste padrão para encontrar e filtrar rapidamente métodos baseados em Pascal Case. Por exemplo, se nós digitássemos "GridView1.PIC", o VS 2010 filtraria o resultado para nos mostrar os membros que têm PIC no nome, bem como os membros que têm um nome no formato Pascal onde os segmentos de palavras começam com aquela seqüência de letras:

Observe acima como PIC fez com que tanto "PageIndexChanged" e "PageIndexChanging" aparecessem. Isso nos poupa alguns pressionamentos de tecla quando buscamos por nomes de membros e tipos.

Resumo

Eu acho que você verá que esta nova abordagem de filtragem da Intellisense no VS 2010 torna mais fácil localizar rapidamente e usar as classes e membros quando você estiver escrevendo código. Você pode aproveitar este recurso usando ambas as linguagens de programação: VB e C#.

Espero que ajude,

Scott

[P.S. Além de escrever posts neste blog, eu tenho usado o Twitter 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.

Pesquisando e Navegando pelo Código no VS 2010 (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Wed, 21 Oct 2009 04:50:00 GMT

Este é o nono de uma série de posts que estou escrevendo sobre o próximo lançamento do VS 2010 e .NET 4. No post de hoje eu vou cobrir alguns dos recursos de pesquisa e navegação de código que estão agora incorporados no VS 2010.

Pesquisando e Navegando pelo Código

Os desenvolvedores precisam ser capazes de facilmente navegar, pesquisar e entender a base de código em que estão trabalhando. Em estudos de usabilidade que fizemos, nós geralmente percebemos que os desenvolvedores gastam mais tempo lendo, analisando e pesquisando o código existente do que realmente escrevendo código novo.

O editor de código do VS 2010 acrescenta algumas características agradáveis que lhe permite de forma mais produtiva buscar e navegar pela base de código, e permiti a você compreender mais facilmente como o código está sendo usado em uma solução.

Pesquisando e Navegando pelo Código Fonte da ASP.NET MVC

Neste post eu vou usar a base de código do framework da ASP.NET MVC (que tem milhares de linhas de código) para ajudar a demonstrar alguns dos novos recursos de pesquisa e navegação de código do VS 2010. Se você tiver o VS 2010 Beta 2 instalado, você pode acompanhar este post fazendo o download e abrindo o código base do framework da ASP.NET MVC diponível aqui.

Você deve perceber que o desempenho dos recursos demonstrados a seguir é muito rápido neste projeto - apesar do mesmo conter milhares de linhas de código. Todas as características que estou mostrando a seguir estão também incorporadas no VS 2010 (e funcionam para todos os tipos de projeto e para ambas as linguagens VB e C#).

Suporte a "Navegar Para" do VS 2010

Ser capaz de pesquisar e navegar rapidamente pelo código é importante, em ambas soluções grandes e pequenas.

O Visual Studio 2010 agora suporta um novo atalho de teclado (Ctrl + vírgula) (significando que a tecla Ctrl é pressionada juntamente com a tecla de vírgula). Quando você pressiona a combinação (Ctrl + vírgula), uma nova janela de diálogo "Navegar Para" do VS 2010 aparecerá, a qual permite procurar rapidamente os tipos, arquivos, variáveis e os membros dentro de sua solução - e, em seguida, abrir e navegar por eles:

A janela de diálogo "Navigate To" (Navegar Para) fornece uma interface de busca rápida e incremental - com resultados imediatos tão logo você comece a digitar os termos da busca. Por exemplo, digite "cont" (sem pressionar enter) e você verá que 176 resultados imediatamente aparecerão na lista de resultados tão logo você comece a digitar:

Digite alguns caracteres mais e você verá a lista ser filtrada automaticamente, mostrando apenas os resultados que condizem com a palavra "controller":

Você pode usar a barra de rolagem para percorrer os resultados - ou, alternativamente, pressione a tecla TAB e em seguida, use as setas de cursor, se você não quiser retirar as mãos do teclado. Você verá que a janela de diálogo "Navegar Para" lista todos os tipos de resultados que correspondem ao termo de sua pesquisa - incluindo os nomes de tipo, nomes de propriedades e métodos, declarações de campo e nomes de arquivo:

Selecionando qualquer um dos resultados na lista de resultados abrirá o arquivo fonte relevante no VS 2010 (se o mesmo já não estiver aberto) e te levará imediatamente para o local relevante no código (destacando o termo procurado dentro do arquivo):

Capacidades Interessantes de Pesquisa Fuzzy

A caixa de pesquisa "Navegar Para" suporta algumas capacidades de "pesquisa fuzzy" que lhe permite executar filtros inteligentes e pesquisar sem ter que saber exatamente o nome da coisa que você está procurando. Estas pesquisas funcionam bem com a interface de pesquisa incremental/imediata da janela de diálogo - e permitirá a você refinar suas pesquisas para obter resultados em tempo real enquanto você digita.

Para testar esta funcionalidade, vamos primeiramente pesquisar usando a palavra "cache". Observe como os resultados da pesquisa não incluem apenas os itens que começam com a palavra "cache" -, mas também mostram qualquer resultado que contenha a palavra "cache":

Podemos adicionar várias palavras na caixa de texto de pesquisa para filtrar ainda mais os resultados. Por exemplo, a seguir estou filtrando a lista para incluir somente os resultados que têm ambas as palavras "cache" e "action" no nome:

Tipos e membros dentro do .NET Framework que usam um padrão de nomeação padrão chamado "Pascal Casing" - que significa que a primeira letra de cada palavra em um tipo ou entidade é capitalizado (em maiúsculo). A janela de diálogo "Navegar Para" permite, opcionalmente, a utilização desta convenção "Pascal Casing" para filtrar rapidamente os tipos. Basta digitar a primeira letra maiúscula de nomes de um tipo/membro para filtrar automaticamente em resultados que correspondem à convenção de nomes maiúsculos.

Por exemplo, digitar "AMS" irá filtrar os resultados a seguir (apenas os tipos e membros que têm palavras que começam com A, depois M, depois S):

A janela de diálogo "Navegar Para" permite a você rapidamente filtrar e localizar o código com um mínimo de digitação - e evita que você tenha que usar o mouse para abrir a aba Solution Explorer para clicar em um arquivo diretamente.

Veja a Hierarquia de Chamadas

Ter a capacidade de pesquisar e navegar pelo código rapidamente é ótimo. Ser capaz também de descobrir rapidamente como o código está sendo usado é ainda melhor. O VS 2010 introduz um novo recurso chamado “View Call Hierarchy” (Ver a Hierarquia de Chamadas) que lhe permite saber rapidamente se um determinado método ou propriedade dentro do seu código está sendo chamado, e permite que você rapidamente atravesse o grafo da árvore de chamadas de toda a sua base de código (sem ter que executar ou debugar a solução).

Para usar este recurso, basta selecionar um método ou o nome de uma propriedade dentro de seu código, e em seguida, digite o atalho de teclado (Ctrl+K, Ctrl+T), ou clique no botão direito do mouse e selecione o comando do menu de contexto "Exibir Hierarquia de Chamadas":

Isso fará com que uma nova janela de ferramentas chamada "Hierarquia de Chamadas" seja mostrada, a qual por padrão é exibida sob o editor de código. A seguir você pode ver como a janela "Hierarquia de Chamadas" está exibindo os dois métodos dentro da nossa solução que invocam o método ViewPage.RenderView() que selecionamos acima.

Podemos então opcionalmente detalhar hierarquicamente para o primeiro método "RenderViewAndRestoreContentType" para ver quem o chama:

Para os métodos/propriedades virtuais você também pode usar a janela de hierarquia de chamadas para ver quais tipos são derivados para então sobreescrever os mesmos.

Com um duplo clique em qualquer dos membros dentro da janela "Hierarquia de Chamadas" será aberto o arquivo fonte apropriado e te levará imediatamente ao local de origem:

Isso permite a você navegar rapidamente por toda base de código e ao mesmo tempo entender melhor as relações entre as classes e métodos à medida em que você codifica.

Referências Destacadas

Com o VS 2010, quando você selecionar ou destacar uma variável / parâmetro / declaração de campo, dentro do editor de código, todos os usos subseqüentes dele são automaticamente destacados para você dentro do editor. Isto torna mais fácil identificar rapidamente onde e como uma variável ou parâmetro está sendo usado.

Por exemplo, quando nós selecionamos o parâmetro "controllerContext" passado para o método ControllerActionInvoker.GetParameterValue() no editor a seguir, note como os 4 usos deste dentro desse método também já são automaticamente destacados:

Se eu selecionar uma variável local dentro do método, todos os lugares onde ela é usada também são automaticamente destacados:

Se múltiplas ocorrências são destacadas, você pode alternar entre elas usando a tecla (Ctrl-Shift-seta para cima) e (Ctrl-Shift-seta para baixo) para mover rapidamente o cursor para o símbolo anterior ou para o próximo símbolo destacado.

Resumo

O novo editor de texto do VS 2010 torna mais fácil pesquisar rapidamente, navegar e explorar o código dentro de um projeto ou solução. O desempenho destas operações é muito rápido (mesmo com uma grande base de código) e são mantidas atualizadas à medida que você trabalha no projeto e faz alterações no mesmo. O resultado final permite que você seja muito mais produtivo.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Roteamento de URL com ASP.NET 4 e Formulários Web (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Tue, 13 Oct 2009 04:13:00 GMT

[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)]

Este é o oitavo 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 cobre um recurso legal do tempo de execução da ASP.NET 4 – o qual é a habilidade de usar o roteamento de URL com páginas baseadas em Web Forms (Formulários Web).

O que é Roteamento de URL?

Roteamento de URL era uma capacidade que nós primeiramente introduzimos com a ASP.NET 3.5 SP1, a qual já é usada dentro de aplicações ASP.NET MVC para expor URLs limpas e mais amigáveis para os motores de busca no padrão "web 2.0". O roteamento de URL permite que você configure uma aplicação para aceitar URLs de requisição que não mapeiam para arquivos físicos. Em vez disso, você pode usar roteamento para definir URLs que são semanticamente significativas para os usuários e que podem ajudar no que diz respeito à otimização de motores de busca (SEO).

Por exemplo, a URL para uma página tradicional que mostra as categorias de produtos pode ser semelhante a descrita a seguir:

http://www.mysite.com/products.aspx?category=software

Usando o mecanismo de roteamento de URL na ASP.NET 4 você pode agora configurar a aplicação para aceitar a seguinte URL para exibir a mesma informação:

http://www.mysite.com/products/software

Com a ASP.NET 4.0, URLs iguais as mostradas acima podem agora ser mapeadas para classes de Controladores da ASP.NET MVC, bem como para páginas ASP.NET baseadas em Formulários Web.

Mapeando URLs usando a ASP.NET MVC

O motor de Roteamento de URLs introduzido com a ASP.NET 3.5 SP1 provê uma maneira poderosa para lidar com URLs de entrada. Normalmente você escreve código como parte da inicialização da aplicação para registrar/mapear URLs que correspondem a um formato de URL específico tendo em vista a codificação de tratadores de eventos.

A seguir é mostrado um exemplo de como você pode usar a ASP.NET MVC hoje para mapear a URL produtos/software para uma classe de controlador chamada "Products" que tem um método de ação denominado "Browse" (Procurar):

O primeiro parâmetro "products-browse" para o método de ajuda MapRoute() acima é um nome amigável para a rota. O segundo parâmetro "products/{category}" é o filtro de URL que corresponde à URL /products/software - e que trata o segundo segmento da URL como um valor de parâmetro chamado "category" (categoria). Este parâmetro será, então, passado para o método de ação Browse() do controlador ProductsController para que este dê início ao processamento.

Mapeamento de URLs usando Formulários Web da ASP.NET

A ASP.NET 4.0 agora permite também que você use o mecanismo de roteamento de URL para mapear URLs para Formulários Web da ASP.NET, bem como para Controladores da ASP.NET MVC.

A seguir está um exemplo de como você pode usar o novo método de ajuda MapPageRoute() na ASP.NET 4.0 para mapear a URL /products/software para uma págiina "Products.aspx" que reside imediatamente abaixo do diretório raiz da aplicação:

Os dois primeiros parâmetros para o método de ajuda MapPageRoute() são os mesmos usados em MapRoute(). O primeiro parâmetro fornece um nome amigável para a rota, e o segundo especifica o formato de URL aceito. O terceiro parâmetro, porém, aponta para uma página Products.aspx para que esta manipule a URL ao invés de uma classe de controlador. Opcionalmente, você pode especificar parâmetros adicionais para MapPageRoute() que tiram proveito de recursos como "restrições de rota" e que fornecem "valores padrão para parâmetros" da mesma forma já utilizada com a ASP.NET MVC através de registros de rota.

Dentro da página Products.aspx você pode então escrever código como o mostrado a seguir, o qual utiliza a nova propriedade Page.RouteData da ASP.NET 4.0 para recuperar o valor do parâmetro "category" mapeado usando o filtro de URL /products/{category}, e em seguida você faz a ligação dos dados com os produtos da categoria para exibí-los:

Além de acessar via código os parâmetros de entrada da rota usando código como o mostrado acima, você também pode aproveitar a nova declaração de controle <asp:routeparameter> com qualquer controle de fonte de dados (DataSource) para declarativamente vincular um valor de uma rota. Por exemplo, a seguir nós estamos usando uma declaração <asp:routeparameter> para vincular o parâmetro @category da instrução select a partir do parâmetro /products/{category} passado na rota da URL:

Recuperando URLs dentro de um Formulário Web da ASP.NET

O mecanismo de roteamento de URL da ASP.NET pode ser usado tanto para mapear URLs de entrada para manipuladores de código, bem como ser usados para programaticamente gerar URLs de saída usando a mesma lógica usada para registrar o mapeamento.

Por exemplo, quando mapeamos a URL /products/{category} acima, nós demos um nome "amigável" chamado "products-browse". Isso nos permite agora também usar o novo método de ajuda Page.GetRouteUrl() para procurar a rota no sistema de roteamento de URL, opcionalmente, especificar parâmetros para ela, e em seguida, recuperar uma URL real que ela mapeia. Por exemplo, o código a seguir retornaria um valor de URL igual a "/products/software":

Você pode acessar o método de ajuda acima dentro do arquivo de code-behind ou dentro do código HTML da página .aspx.

Há também agora um conjunto de métodos Response.RedirectToRoute() que você pode usar para redirecionar os usuários para uma rota (independentemente de se tratar de uma rota manipulada por uma aplicação MVC ou Formulários Web) e, opcionalmente, passar parâmetros para esta.

Manipulando Cenários de PostBack

O roteamento de URL na ASP.NET 4.0 tem suporte completo para cenários de post-back. O controle <form runat="server"> emitirá automaticamente a mesma URL que fez com que a página fosse renderizada. Por exemplo, se você acessar uma página com a URL /products/software então qualquer controle do servidor <form runat="server"> dentro desta página, renderizaria um elemento HTML <form action="/products/software"> de volta para o cliente - o que significa que qualquer cenário de post-back que acontece na página irá preservar a URL original.

Isso torna fácil o suporte a URLs limpas, amigáveis para SEO com os Formulários Web e cenários de postback - e evita alguns dos truques que as pessoas precisam usar hoje, quando estas usam módulos de reescrita de URL para conseguir efeitos semelhantes.

Resumo

A ASP.NET 4.0 torna fácil a implementação de URLs limpas, amigáveis para SEO usando a ASP.NET MVC e agora os Formulários Web (você também pode ter aplicações que misturam os dois frameworks).

O mecanismo de roteamento de URL torna mais fácil o registro de URLs de qualquer formato e mapeia as mesmas para qualquer manipulador que você deseje. Como o mecanismo de roteamento de URL pode ser usado tanto para mapeamento de URLs de entrada, assim como para gerar URLs de saída, você pode em um momento posterior alterar os mapeamentos de URL sem ter que modificar o código de qualquer página ou controlador específico para refletir as mudanças - o que torna a construção de aplicações otimizadas para SEO muito mais fácil.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Inicialização Automática para Aplicações ASP.NET (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Tue, 15 Sep 2009 05:46:00 GMT

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

Eu vou mudar o foco dos posts e ao invés de escrever sobre novos recursos de ferramentas do VS 2010, escreverei alguns posts que cobrem novos recursos do motor de execução (não se preocupe – eu voltarei a escrever sobre muitos outros recursos do VS. Eu estou simplesmente tentando misturar um pouco as coisas).

O post de hoje cobre um recurso pequeno, mas legal, que você agora pode opcionalmente tirar proveito usando a ASP.NET 4 - a capacidade de inicializar automaticamente e proativamente ativar uma aplicação web sem ter que aguardar o acesso de um cliente externo ao servidor. Isto pode te ajudar a prover uma experiência de resposta rápida para o primeiro usuário que acessar o servidor, e evita que você escreva scripts customizados para "aquecer" o servidor e ter todo o cache de dados pronto. Isto funciona com todos os tipos de aplicação ASP.NET – incluindo ambas as aplicações baseadas em Formulários Web ASP.NET e ASP.NET MVC.

Auto-Inicialize Aplicações Web com a ASP.NET 4

Algumas aplicações web precisam carregar grandes quantidades de dados ou executar um processamento de inicialização custoso antes de estarem prontas para processar requisições. Desenvolvedores que usam ASP.NET hoje geralmente fazem este trabalho usando o tratador de evento "Application_Start" que fica dentro do arquivo Global.asax da aplicação (o qual é ativado na primeira vez que uma requisição é executada). Eles geralmente seguem dois caminhos: criam scripts customizados para enviar requisições falsas para aplicação periodicamente "acorde a aplicação" e executam este código antes que um cliente acesse o servidor, ou simplesmente fazem com que o usuário desafortunado que acessa a aplicação pela primeira vez aguarde enquanto a lógica termina antes de processar a requisição (o que pode gerar um longo delay (atraso) para o cliente/usuário).

A ASP.NET 4 vem com um novo recurso chamado "auto-start" ou auto-inicialização que melhor endereça este cenário e está disponível quando a ASP.NET 4 roda no IIS 7.5 (o qual acompanha o Windows 7 e o Windows Server 2008 R2). O recurso de auto-inicialização provê uma abordagem controlada para iniciar o worker process (processo que executa todas as funcionalidades da ASP.NET) de uma aplicação, iniciando uma aplicação ASP.NET e então aceitando requisições HTTP.

Configurando uma Aplicação ASP.NET 4 para Auto-Inicializar

Para usar o recurso de auto-inicialização da ASP.NET 4, você primeiramente configura o worker process do "application pool" do ISS no qual sua aplicação está incluída para que o worker process seja automaticamente inicializado na primeira vez em que o servidor web for carregado. Você pode fazer isto abrindo o arquivo applicationHost.config do IIS 7.5 (C:\Windows\System32\inetsrv\config\applicationHost.config) e adicionando um atributo startMode=”AlwaysRunning” na entrada da propriedade <applicationPools>:

<applicationPools>

<add name="MyAppWorkerProcess" managedRuntimeVersion="v4.0" startMode="AlwaysRunning" />

</applicationPools>

Abra o gerenciador de tarefas do Windows e clique na checkbox "mostrar processos de todos os usuários". Salve as mudanças efetuadas no arquivo applicationHots.config. Você verá que um novo worker process chamado "w3wp.exe" imediatamente será inicializado no exato momento em que o arquivo é salvo.

Um único worker process de um pool de aplicações do IIS pode conter múltiplas aplicações ASP.NET. Você pode especificar quais aplicações você quer automaticamente inicializar quando o worker process for executado adicionando um atributo serviceAutoStartEnabled="true" na entrada da configuração da aplicação <application>:

<sites>

     <site name="MySite" id="1">

          <application path="/" serviceAutoStartEnabled="true" serviceAutoStartProvider="PreWarmMyCache" />

     </site>

</sites>

<serviceAutoStartProviders>

     <add name="PreWarmMyCache" type="PreWarmCache, MyAssembly" />

</serviceAutoStartProviders>

O atributo serviceAutoProvider="PreWarmMyCache" acima faz referência a uma entrada de provedor dentro do arquivo de configuração que permite a você configurar uma classe customizada que pode ser usada para encapsular qualquer lógica de "aquecimento" para a aplicação. Esta classe pode ser automaticamente invocada tão logo o worker process e a aplicação sejam pré-carregados (antes que uma requisição web externa seja recebida), e pode ser usada para executar qualquer inicialização ou lógica para o carregamento do cache que você queira antes que requisições sejam recebidas e processadas:

public class PreWarmCache : System.Web.Hosting.IProcessHostPreloadClient
{

    public void Preload(string[] parameters)
    {

        // Execute lógica de inicialização e carregamento de cache aqui...

    }

}

O IIS inicializará a aplicação em um estado durante o qual a aplicação não aceitará requisições até que sua lógica de "aquecimento" seja executada. Após o seu código de inicialização ter sido executado no método Preload e o método retornar, a aplicação ASP.NET será marcada como pronta para receber requisições.

Você pode opcionalmente combinar o novo recurso de auto-inicialização com as capacidades de balanceamento de carga da extensão Roteamento de Requisições da Aplicação do IIS7 e usá-la para sinalizar a um balanceador de carga quando a aplicação estiver inicializada e pronta para receber tráfego HTTP – no exato ponto em que o servidor pode ser trazido para o web farm (fazenda de servidores web) para processar requisições.

Sumário

O novo recurso de auto-inicialização da ASP.NET 4 e do IIS 7.5 provê uma abordagem bem definida que permite a você rodar uma inicialização custosa para a aplicação e lógica de pré-cache que podem ser executadas antes que qualquer usuário final acesse sua aplicação. Isto permite a você ter sua aplicação "aquecida" e pronta desde o começo para entregar uma experiência consistente de alta performance.

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.

Suporte a Snippets ASP.NET, HTML e JavaScript (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Fri, 04 Sep 2009 06:12:00 GMT

Este é o sexto 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 é sobre outra melhoria útil presente no VS 2010 – suporte a snippets de HTML/ASP.NET/JavaScript. Snippets (pedaços/fragmentos de código) permitem que você seja mais produtivo dentro da visão de código permitindo que você crie agrupamentos de código e linguagem de marcação HTML que você pode rapidamente aplicar e usar em sua aplicação com um mínimo de digitação.

O Visual Studio já possuía suporte ao conceito de "snippets" para VB e C# em lançamentos anteriores – mas não para linguagem de marcação HTML, ASP.NET e JavaScript. Com o VS 2010, nós agora suportamos snippets para estes tipos de conteúdo também.

Usando Snippets da ASP.NET

Vamos seguir um passo a passo que mostra como nós podemos usar snippets para rapidamente implementar um cenário de segurança comum. Especificamente, nós implementaremos a funcionalidade necessária para mostrar ou um link "[ Login ]" ou uma mensagem de boas-vindas "[ Welcome UserName ]" no topo direito do site dependendo se o usuário está ou não logado:

A funcionalidade acima é automaticamente adicionada para você quando você cria um projeto usando os novos Modelos de Projeto Iniciais da ASP.NET no VS 2010. Por ocasião deste passo a passo, nós iremos assumir que estamos começando com uma página master (principal) em branco e iremos construí-la inteiramente do início.

Nós começaremos adicionando um elemento <div> padrão na página master, e então posicionaremos nosso cursor do mouse dentro deste div:

Nós vamos usar o controle <asp:loginview> para nos ajudar a implementar esse cenário. O controle <asp:longinview> é um controle que usa template (e foi introduzido pela primeira vez na ASP.NET 2.0) o qual nos permite facilmente mudar entre os templates “Anonymous” (Anônimo) e “LoggedIn” (Logado) que são automaticamente mostrados dependendo se o usuário está autenticado ou não. Ao invés de digitar a linguagem de marcação do controle <asp:loginview> manualmente, nós usaremos o novo suporte a snippets do VS 2010.

Digitando "<log" no editor, teremos a intellisense que mostrará elementos disponíveis, controles e snippets de código que começam com esses caracteres.

Nós selecionaremos o snippet de código já construído "loginview" presente na lista acima e pressionaremos a tecla "tab" para completá-lo:

Agora que nós selecionamos o snippet que queremos usar, nós podemos pressionar a telca "tab" novamente para executar o snippet – o que fará com que este imediatamente substitua o nome do snippet com a linguagem de marcação mostrada a seguir. Note que o snippet adicionou um novo controle <asp:loginview> para nós e automaticamente definiu os dois templates mais comumente usados no controle. Nós fomos capazes de implementar isto tudo com somente 6 teclas pressionadas (4 teclas pressionadas para digitar "<log", e então pressionamos 2 vezes a tecla "tab").

Nós iremos agora implementar o template "AnonymousTemplate".

Digitando "<a" no editor trará a intellisense que mostrará os elementos e snippets de código disponíveis que nós podemos usar:

Nós selecionaremos o snippet de código já pronto "a" presente na lista acima e pressionaremos a tecla "tab" para completá-lo. Quando nós pressionarmos a tecla tab novamente, o snippet será executado – o que fará com que o que digitamos seja substituído pelo nome do snippet com o seguinte código de marcação:

O valor do atributo "href" e conteúdo interno do elemento <a> acima são destacados com uma cor de fundo verde. Isto indica que estes valores são parâmetros substituíveis e que nós podemos automaticamente pressionar tab para preenchê-los – evitando a necessidade de usar as teclas do cursor ou tocar o mouse (tornando as coisas muito mais rápidas).

Sem ter que mover nosso cursor ou mouse, nós podemos começar a digitar a URL da página de login que queremos que os usuários vejam se eles não estiverem autenticados no site:

Quando terminado, nós podemos pressionar a tecla "tab" e o VS irá automaticamente destacar o segundo parâmetro de conteúdo no editor para nós (sem necessidade de movimentar o cursor manualmente ou de ativar uma ação com o mouse):

Nós podemos então digitar o texto que queremos mostrar (novamente sem ter que mover o mouse ou tocar a tecla do cursor):

Uma vez terminado com o "<AnonymousTemplate>”" nós podemos partir para o "<LoggedInTemplate>”. Nós digitaremos "<log" no editor para trazer a intellisense – e selecionaremos o snippet "loginname" já pronto:

Quando nós pressionarmos a tecla tab, o snippet será executado – o que fará com que o que digitamos seja substituído pela marcação HTML a seguir:

O valor da propriedade "FormatString" acima foi automaticamente preenchido para nós com o texto da mensagem padrão de boas-vindas. O valor também é automaticamente destacado caso desejemos alterá-lo (sem a necessidade de mover o mouse ou as teclas do cursor). Para este exemplo nós iremos manter o texto padrão.

Nossa marcação HTML final fica igual a seguir:

Quando nós executarmos nossa aplicação, a marcação acima mostrará um link "[Login]" quando nós não estivermos autenticados:

Quando nós estivermos logados, nós veremos uma string de boas-vindas igual a seguir:

O número total de teclas que pressionamos para implementar todo este cenário é menor que 15% daquilo que teríamos que digitar anteriormente. Digitando rápido eu pude perceber que eu poderia implementar este cenário completo em menos de 15 segundos :-)

Snippets da ASP.NET MVC

Snippets prontos estão disponíveis para todos os controles da ASP.NET e elementos de marcação HTML.

Snippets prontos também estão disponíveis para cenários de visão da ASP.NET MVC, e para os métodos de ajuda HTML da ASP.NET MVC.

Por exemplo, nós podemos digitar "<act" dentro de uma visão da ASP.NET MVC e em seguida selecionar o snippet "actionlink":

Quando nós completamos esta ação e pressionamos a tecla "tab", o snippet será executado – o que fará com que o que digitamos seja substituído pelo nome do snippet com a marcação HTML a seguir:

Note que os valores "linktext" e "actionname" são marcados como parâmetros do snippet – isto significa que nós podemos facilmente substituí-los sem ter que usar as teclas do cursor ou tocar o mouse. O valor do primeiro parâmetro "linktext" é selecionado por padrão – o que significa que nós podemos simplesmente digitar para imediatamente substituir o valor, e então podemos pressionar a tecla tab para imediatamente selecionar e substituir o segundo parâmetro "actionname":

Snippets Customizados

O Visual Studio 2010 incluirá mais de 200 snippets pré-construídos que você pode usar imediatamente quando você instalar o produto.

O que é realmente legal é que você não está limitado a somente usar os snippets pré-construídos. Você também pode facilmente criar os seus próprios snippets (completos com parâmetros substituíveis) e você poderá importá-los no VS 2010 e também compartilhá-los com outros desenvolvedores. Isto torna fácil para você automatizar rapidamente as tarefas que você mais executa.

Este artigo descreve o suporte a snippets que já existe no VS 2008, e provê um pouco mais de contexto em como criar e gerenciar snippets customizados.

Sumário

Snippets formam um recurso útil que lhe permite reduzir o número de teclas pressionadas dentro do editor, e permite a você completar cenários e tarefas muito mais rapidamente. Ter snippets agora habilitados não somente em arquivos VB e C#, mas também em HTML, ASP.NET e JavaScript, torna esta capacidade ainda mais útil – e pode tornar você ainda mais produtivo.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Perfil de Desenvolvimento Web Otimizado para Código (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Wed, 02 Sep 2009 04:55:00 GMT

Este é o quinto 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 cobre uma nova opção de perfil "Desenvolvimento Web (Otimizado para Código)" que estamos introduzindo com o VS 2010, o qual fornece a você a opção de configurar o Visual Studio para rodar em um layout de IDE que esconde o designer web WYSIWYG e ao invés de mostrá-lo, otimiza a experiência com as ferramentas tornando-a mais rica e "focada na edição de código".

Perfis Web do VS 2010

Quando você executar o VS 2010 pela primeira vez, este lhe pedirá para selecionar um perfil de IDE a ser usado. O perfil que você selecionar configurará como as janelas de ferramentas serão mostradas/posicionadas na IDE por padrão e ajustará os atalhos padrão do teclado. Você pode então customizar estas configurações usando o menu Tools->Options dentro da IDE e então sobrescrever/mudar tais configurações. Você pode também mais tarde resetar seu perfil e selecionar um perfil diferente escolhendo o comando do menu Tools->Import and Export Settings.

Uma das coisas que você perceberá quando você executar o VS 2010 Beta2 pela primeira vez é a inclusão de dois perfis para "Desenvolvimento Web" na lista de opções de perfis:

A primeira opção de perfil "Web Development" (Desenvolvimento Web) é uma evolução da opção de perfil web development já existente no VS 2008 (com algumas boas melhorias que ajudam a melhorar o uso do espaço livre da tela com o VS 2010). Este perfil também permite a você tirar vantagem de todas as melhorias feitas no designer WYSIWYG HTML e no designer de páginas da ASP.NET que acompanham o lançamento do VS 2010 (eu escreverei sobre isto em mais detalhes em futuros posts desta série).

A segunda opção de perfil "Web Development (Code Optimized)" (Desenvolvimento Web (Otimizado para Código)) é um novo perfil que estamos introduzindo no VS 2010 que é otimizado para desenvolvedores web que não querem usar um designer WYSIWYG quando estão desenvolvendo, e que preferem uma experiência de edição "apenas com código" quando estão trabalhando nas páginas. Esta opção de perfil de IDE esconde as tabs relacionadas ao desginer de páginas WYWISYG, e configura um layout da IDE padrão que maximiza a quantidade de código que é mostrado na tela (com um mínimo de barras de ferramentas e janelas de ferramentas). Este perfil ainda provê a depuração de código/intellisense e a experiência do editor de código para páginas.

Comparando os Perfis para Desenvolvimento Web do VS 2010

Você pode ter uma noção da diferança entre os dois perfis comparando as screenshots do layout da IDE do Visual Studio imediatamente após a aplicação dos dois perfis voltados para o "Desenvolvimento Web":

Screenshot do perfil “Web Development”:

O layout a seguir demonstra o layout padrão da IDE (em uma resolução de monitor de 750x650) quando o perfil padrão "Web Development" é aplicado. Este perfil é uma evolução do perfil "Web Development" existente no VS 2008 e expõe tabs para Design/Split/Source (Desenho/Dividir/Código) dentro da janela do documento de qualquer HTML ou página ASP.NET:

Screenshot do Perfil “Web Development (Code Optimized)”:

A screenshot a seguir demonstra o layout padrão da IDE (em uma resolução de monitor de 750x650) quando o novo perfil "Web Development (Code Optimized)" é aplicado. Como você pode ver, o perfil otimiza o espaço vazio da tela para mostrar e editar código na tela, esconde todas as barras de ferramentas por padrão, e desabilita e esconde as tabs do designer dentro das janelas dos documentos HTML e páginas ASP.NET:

A seguir está uma screenshot do perfil "otimizado para código" em uma resolução de monitor maior:

Misturando e Combinando Recursos

Todos os diferentes recursos usados em ambos os perfis "Web Development" e "Web Development (code optimized)" são expostos através da janela de configuração do Visual Studio em Tools->Options. Isto significa que você pode começar com qualquer dos perfis do VS (incluindo os perfis General, VB e C#) e ligar ou desligar recursos individuais para customizar o layout da IDE e editar a experiência do jeito que você quiser.

Por exemplo: a seguir você pode ver a checkbox presente em Tools->Options para habilitar ou desabilitar o designer HTML (a qual irá configurar se as tabs Design/Split/Source serão mostradas abaixo de cada página):

Isto dá a você a flexibilidade para customizar sua experiência de desenvolvimento do jeito que você quiser e lhe permite criar uma experiência ferramental personalizada e otimizada para você e sua maneira predileta de desenvolver.

Os dois perfis para desenvolvimento web que acompanham o VS provêem dois bons pontos pré-configurados para começar, e nós pensamos que estes perfis podem oferecer um conjunto legal de padrões para um amplo conjunto de desenvolvedores. Você pode facilmente escolher começar com qualquer um dos perfis que você sentir que se adapta melhor a você, e opcionalmente você pode configurá-los ainda mais da maneira que você desejar.

Sumário

Nós estamos oferecendo um novo perfil simplesmente como uma opção para aqueles que preferem uma experiência de desenvolvimento focada em código. O designer WYSIWYG para HTML/ASP.NET continua a estar ativo por padrão em todos os outros perfis do VS 2010 (da mesma forma que está ativo no VS 2008), e nós também fizemos muitas melhorias no designer para o lançamento do VS 2010 (eu escreverei mais detalhes sobre estas melhorias em futuros posts). Então não se preocupe – o designer WYSIWYG definitivamente não desaparecerá, e continuará a ser melhorado e aprimorado em cada novo lançamento.

Nós achamos que o perfil “Web Development (Code Optimized)” é uma boa nova opção para os desenvolvedores que preferem ter uma experiência de desenvolvimento web com "foco na edição de código", e que não usam o designer WYSIWYG. Esta opção de perfil provê um modo simples para que os desenvolvedores escondam o designer (juntamente com suas janelas de ferramentas associadas e barras de ferramentas) do layout da IDE e ao invés de mostrá-lo, passam a ter uma experiência de desenvolvimento web focada na código fonte.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

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

Leniel Macaferi — Tue, 01 Sep 2009 02:37:00 GMT

Este é o quarto 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 uma das melhorias gerais da IDE e eu sei que muitas pessoas já estão esperando ansiosamente por esta melhoria no VS 2010 – suporte a múltiplos monitores.

Usando Múltiplos Monitores

O VS 2008 abriga todos os documentos/arquivos/designers dentro de uma única janela de alto-nível (principal) – o que infelizmente significa que você não pode particionar a IDE entre múltiplos monitores.

O VS 2010 corrigi isto agora permitindo que editores, designers e janelas de ferramentas sejam movidas para fora da janela principal e que sejam posicionadas em qualquer lugar que você queira e em qualquer monitor presente no seu sistema. Isto permite a você melhorar significativamente o uso do espaço disponível na tela e otimizar o fluxo de trabalho de desenvolvimento de maneira geral.

Tirar vantagem do suporte a múltiplos monitores é realmente fácil. Simplesmente clique em uma tab de documento ou em uma janela de ferramentas e arraste a mesma para uma nova localização dentro da janela principal da IDE – ou para fora da IDE para qualquer localização em qualquer monitor que você quiser:

Você pode mais tarde arrastar o documento/janela de volta para a janela principal se você quiser reenquadrá-la na janela principal (ou clique com o botão direito do mouse e escolha a opção re-dock).

O Visual Studio relembra a última posição da tela dos documentos quando o mesmo é salvo – o que significa que você pode fechar os projetos e reabrí-los para ter o layout da tela de volta da maneira que estava na última vez que você salvou os projetos.

Alguns cenários para o uso de Múltiplos Monitores

A seguir estão algumas screenshots de alguns cenários possíveis com o uso de múltiplos monitores (obviamente existem muitos mais que eu não estou descrevendo aqui). Suponha que cada janela nas screenshots a seguir está em um monitor diferente para que você tenha uma idéia completa da solução...

Suporte a arquivos de código fonte

Demonstra como arquivos de código podem ser divididos entre múltiplos monitores. A seguir eu mantive um arquivo .aspx na janela principal da IDE e então movi um arquivo de code-behind (código da página) e um arquivo de classe separado para uma tela separada:

Suporte à janela de Ferramentas

Demonstra como qualquer janela/painel de ferramentas dentro do VS10 pode ser dividida entre múltiplos monitores. A seguir eu movi a janela de ferramentas do executor de testes (test runner) para uma tela separada:

Suporte ao Designer:

Demonstra como um designer dentro do VS pode ser dividido entre múltiplos monitores. A seguir eu movi o desinger WYSWIYG da WPF/Silverlight e o grid de propriedades para uma tela separada (o arquivo de code behind ainda está na janela principal). Note como o grid de propriedades do VS10 agora suporta editores de cor alinhados, ligação de dados (databinding), estilos, pincéis, e muito mais coisas para aplicações WPF e Silverlight (Eu escreverei sobre isto em posts futuros):

Sumário

Se você trabalha em um sistema que tem múltiplos monitores conectados, eu acho que você vai gostar do suporte a múltiplos monitores dentro do VS10 e que você notará que este suporte dará um gás na sua produtividade.

Se você ainda não tem múltiplos monitores conectados ao seu computador, esta pode ser uma boa desculpa para ter alguns... :-)

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

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

Leniel Macaferi — Fri, 28 Aug 2009 03:48:00 GMT

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

Texto traduzido do post original por Leniel Macaferi.

Modelos de Projeto Iniciais (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Thu, 27 Aug 2009 00:07:00 GMT

Este é o segundo 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 é sobre outra pequena, porém eu acho legal, mudança que está chegando com o VS 2010 e a ASP.NET quando você cria novos projetos Web ASP.NET – a qual é a habilidade para criar ambos "Projetos Vazios" como também projetos que já possuem funcionalidades comuns e layout incluídos nos mesmos, e que pode ajudá-lo quando você começa a construir uma nova aplicação.

Criando Novos Projetos

Quando você usar os comandos do menu File->New Project ou File->New Web Site dentro do VS 2010, você verá uma nova janela de diálogo "New Project" igual a mostrada a seguir que permite a você filtrar por linguagem de programação e tipo de aplicação e selecionar diferentes modelos de projeto para usar ao criar novos projetos:

O VS 2010 vem com modelos de projeto do tipo "vazio" para criar novas aplicações ASP.NET – os quais irão criar projetos mínimos que contêm somente os arquivos essenciais para começar. Meu último post nesta série incluiu uma screenshot que mostra o que o modelo de projeto "Empty ASP.NET Web Application" cria quando você o usa para começar uma nova aplicação.

Criando Novos Projetos usando um Modelo Inicial

O VS 2010 também vem com modelos de projeto iniciais que permitem a você criar uma nova aplicação ASP.NET que já tem alguma estrutura formada por layout/CSS e funcionalidades comuns já implementadas dentro do projeto.

Nós primeiramente tentamos este conceito com a ASP.NET MVC 1.0 – cujo o modelo de projeto provê uma página master/principal, uma arquivo CSS, bibliotecas JavaScript, sistema de login, e páginas "home" e "about" já plugadas e implementadas. O VS 2010 também adiciona suporte para esta idéia quando você cria projetos ASP.NET Web Forms.

Quando você escolhe o modelo de projeto padrão "ASP.NET Web Application", você verá que o projeto ASP.NET Web Forms criado já possui alguns diretórios e arquivos contidos dentro destes:

Este modelo de projeto inclui um arquivo de página master Site.Master que provê um layout consistente e abrangente para o site (com cabeçalhos, rodapés, etc), a qual usa uma folha de estilos CSS para configurar todos os estilos do site. Tem também um diretório "Scripts" que contém a jQuery dentro deste (ASP.NET AJAX está disponível através do controle script manager (gerenciador de scripts)). Inclui também páginas "default.aspx" e "about.aspx" no diretório raiz que são baseadas na página master e que incluem algum conteúdo padronizado. Inclui também um diretório "Account" que tem algumas páginas que implementam um sistema de autenticação baseado em formulários para que os usuários efetuem log-in, se registrem e troquem seus passwords:

Você pode executar o projeto sem ter que escrever código algum ou configurar alguma coisa, e tem um site legal e rodando:

O site tem suporte completo para autenticação de segurança baseada em formulários, e é pré-configurado para usar o sistema de Membership da ASP.NET para o gerenciamento de passwords:

Todos os estilos e conteúdo dentro do site são configurados usando CSS, e tiram proveito de alguns dos novos recursos dos Web Forms da ASP.NET 4 – incluindo nomes "id" no lado do cliente mais limpos (não mais nomes que começam com ctrl_ – ASP.NET 4 dá a você o controle completo sobre o id do controle no lado cliente), e renderização baseada em CSS ao invés de renderização baseada em tabelas para os controles do servidor que acompanham a ASP.NET. Eu discutirei sobre estes novos recursos dos Web Forms com mais profundidade em próximos posts desta série (juntamente com muitos outros recursos que estão sendo adicionados).

Galeria de Templates (Modelos de Projeto) Online

Além dos modelos de projeto já integrados e pré-definidos, o VS 2010 também suporta a habilidade de procurar modelos de projeto adicionais para usar, os quais estão na galeria de modelos de projeto online. Você terá acesso à galeria quando você acessar as janelas de diálogo "New Project" e "Add Item". Você pode contribuir com seus próprios modelos, adicionando-os na galeria, você pode dar uma nota e analisar submissões de outros, e procurar e filtrar os modelos por tipo de projeto, palavra chave e nota dada pela comunidade. Você também pode facilmente fazer o download e instalar qualquer template localmente e diretamente de dentro da janela de diálogo:

Isto irá esperançosamente facilitar a criação de muitos kits de projetos iniciais úteis (de todos os tipos de projeto – não somente web) que pessoas poderão facilmente descobrir e usar para rapidamente iniciar a construção de soluções.

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Arquivos Web.Config mais Limpos (Série de posts sobre VS 2010 e .NET 4.0)

Leniel Macaferi — Wed, 26 Aug 2009 02:50:00 GMT

Este é o primeiro 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 é sobre uma mudança reconhecidamente pequena mas que eu ainda acho legal, a qual está chegando com a ASP.NET 4.0: arquivos web.config limpos e concisos.

Você encontrará esta melhoria na primeira vez que você acessar o menu File->New Project dentro do Visual Studio 2010 para criar uma aplicação Web ASP.NET 4.0 vazia (este é o motivo de eu achar esta melhoria adequada para encabeçar a série de posts).

Arquivos Web.config no .NET 3.0 e 3.5

Durante os últimos lançamentos, os arquivos web.config dentro dos projetos ASP.NET cresceram de forma constante no que diz respeito ao tamanho. Por exemplo: o arquivo web.config padrão que é adicionado em um projeto web novo no Visual Studio 2008 SP1 tem agora algo em torno de 126 linhas e contém de tudo, desde definições de tag até definições de módulos e tratadores de eventos (handlers) que são incluídos no pipeline (canal de processamento de dados) HTTP da ASP.NET.

Este aumento no tamanho é porque o .NET 3.0 e .NET 3.5 usam o mesmo CLR e arquivo de configuração machine.config lançados com o .NET 2.0 – e simplesmente adicionam e atualizam os assemblies no framework quando eles são instalados. Para evitar o risco de nós acidentalmente sobrescrevermos as configurações customizadas dentro do arquivo machine.config 2.0 na máquina, nós não registramos as definições de tags, tratadores e módulos que foram lançados com as novas funcionalidades da ASP.NET que chegaram com as versões do .NET 3.0 e .NET 3.5. Ao invés disso, nós deixamos que novos projetos registrem estas configurações dentro do arquivo web.config local da aplicação. Esta foi uma decisão mais segura – mas fez com que os arquivos web.config aumentassem de tamanho e se tornassem mais complicados e difíceis para a leitura.

Arquivos Web.config no .NET 4

O .NET 4 inclui uma nova versão do CLR, e um novo arquivo machine.config específico para o .NET 4 (o qual é instalado lado a lado com aquele usado pelo .NET 2, .NET 3 e .NET 3.5).

O novo arquivo machine.config do .NET 4 agora registra automaticamente todas as seções de tags da ASP.NET, tratadores e módulos que nós adicionamos com o passar dos anos, incluindo as funcionalidades para:

ASP.NET AJAX
Dados Dinâmicos da ASP.NET
Roteamento (Routing) da ASP.NET (o qual pode agora ser usado com ambos os Fórmulários Web (WebForms) da ASP.NET e ASP.NET MVC)
Controle para gráficos (Charts) da ASP.NET (os quais agora são parte integral da ASP.NET V4)

O que isto significa é que quando você criar um novo projeto de "Aplicação ASP.NET Vazia" no VS 2010, você verá que o novo arquivo padrão web.config do nível de aplicação é agora limpo e simples:

A primeira seção config acima simplesmente sinaliza à ASP.NET para permitir a depuração de código (debugging) por padrão na aplicação, e indica a versão do .NET que o Visual Studio deverá utilizar para prover intellisense (o VS 2010 suporta múltiplos frameworks – e o intellisense dentro da IDE irá variar automaticamente dependendo de qual versão do framework você estiver usando).

A segunda seção config indica se o uso do modo "integrado" deve ser feito quando a aplicação ASP.NET for executada dentro do IIS7 – o qual controla se os módulos HTTP (HttpModules) devem ser executados para todas as requisições dentro da aplicação ou somente para URLs específicas da ASP.NET. Nós habilitamos esta configuração por padrão no arquivo web.config no nível da aplicação para novas aplicações – isto é porque por razões de compatibilidade, a configuração padrão do IIS7 registrada no nível da máquina especifica que módulos devem ser executados somente para URLs da ASP.NET (e não para todas as requisições).

Sumário

O arquivo web.config simplificado no .NET 4 é reconhecidamente uma pequena modificação – mas eu acho uma boa modificação de qualquer forma, e uma modificação que torna a experiência comum na hora de criar uma nova aplicação ASP.NET um pouco mais limpa e mais amigável.

Nos próximos posts eu estarei aprofundando em muitas das melhorias mais substanciais que estão chegando com a ASP.NET 4 (como também um pouco mais dos ajustes "pequenos mas legais" que estão chegando).

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Série de posts sobre Visual Studio 2010 e .NET 4

Leniel Macaferi — Wed, 26 Aug 2009 02:31:00 GMT

Nos próximos meses eu escreverei uma série de posts que discutirão algumas das coisas legais que estão chegando com o lançamento do VS 2010 e .NET 4.

O VS 2010 e a .NET 4 são os próximos grandes lançamentos das nossas ferramentas e estrutura (framework) de desenvolvimento. Juntos eles contêm milhares de novas funcionalidades e melhorias que eu acho que você irá realmente gostar, as quais fazem com que a construção de aplicações de todos os tipos seja mais fácil, rápido e melhor. As melhorias vão desde pequenos ajustes até aprimoramentos maiores - e podem ser encontrados no framework, nas linguagens e na IDE.

Nós ainda estamos a alguns passos do lançamento da versão "Beta2" do VS10 e da .NET 4 - esta é a versão que eu usarei para embasar os meus posts. Eu gostaria de começar a escrever antes do lançamento da Beta2 porque existem muitas coisas para escrever sobre (e é legal ter a chance de escrever sobre algumas das novidades do Beta2 antes que qualquer outra pessoa o faça! :-).

Eu irei atualizar esta página com links para os posts individuais que eu escrever sempre que eu publicá-los durante esta jornada:

Arquivos Web.Config mais Limpos (Postado em 25 Agosto de 2009)
Modelos de Projeto Iniciais (Postado em 26 de Agosto de 2009)
Suporte a Múltiplos Frameworks (Postado em 27 de Agosto de 2009)
Suporte a Múltiplos Monitores (Postado em 31 de Agosto de 2009)
Perfil de Desenvolvimento Web Otimizado para Código (Postado em 02 de Setembro de 2009)
Snippets de Código para HTML / ASP.NET / JavaScript (Postado em 04 de Setembro de 2009)
Inicialização Automática para Aplicações ASP.NET (Postado em 15 de Setembro de 2009)
Roteamento de URL com ASP.NET 4 e Formulários Web (Postado em 13 de Outubro de 2009)
Pesquisando e Navegando pelo Código no VS 2010 (Postado em 21 de Outubro de 2009)
Melhorias para Intellisense de Código do VS 2010 (Postado em 22 de Outubro de 2009)

WPF 4 (Postado em 26 de Outubro de 2009)

Melhorias na janela de diálogo Adicionar Referência (Postado em 29 de Outubro de 2009)

Espero que ajude,

Scott

Texto traduzido do post original por Leniel Macaferi.

Preview 1 da ASP.NET MVC V2 Lançada

Leniel Macaferi — Fri, 31 Jul 2009 04:53:00 GMT

O time da ASP.NET acabou de lançar a preview pública da ASP.NET MVC Versão 2. Você pode fazer o download aqui.

A preview de hoje funciona com o .NET 3.5 SP1 e VS 2008, e pode ser instalada lado a lado na mesma máquina; assim como a ASP.NET MVC 1.0 (o que significa que não há conflito, e seus projetos da ASP.NET MVC 1.0 existentes não serão impactados se você a instalar). Se você tiver ambas ASP.NET MVC 1.0 e ASP.NET MVC 2.0 instaladas você verá dois modelos de projeto da ASP.NET MVC dentro da janela de diálogo "Novo Projeto" do Visual Studio 2008:

As notas de lançamento que acompanham o lançamento da Preview da ASP.NET MVC 2 detalham como fazer o upgrade de projetos ASP.NET MVC 1.0 existentes de modo que estes passem a usar a V2 se você quiser migrá-los para aproveitar os novos recursos.

Novos Recursos

A ASP.NET MVC V2 incluirá muitas novas capacidades e recursos (alguns deles já foram detalhados na página de futuras adições da ASP.NET MVC. O lançamento de hoje da "Preview 1" contém uma primeira impressão de alguns destes recursos. Muitos novos recursos aparecerão nos lançamentos de futuras previews. Os bits da Preview 1 ainda são relativamente novos - o time está lançando este preview hoje para começar a receber e incorporar sugestões.

A seguir estão descritos rápidos detalhes sobre algumas das capacidades da Preview 1:

Suporte a Áreas

A ASP.NET MVC 2 inclui suporte a um novo recurso chamado "areas" (áreas) que permite a você particionar e agrupar funcionalidades mais facilmente dentro de uma aplicação MVC.

Áreas provê um meio para agrupar controladores e visões permitindo assim a construção de subseções em uma aplicação muito grande isolando-as de outras seções. Cada área pode ser implementada como um projeto ASP.NET MVC separado, o qual pode então ser referenciado pela aplicação principal. Isto ajuda no gerenciamento da complexidade na hora de construir uma grande aplicação e facilita o trabalho de múltiplos times que cooperam entre si em uma única aplicação.

A seguir está uma screenshot que mostra uma única solução que tem três projetos. Um dos projetos é chamado "CompanySite" e inclui o conteúdo principal do site, layout e controladores e visões. Existem então dois projetos "Area" separados - "Blogs" e "Forums". Estes projetos implementam a funcionalidade que existe para as seções das URLs /Blogs e /Forums dentro do site – e encapsulam todas as regras de roteamento, controladores e visões implementando estas seções:

O lançamento da Preview 1 inclui a primeira parte da implementação do recurso de áreas. Esta preview ainda não inclui nenhuma ferramenta que suporta este recurso (atualmente você precisa adicionar manualmente uma tarefa de construção para criar um projeto área e configurá-lo). Versões futuras incluirão o suporte a ferramentas, e expandirão e refinarão o conjunto de recursos ainda mais.

Suporte à Validação de Dados através de DataAnnotation

A ASP.NET MVC 2 agora inclui suporte nativo para validação de dados através de DataAnnotation (Anotação de Dados) que primeiramente apareceu no .NET 3.5 SP1 – e a qual é usada com a ASP.NET Dynamic Data e os Serviços RIA do .NET. DataAnnotation provê uma maneira fácil para declarativamente adicionar regras de validação nas classes do Modelo e ViewModel dentro de uma aplicação de modo a ter a validação automática para os dados e métodos de ajuda da UI dentro da ASP.NET MVC.

Para ver este recurso em ação, nós podemos criar uma nova classe do tipo ViewModel chamada "Customer" (Cliente) igual a seguir que tem cinco propriedades (implementadas usando o recurso de propriedades automáticas da C#)

Nós podemos então decorar as propriedades com regras de validação apropriadas usando os atributos de DataAnnotation implementados dentro do namespace System.ComponentModel.DataAnnotations. O código a seguir usa 4 regras de validação nativas e diferentes – [Required] (Requerido), [StringLength] (Tamanho da String), [Range] (Limite), e [RegularExpression] (Expressão Regular). O namespace também inclui uma classe base (ValidationAttribute) que você pode herdar para criar seus próprios atributos de validação customizados.

Nós podemos então criar uma classe CustomersController que tem dois métodos de ação chamados Create, O primeiro método de ação Create trata as requisições HTTP GET para a URL “/Customers/Create” e renderiza um template (modelo) de visão baseado em um objeto Customer vazio. O segundo método de ação Create trata requisições HTTP POST para a mesma URL (e recebe um objeto Customer como parâmetro). Este verifica se existe algum erro de ligação de dados referente ao modelo para os dados de entrada submetidos pelo usuário, e se existem erros, o método mostra novamente o template da visão usando os dados já inseridos. Se não existem erros, o método mostra uma visão de sucesso para o usuário:

Finalmente, nós podemos clicar com o botão direito do mouse sobre qualquer um dos métodos de ação Create acima, escolher o comando do menu de contexto "Add View" (Adicionar Visão) e automaticamente "gerará" um template para a visão "create" que é baseado no objeto Customer. Quando nós fazemos isto o template da visão gerado conterá a tag HTML <form> a seguir para nosso Customer:

Agora quando nós requisitamos a URL “/Customers/Create” no nosso browser, nós teremos um formulário inicial vazio igual a seguir:

Se nós entrarmos com dados inválidos e fizermos um post para o servidor, o objeto responsável pela ligação dos dados do modelo (binder) da ASP.NET MVC 2 irá detectar que existem atributos DataAnnotation na nossa classe Customer, e automaticamente validará os dados enviados usando as regras de validação. Se existem erros, o nosso método de ação do controlador mostrará novamente o formulário – o quer fará com que as mensagens de erro apropriadas sejam exibidas para o usuário igual a seguir. Note como as strings de validação para as mensagens de erro que definimos usando atributos de DataAnnotation são mostradas para o usuário através dos métodos de ajuda Html.Validation. Nenhum código adicional é necessário para habilitar isto.

O formulário acima será reexibido com as mensagens de erro cada vez que o usuário inserir dados inválidos e tentar enviá-los para o servidor através de uma requisição post.

Em previews futuras da ASP.NET MVC 2 nós estamos planejando entregar o plugin de Validação da jQuery como parte do modelo padrão de projeto, e adicionar suporte automático para a aplicação de regras de validação do tipo DataAnnotation no lado do cliente através de JavaScript. Isto permitirá que os desenvolvedores adicionem regras de validação mais facilmente em um lugar, seja este o Modelo ou o objeto ViewModel, tendo estas regras aplicadas em ambos os lados (cliente e servidor) em qualquer lugar onde estas sejam usadas dentro da aplicação.

Se você não quiser anotar suas classes do Modelo ou ViewModel diretamente, você pode alternativamente criar uma “buddy class” (classe de ajuda) que acompanha sua classe do modelo e encapsula as regras de DataAnnotation separadamente. Esta capacidade é também útil em cenários onde o VS está gerando o código/atualizando as propriedades diretamente em uma classe e você não pode adicionar atributos ao código gerado automaticamente (por exemplo: classes geradas pelos motores de LINQ para SQL ou LINQ para Entidades).

Além de prover suporte nativo para DataAnnotations, a classe DefaultModelBinder na ASP.NET MVC V2 tem novos métodos virtuais que podem ser sobrescritos para facilmente integrar outros frameworks de validação (por exemplo: Castle Validator, EntLib Validation, etc). Os métodos de ajuda de UI para validação na ASP.NET MVC são projetados para suportar qualquer tipo de framework de validação (eles não têm conhecimento direto sobre DataAnnotations).

Métodos de Ajuda de UI Fortemente Tipificados

A ASP.NET MVC V2 inclui novos métodos de ajuda de UI que permitem a você usar expressões lambda fortemente tipificadas quando referenciar o objeto do modelo referente ao template da visão. Isto permite uma melhor verificação das visões no tempo de compilação (de modo que bugs podem ser encontrados no tempo de compilação ao invés de no tempo de execução), e também permite um melhor suporte à intellisense dentro dos templates das visões.

Você pode ver um exemplo do melhor suporte à intellisense em ação a seguir – note como eu estou pegando uma lista completa com as propriedades do objeto Customer pertencente ao modelo quando estou usando o novo método de ajuda Html.EditorFor().

A Preview 1 tem suporte nativo para os novos métodos de ajuda Html.EditorFor(), Html.LabelFor() e Html.DisplayFor(). Um assembly da MVC futures atualizado que nós estamos entregando esta semana adiciona os métodos de ajuda Html.TextBoxFor(), Html.TextAreaFor(), Html.DropDownListFor(), Html.HiddenFor(), e Html.ValidationMessageFor() (com o passar do tempo estes métodos serão movidos para o assembly central da ASP.NET MVC 2 também).

A seguir você pode ver uma versão atualizada do template da visão "create" para o cenário de criação do nosso objeto Customer. Note como ao invés de usarmos expressões formadas por strings para referenciar o objeto Customer, agora nós estamos usando expressões lambda fortemente tipificadas com os métodos de ajuda de UI. Assim nós podemos ter suporte total para a intellisense e verificação de código no tempo de compilação com todos os métodos:

O método de ajuda Html.LabelFor() acima gera o marcação HTML <label for="Name">Name:</label>.

O método de ajuda Html.EditorFor() pode ser usado para qualquer valor de tipo de dado. Por padrão este é experto o bastante e irá gerar uma marcação HTML <input/> apropriada com base no tipo de dado a ser editado. Por exemplo, o método Html.EditorFor() gerará elementos <input type=”text”/> para as primeiras quatro propriedades acima (as quais são strings e inteiros). Este gerará um elemento <input type=”checkbox”/> para a propriedade final "IsActive" – a qual é do tipo boleano.

Além de suportar tipos de dados simples, o método de ajuda Html.EditorFor() também permite que você passe objetos mais complexos com múltiplas propriedades. Por padrão este método irá percorrer todas as propriedades públicas do objeto e gerará um elemento <label>, <input/> e qualquer mensagem de validação apropriada para cada propriedade que este achar. Por exemplo, nós poderíamos reescrever a visão acima para termos somente uma única chamada a Html.EditorFor() para o objeto Customer, gerando conceitualmente a mesma marcação mostrada acima:

Os métodos de ajuda fortemente tipificados permitem a você opcionalmente decorar as propriedades da classe ViewModel do Customer com atributos [DisplayName] para controlar a string do label que será gerada para cada propriedade usada (por exemplo: ao invés de ter um texto para o label "IsActive" nós poderíamos aplicar um atributo [DisplayName(“Is Active Customer:”)]).

Você também pode adicionar atributos [ScaffoldColumn(false)] para indicar que uma propriedade particular não deve ser renderizada por completo em cenários iguais ao mostrado acima onde objetos complexos são passados para o método Html.EditorFor().

Suporte a Templates para os Métodos de Ajuda de UI

Os método Html.EditorFor() e Html.DisplayFor() possuem suporte nativo para renderização de ambos os tipos de dados padrão e complexos com múltiplas propriedades. Como notado acima, eles também suportam customização básica da renderização através da aplicação de atributos como [DisplayName] e [ScaffoldColumn] no ViewModel.

Geralmente os desenvolvedores querem ser capazes de customizar ainda mais a saída HTML gerada pelos métodos de ajuda de UI para ter total controle sobre o que é gerado. Os métodos de ajuda Html.EditorFor() e Html.DisplayFor() suportam isto através de um mecanismo de customização que permite a você definir templates externas que podem ser sobrescritas e completamente controlar a saída renderizada. Melhor ainda, você pode customizar o conteúdo renderizado com base no tipo de dado/classe.

Com a Preview 1 você pode agora opcionalmente adicionar uma pasta chamada “EditorTemplates” e/ou “DisplayTemplates” abaixo do diretório \Views\[controllername] (se você quiser customizar a renderização das visões usadas por um controlador específico) ou abaixo do diretório \Views\Shared (se você quiser customizar a renderização de todas as visões e controladores em uma aplicação).

Você pode então adicionar arquivos de templates parciais nestas pastas para customizar a saída renderizada para um tipo de dado individual e/ou classe. Por exemplo, a seguir eu adicionei uma pasta EditorTemplates abaixo da pasta \Views\Shared – e adicionei três arquivos de template customizados dentro desta:

O template "Customer.ascx" acima indica que eu quero customizar a saída em todos os momentos em que um objeto Customer for passado para o método Html.EditorFor() (por exemplo: eu poderia customizar a exata ordem de ordenação/layout para a renderização das propriedades do Customer). A template "DateTime.ascx" acima indica que eu quero customizar o HTML gerado em todos os momentos em que uma propriedade do tipo DateTime for passada para o método Html.EditorFor() (por exemplo: eu posso querer usar um selecionador de datas construído com JavaScript ao invés de um textbox comum). Eu poderia opcionalmente adicionar uma template adicional "Object.ascx" na pasta se eu quisesse sobrescrever a renderização padrão de todos os objetos.

Alem da customização da renderização com base no tipo, você também pode adicionar "templates" nomeadas na pasta. Um cenário comum pode ser um template "CountryDropDown" que trata o tipo de dado string – mas ao invés de prover uma textbox padrão este template renderiza uma tag <select> para uma dropdownlist de valores relativos ao campo country (país) de forma que o usuário possa fazer sua seleção. A seguir é mostrado o que este template para o editor pode proporcionar:

Nós podemos explicitamente indicar que nós queremos usar o template acima passando seu nome como um argumento quando invocamos o método de ajuda Html.EditorFor(). Por exemplo, a seguir, além de especificar a expressão lambda para nossa propriedade Country, nós também estamos especificando o nome do template que o editor deve usar quando renderizar a propriedade.

Alternativamente, você pode especificar atributos "UIHint" nas suas propriedades e tipos do ViewModel. Isto permite a você indicar em único lugar a template padrão para o editor ou display, e fazer com que este template seja usado em todas as visões em sua aplicação (sem ter que explicitamente passar essa informação como um argumento para o método Html.EditorFor()).

A seguir está um exemplo de como indicar o template usando o atributo UIHint para a propriedade Customer.Country (a qual é do tipo string). Esta propriedade deve usar por padrão o template CountryDropDown quando for renderizada:

Uma vez definido o atributo acima no nosso ViewModel, nós não precisamos mais especificar o nome do template explicitamente quando usarmos esta propriedade com o método de ajuda Html.EditorFor(). Agora quando nós clicarmos no botão refresh (atualizar) no browser para nossa URL /Customers/Create, nossa propriedade Country será renderizada como um dropdown (combobox) ao invés de um textbox comum.

Outros Recursos Maneiros

A Preview 1 da ASP.NET MVC 2 inclui vários recursos adicionais que embora pequenos, são extremamente legais. Alguns dos meus favoritos são:

Novo Atributo [HttpPost]

É muito comum na ASP.NET MVC termos que dividir o tratamento da URL em dois métodos de ação – um que trata as requisições GET e um que trata as requisições POST.

Com a ASP.NET MVC 1 você usava um atributo [AcceptVerbs(HttpVerbs.Post)] para indicar a versão do "Post" de um método de ação:

Isto ainda funcionará com a ASP.NET MVC 2. Alternativamente a esta opção você pode agora tirar vantagem de um atributo mais resumido [HttpPost] que desempenha o mesmo papel:

Valores Padrão para Parâmetros

Tratar as opções de parâmetros é um cenário muito comum na web. Com a ASP.NET MVC 1 você podia tratar parâmetros opcionais registrando uma regra de roteamento customizada e especificando um valor padrão para esta, ou você marcava o parâmetro do método de ação como nullable (pode ser nulo) e então adicionava código dentro do método de ação para verificar se o parâmetro era ou não nulo (e se fosse, você provia um valor padrão).

A Preview 1 da ASP.NET MVC 2 agora suporta a decoração dos parâmetros do método de ação com o atributo DefaultValueAttribute do namespace System.ComponentModel. Isto permite a você especificar o valor para o parâmetro que a ASP.NET MVC deve passar caso o valor do parâmetro não esteja presente como parte da requisição. Por exemplo, a seguir está um exemplo de como nós poderíamos tratar ambas as URLs /Products/Browse/Beverages e /Products/Browse/Beverages?page=2 – fazendo com que o valor do parâmetro "page" seja "1" se este não for provido como parte da querystring (string de pesquisa):

A linguagem VB hoje permite que você especifique valores padrão para os parâmetros diretamente dentro da linguagem (evitando assim a necessidade de especificar explicitamente o atributo DefaultValue igual ao mostrado acima). A linguagem C# no VS 2010 também suportará valores padrão através de parâmetros opcionais – o que permitirá a você reescrever o código acima simplesmente como:

Isto deve tornar o tratamento de cenários que usam valor padrão/opcional realmente mais fácil e limpo.

Atribuindo Dados Binários

A Preview 1 da ASP.NET MVC 2 adiciona suporte para a atribuição de valores de string do tipo base64-encoded em propriedadeas do tipo byte[] e System.Data.Linq.Binary. Existem agora duas versões de sobrecarga para o método Html.Hidden() que aceitam estes tipos de dados. Estes tipos de dados podem ser úteis em cenários onde você quer habilitar o controle de concorrência dentro de sua aplicação retornando para o servidor valores do tipo timestamp das linhas do banco de dados presentes dentro de seus formulários.

Sumário

Clique aqui para fazer o download de um arquivo .zip que contém o projeto que implementa o código de exemplo da ASP.NET MVC 2 que eu demonstrei no passo a passo acima.

A construção de hoje da ASP.NET MVC 2 é somente uma primeira preview. Mais recursos chegarão em versões futuras, e o time espera receber bastante retorno com relação ao que pode ser feito para melhorar e aumentar a quantidade de recursos disponíveis na distribuição.

O objetivo de disponibilizarmos estas previews regulares é ajudar a termos certeza que este processo de retorno está aberto e que qualquer um que queira participar possa facilmente se envolver. Por favor nos envie qualquer retorno, sugestões ou relate problemas que você tem no Fórum da ASP.NET MVC em www.asp.net. Você pode também aprender mais sobre este lançamento a partir do post MVC2 de Phil Haack, e a partir do Vídeo que Phil fez com Scott Hanselman sobre o lançamento da Preview 1 no Channel9.

Espero que ajude,

Scott

P.S. 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.