Por James Avery

Este artigo discute	Este artigo usa as seguintes tecnologias
Ferramentas para testes unitários; Ferramentas para administração e geração de código e documentação; Ferramentas para modificar o ambiente de desenvolvimento; Ferramentas para trabalhar com dados.	.NET Framework, Visual Studio 2003 e Visual Studio 2005.

Neste artigo preparei uma lista de ferramentas disponíveis (veja um resumo na Tabela 1) disponibilizadas na forma de add-ins para o Visual Studio. A IDE disponibiliza um modelo rico e extensível, do qual os desenvolvedores Microsoft e a comunidade tem tirado vantagem para prover uma variedade de add-ins de qualidade. Alguns add-ins contribuem significativamente para prover a funcionalidade "how-did-I-live-without-this" ("como posso viver sem isto"), enquanto outros só ajudam a automatizar pequenas tarefas redundantes que executamos freqüentemente.

Nome	Download
TestDriven.NET	www.testdriven.net
GhostDoc	www.roland-weigelt.de/ghostdoc
Paster	weblogs.asp.net/alex_papadimoulis/category/5341.aspx
CodeKeep	www.codekeep.net
PInvoke.NET	www.pinvoke.net
VSWindowManager PowerToy	workspaces.gotdotnet.com/vswindowmanager
WSContractFirst	www.thinktecture.com/Resources/Software/WSContractFirst/default.html
VSMouseBindings	www.gotdotnet.com/team/ide/#original
CopySourceAsHTML	www.jtleigh.com/CopySourceAsHtml
Cache Visualizer	blog.bretts.net

Tabela 1. Os 10 add-Ins indispensáveis para Visual Studio

Neste artigo, apresentaremos alguns dos melhores add-ins para o Visual Studio atualmente disponíveis, cujo download pode ser feito livremente. Veremos cada um desses add-ins, mas por estar cobrindo tantos, só teremos espaço para apresentar as suas funcionalidades básicas. Cada um desses add-ins trabalha com o Visual Studio .NET 2003, e a maioria já tem versão disponível para o Visual Studio 2005. Se no momento da publicação deste artigo, a versão para Visual Studio 2005 ainda não estiver disponível, brevemente estará.

TestDriven.NET

Desenvolvimento dirigido a testes (test-driven development) é a prática de escrever testes unitários antes de escrever o código, e então escrever o código que faça esses testes funcionar. Escrever os testes antes de escrever o código mostrará o comportamento exato que o seu código deveria ter e, ao final, teremos testes completos para o todo o código, facilitando também o Refactoring.

O NUnit nos permite escrever testes unitários usando uma sintaxe simples e a seguir executá-los na aplicação, um por um ou na sua totalidade. Se estivermos usando o Visual Studio Team System, a funcionalidade estará embutida na IDE. Antes do Visual Studio Team System, tínhamos o TestDriven.NET, um add-in integrado diretamente no NUnit da IDE do Visual Studio. Usar uma versão "não Team System" do Visual Studio 2005 ou do Visual Studio .NET 2003 é, na nossa opinião, ainda a melhor solução disponível.

O TestDriven.NET adiciona funcionalidades de teste unitário diretamente à IDE do Visual Studio. Em vez de escrever um teste unitário, passar o teste para a ferramenta GUI do NUnit, fazer o teste, retornar à IDE para codificar, e assim por diante, podemos fazer tudo direitamente na IDE.

Figura 1. Novas opções de teste do TestDriven.NET

Depois de instalar o TestDriven.NET, vários novos itens de menu aparecerão no menu de contexto, como mostrado na Figura 1. Podemos clicar de direita diretamente em um teste unitário e rodá-lo. Os resultados serão exibidos na janela Output, como mostrado na Figura 2.

Figura 2. Saída de um teste unitário

Apesar da execução de testes unitários na IDE ser um recurso inestimável, talvez a melhor característica seja que também podemos inicia-lo rapidamente em modo de depuração, clicando em um teste e selecionando Test With | Debugger. Isto iniciará o depurador e o teste unitário será executado pausando nos breakpoints assinalados.

Na realidade, o TestDriven.NET pode, da mesma maneira, executar facilmente o teste de qualquer método público void. Isso significa que se estivermos testando uma aplicação antiga, e precisarmos percorrer o código, poderemos escrever um teste rápido e executá-lo imediatamente.

O TestDriven.NET é um add-in essencial, caso trabalhemos com testes unitários ou pratiquemos o desenvolvimento orientado a testes (se ainda não o estiver fazendo, deveria considerá-lo seriamente). O TestDriven.NET foi escrito por Jamie Cansdale e o seu download pode ser feito de www.testdriven.net.

GhostDoc

Comentários XML são ferramentas inestimáveis para a documentação de aplicações. Usando comentários XML, podemos documentar o código e, usando uma ferramenta como o nDoc, gerar arquivos de ajuda ou documentação Web baseada nesses comentários. O único problema com a documentação XML é o tempo gasto para escrever inúmeras vezes declarações semelhantes. O objetivo do GhostDoc é automatizar as partes tediosas de escrever comentários XML com base nos nomes de classes ou métodos, assim como nos parâmetros. Isso não substitui a elaboração da documentação completa das regras de negócio, mas automatizará a parte mais negligenciada da geração de documentação.

Por exemplo, consideremos o método mostrado aqui:

private void SavePerson(Person person)
{
}

Depois de instalar o GhostDoc, podemos clicar de direita na declaração do método e escolher Document this. Os seguintes comentários serão acrescentados então ao documento:

/// <summary>
/// Saves the person.
/// </summary>
/// <param name="person">Person.</param>
private void SavePerson(Person person)
{

}

Como podemos ver, o GhostDoc gerou um resumo automaticamente, baseado em como o método foi nomeado e também preencheu os comentários de parâmetros. Não pare por aqui, adicione outros comentários que declaram onde person está sendo salva ou talvez dê um exemplo de como criar e salvar um person. A seguir, o comentário após o acréscimo manual de informação adicional:

/// <summary>
/// Saves a person using the configured persistence provider.
/// </summary>
/// <param name="person">The Person to be saved</param>
private void SavePerson(Person person)
{
}

O acréscimo destes comentários extras é muito mais fácil, uma vez que a parte básica redundante é gerada automaticamente pelo GhostDoc. O GhostDoc também inclui opções que permitem modificar as regras existentes e adicionar novas regras que determinam o tipo de comentários que devem ser gerados.

O GhostDoc foi escrito por Roland Weigelt e seu download pode ser feito de www.roland-weigelt.de/ghostdoc.

Smart Paster

Strings têm um grande papel na maioria das aplicações, tanto se forem comentários que serão usados para descrever o comportamento do sistema, mensagens que são enviadas ao usuário ou se forem declarações SQL que serão executadas. Uma das partes mais frustrantes de trabalhar com strings, é que nunca parecem "colar" corretamente na IDE. Quando estivermos colando comentários, as strings podem ser muito longas ou estar desalinhadas, obrigando-nos a inserir linhas de quebra, caracteres de comentário e tabulações. Ao trabalhar com strings que serão concatenadas, temos que trabalhar mais ainda, geralmente separando as partes da string e inserindo símbolos de concatenação ou usando um StringBuilder.

O add-in Smast Paster ajuda a minimizar esses problemas, via comandos no menu de contexto, os quais permitem a colagem de strings da área de transferência para o Visual Studio, usando um formato definido. Depois de instalar o Smart Paster, veremos as novas opções de colagem disponíveis no menu de contexto (veja Figura 3).

Figura 3. Opções do Smart Paster para colagem de strings

Por exemplo, poderíamos ter a seguinte string, que detalha alguma lógica de negócio:

To update a person record, a user must be a member of the customer service group or the manager group. After the person has been updated, a letter needs to be generated to notify the customer of the information change.

Podemos copiar e colar isso no Visual Studio usando Paste As | Comment, e teremos o seguinte:

//To update a person record a user must be a member of the customer 
//service group or the manager group. After the person has been updated 
//a letter needs to be generated to notify the customer of the
//information change.

Os caracteres de comentário e quebras de linha serão automaticamente inseridos (podemos configurar o comprimento para inserção de um caractere de retorno). Se estivéssemos inserindo esse texto sem a ajuda do Smart Paster, o mesmo seria colado como uma linha longa, forçando-nos a adicionar manualmente as linhas de quebra e os caracteres de comentário. Digamos, por exemplo, que temos a seguinte mensagem de erro, onde iremos inserir valores em tempo de execução:

You do not have the correct permissions to perform <insert action>. You must be a member of the <insert group> to perform this action.

Usando o comando Paste As | StringBuilder, podemos inserir esse string como um StringBuilder no Visual Studio. O resultado seria:

StringBuilder stringBuilder = new StringBuilder(134);
stringBuilder.AppendFormat(
    @"You do not have the correct permissions to ");
stringBuilder.AppendFormat(
    @"perform <insert action>. You must be a member of ");
stringBuilder.AppendFormat(
    @"the <insert group> to perform this action.");

Seria então simplesmente uma questão de modificar o código para substituir as seções variáveis da string:

StringBuilder stringBuilder = new StringBuilder(134);
stringBuilder.AppendFormat(
    @"You do not have the correct permissions to ");
stringBuilder.AppendFormat(
    @"perform {0}. You must be a member of ", action);
stringBuilder.AppendFormat(
    @"the {0} to perform this action.", group);

O Smart Paster é um add-in que economiza tempo, eliminando grande parte do trabalho associado com a manipulação de strings no Visual Studio. Foi escrito por Alex Papadimoulis e está disponível em weblogs.asp.net/alex_papadimoulis/category/5341.aspx.

CodeKeep

Durante o processo de desenvolvimento de software, é comum o reuso de pequenos trechos de código. O Visual Studio oferece algumas funcionalidades prontas para trabalhar com trechos de código, mas faz algumas suposições. Em primeiro lugar, supõe que todos os trechos de código serão armazenados na máquina local, portanto, se trocarmos de máquina ou transferirmos tarefas, devemos lembrar de guardar esses trechos. Em segundo lugar, esses trechos só podem ser vistos por nós. Não há nenhum mecanismo pronto para compartilhá-los entre usuários, grupos ou com o público em geral.

Aqui é que entra o CodeKeep. O CodeKeep é uma aplicação Web que disponibiliza um lugar para as pessoas criarem e compartilharem trechos de código em qualquer linguagem. A verdadeira utilidade do CodeKeep é o add-in Visual Studio, que permite procurar rapidamente no banco de dados do CodeKeep, assim como submeter nossos próprios trechos.

Depois de instalar o CodeKeep, podemos procurar os trechos de código existentes selecionando Tools | CodeKeep | Search, e usar a tela de procura mostrada na Figura 4.

Figura 4. Pesquisando trechos de código com o CodeKeep

Nessa tela podemos ver nossos próprios trechos ou procurar todos os trechos que foram submetidos ao CodeKeep. Ao procurar por trechos, vemos todos os que outros usuários submeteram e marcaram como públicos (podemos também marcar o código como privado, caso queiramos esconder nossas "práticas ruins"!). Se acharmos o trecho que estamos procurando, podemos ver seus detalhes, rapidamente copiá-lo para a área de transferência e inseri-lo no código.

Podemos também rapidamente acrescentar nossos próprios trechos de código ao CodeKeep, selecionando o código a salvar, clicando de direita e selecionando Send to CodeKeepital. Aparecerá uma nova tela que permite guardar o trecho, inclusive comentários, a linguagem utilizada e se o código será privado ou público.

Sempre que escrever um trecho de código e imaginar que irá usá-lo no futuro, simplesmente dedique um momento para submetê-lo; desse modo, não terá que se preocupar com a administração dos trechos ou reescrevê-los no futuro. Considerando que o CodeKeep armazena todos os trechos no servidor, esses estarão centralizados, e você não terá que se preocupar quanto a transferência do código de sistema para sistema.

O CodeKeep foi escrito por Dave Donaldson de Arcware e está disponível em www.codekeep.net.

PInvoke.NET

O P/Invoke é o processo usado no .NET Framework para acessar chamadas nativas da API Win32. Uma das partes difíceis do uso do P/Invoke é a determinação da assinatura do método que será usado; esse pode ser freqüentemente um exercício de tentativa e erro. O envio de tipos de dados ou valores incorretos para uma API não gerenciada pode resultar freqüentemente em estouro de memória ou em outros resultados inesperados.

O PInvoke.NET é um "wiki" que pode ser usado para documentar as assinaturas de P/Invoke corretas a serem usadas ao chamar APIs Win32 não gerenciadas. Um wiki é um Web site colaborativo que qualquer um pode editar, o que significa que existem milhares de assinaturas, exemplos e notas sobre o uso do P/Invoke. Do momento em que o wiki pode ser editado por qualquer um, podemos tanto contribuir quanto fazer uso das informações nele contidas.

Apesar de que o wiki e as informações nele armazenadas serem extremamente valiosas, o que as torna particularmente úteis é o add-in PInvoke.NET do Visual Studio. Uma vez carregado e instalado, poderemos procurar assinaturas assim como submeter novos conteúdos de dentro do Visual Studio. Simplesmente clicamos de direita nos arquivos de código e veremos dois itens de contexto novos: Insert PInvoke Signatures e Contribute PInvoke Signatures and Types.

Figura 5. Usando o PInvoke.NET

Quando escolhermos Insert PInvoke Signatures, aparecerá a caixa de diálogo mostrada na Figura 5. Usando essa caixa de diálogo simples, podemos procurar a função que desejamos chamar. Opcionalmente, podemos incluir o módulo do qual essa função faz parte. Por exemplo, uma funcionalidade comum em aplicações é a habilidade de o computador "bipar". Assim procuraremos a função Beep e veremos o que aparece. O resultado pode ser visto na Figura 6.

Figura 6. Achando a função Beep com o PInvoke.NET

Os resultados exibem um resumo do que o método faz (neste caso, "Gera tons simples no alto-falante"). Podemos também ver as assinaturas de código para o C# e o Visual Basic .NET. O wiki sugere APIs gerenciadas alternativas, permitindo saber que há um novo método System.Console.Beep no .NET Framework 2.0.

Também há um link na parte inferior da caixa de diálogo que nos encaminha para a página no wiki correspondente ao método Beep. Neste caso, essa página inclui a documentação dos vários parâmetros que podem ser usados com esse método, assim como alguns exemplos de código sobre como usá-lo.

Depois de selecionar a assinatura desejada, clique no botão Insert e a mesma será inserida no código do documento. Neste exemplo, o seguinte código seria criado automaticamente:

[DllImport("kernel32.dll", SetLastError=true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool Beep(
    uint dwFreq, uint dwDuration);

Só precisamos escrever uma chamada para esse método e o computador estará "bipando" em um instante!

O wiki do PInvoke.NET e o add-in do Visual Studio permitem uma grande economia de trabalho e tempo de pesquisa, necessário para trabalhar com o código gerenciado da API Win32. O wiki pode ser acessado em www.pinvoke.net, e o download do add-in pode ser feito do link Helpful Tools encontrado no canto inferior esquerdo do site.

VSWindowManager PowerToy

A IDE do Visual Studio inclui um número enorme de janelas diferentes, todas com sua utilidade. Se for igual a mim, você normalmente terá layouts de janela diferentes que preferirá usar de acordo com a tarefa em desenvolvimento. Quando escrevo para HTML, gosto de ocultar a caixa de ferramentas e a janela da lista de tarefas. Quando estou desenhando formulários, quero exibir a caixa de ferramentas e a lista de tarefas. Quando estiver escrevendo código, gosto de ocultar todas as janelas com exceção da lista de tarefas. Abrir, fechar e mover janelas constantemente, conforme o que estou fazendo no momento, pode ser frustrante e consumir tempo.

O Visual Studio inclui o conceito de layouts de janela. Podemos notar que quando começamos a depuração, as janelas voltarão automaticamente para o layout em que estavam na última sessão de depuração. Isso acontece porque o Visual Studio inclui um layout normal e outro de janela de depuração. Não seria bom se houvessem layouts adicionais que poderíamos usar quando estamos codificando ou projetando? Bem, isto é exatamente o que o VSWindowManager PowerToy faz.

Depois de instalar o VSWindowManager PowerToy, veremos algumas novas opções no menu Window, como mostrado na Figura 7.

Figura 7. Os comandos de layout do VSWindowManager

O menu Save Window Layout provê comandos que permitem salvar o layout atual das janelas. Para iniciar o uso deste power toy, monte suas janelas do modo usado para design e então selecione o comando de menu Windows | Save Window Layout As | My Design Layout. Isto salvará o layout atual. Faça o mesmo para o seu layout de codificação favorito (selecionando My Coding Layout), podendo configurar até três layouts personalizados diferentes.

O VSWindowManager alternará automaticamente entre os layouts de design e de codificação, conforme trabalhamos com um design ou com um arquivo de código. Podemos também usar o comando Apply Window Layout para escolher os layouts já salvos. Quando selecionarmos um dos layouts salvos, o VSWindowManager automaticamente ocultará, mostrará e ajustará as janelas para exibir o layout desejado.

O VSWindowManager PowerToy é muito simples, mas pode economizar muito tempo e frustração. O VSWindowManager está disponível em workspaces.gotdotnet.com/vswindowmanager.

WSContractFirst

O Visual Studio torna a criação dos Web Services incrivelmente fácil: criamos um arquivo .asmx, adicionamos algum código e pronto. O ASP.NET irá criar então um arquivo Web Service Description Language (WSDL) descrendo o comportamento e padrões de mensagem para o Web Service.

Porém surgem alguns problemas ao deixar o ASP.NET gerar esse arquivo. O problema principal é que não temos mais controle sobre o "contrato" criado para o Web Service. É aqui que o desenvolvimento contract-first vem nos auxiliar. O desenvolvimento contract-first, também chamado de desenvolvimento orientado a contrato (contract-driven development) é a prática de escrever o contrato (o arquivo WSDL) para um Web Service antes de escrever o próprio Web Service. Ao escrever nosso próprio arquivo WSDL, temos o controle total quanto a como o Web Service será visto e usado, inclusive a interface e estruturas de dados que estarão expostas.

Escrever um documento WSDL não é muito divertido. É bom escrever um contrato, mas isso demanda muito código XML. É aqui onde o WSContractFirst entra em jogo. O WSContractFirst torna mais fácil escrever arquivos WSDL, e gera o código do lado cliente e do lado servidor, baseado no arquivo WSDL. Teremos o melhor de ambos os mundos: controle sobre o contrato e o estilo de desenvolvimento rápido de Web Services disponível no Visual Studio.

O primeiro passo para usarmos o WSContractFirst é criar os arquivos de schema XML. Esses arquivos definirão a mensagem ou mensagens que serão usadas nos Web Services. O Visual Studio tem uma interface GUI fácil de usar para definir os schemas, isso é particularmente útil por ser um dos passos fundamentais do processo de desenvolvimento de Web Services. Uma vez definidos os schemas, simplesmente clicamos de direita num deles e escolhemos Create WSDL Interface Description. Isso iniciará o Generate WSDL Wizard. O primeiro passo é mostrado na Figura 8.

Figura 8. Construindo um arquivo WSDL com o WSContractFirst

O passo 1 coleta os dados básicos sobre o service, incluindo nome, namespace e documentação. O passo 2 permite especificar o arquivo .xsd a incluir no service. O schema selecionado para iniciar esse assistente é incluído por padrão. O passo 3 permite especificar as operações do service. Podemos nomear essa operação assim como especificar se é uma operação de "mão única" ou de request/response. O passo 4 permite entrar os detalhes para as operações e mensagens. O passo 5 permite especificar se um elemento <service> deve ser criado e o diálogo de geração de código deve ou não ser iniciado automaticamente quando o assistente for finalizado. O passo 6 permite especificar caminhos alternativos de .xsd. Uma vez completado o assistente, o novo arquivo WSDL é adicionado ao projeto.

Agora que temos o arquivo WSDL, ainda há algumas coisas que o WSContractFirst pode fazer. Para iniciar a parte de geração de código do WSContractFirst, precisamos clicar de direita no arquivo WSDL e selecionar Generate Web Service Code. Isso iniciará a caixa de diálogo de geração de código mostrada na Figura 9.

Figura 9. Opções de geração de código do WSContractFirst

Podemos escolher gerar um proxy no lado cliente ou um stub, bem como configurar algumas outras opções do código e quais recursos serão incluídos. O uso dos recursos de geração de código agilizará tremendamente o desenvolvimento.

Se estivermos desenvolvendo Web Services usando o Visual Studio, definitivamente deveríamos analisar o WSContractFirst e o desenvolvimento contract-first. O WSContractFirst foi escrito por Christian Weyer de Thinktecture e seu download pode ser feito de www.thinktecture.com/Resources/Software/WSContractFirst/default.html.

VSMouseBindings

O mouse pode ter até cinco botões, portanto, por que só estamos usando três deles? O VSMouseBindings é um power toy que provê uma interface fácil de usar, a qual permite associar cada um dos botões do mouse a um comando do Visual Studio.

O VSMouseBindings faz uso extensivo do command pattern. Podemos associar botões do mouse a vários comandos, tais como abrir um novo arquivo, copiar o texto selecionado para a área de transferência, ou quase qualquer outra coisa que possa ser feita no Visual Studio. Depois de instalar o VSMouseBindings, veremos uma nova seção na caixa de diálogo Options, chamada VsMouseBindings. A interface pode ser vista na Figura 10.

Figura 10. Opções do VSMouseBindings para o Visual Studio

Como podemos ver, pode ser selecionado um comando para cada um dos botões principais. Possivelmente não desejaremos re-configurar os botões esquerdo e direito do mouse, pois suas funcionalidades normais são úteis. Porém, os botões voltar e avançar estão "implorando para serem atribuídos a outros comandos. Se gostarmos de ter funcionalidades semelhantes aos botões avançar e voltar do navegador, podemos associar os botões aos comandos Navigate.Backward e Navigate.Forward do Visual Studio.

O Use this mouse shortcut no menu permite definir o escopo das configurações. Isso significa que podemos realizar configurações diferentes quando estivermos no HTML Designer, em oposição a quando estamos trabalhando no editor de código.

O VSMouseBindings está disponível em www.gotdotnet.com/team/ide/#original.

CopySourceAsHTML

Códigos são exponencialmente mais legíveis quando certas partes são diferenciadas do resto via uso de esquema de cores. Ler código em Visual Studio, geralmente é muito mais fácil do que ler código em um editor como o Notepad.

Possivelmente poderemos ter nosso próprio blog, ou pelo menos ter gasto algum tempo lendo-o. Normalmente, quando tentamos submeter um trecho de código interessante ao blog, o mesmo terá a aparência de texto simples, não sendo a coisa mais fácil de se ler. É aqui que o add-in CopySourceAsHTML entra em jogo. Este add-in permite copiar código como HTML, significando que podemos enviá-lo facilmente para um blog ou Web site e manter o esquema de cores aplicado pelo Visual Studio.

Depois de instalar o CopySourceAsHTML, simplesmente selecionamos o código desejado e a seguir o comando Copy Source as HTML do menu de contexto . Depois de selecionar essa opção, aparecerá a caixa de diálogo mostrada na Figura 11.

Figura 11. Opções do CopySourceAsHTML

Aqui podemos escolher algumas opções para a criação do HTML. Podemos incluir números de linha, tamanhos de aba e muitas outras configurações. Depois de clicar OK, o HTML é armazenado na área de transferência. Por exemplo, suponha o seguinte trecho de código no Visual Studio:

private long Add(int d, int d2)
{
    return (long) d + d2;
}

Figura 12. Código HTML formatado

Depois de selecionamos Copy As HTML e configuramos o HTML para incluir os números de linha, o código será semelhante ao da Figura 12.

O CopySourceAsHTML foi escrito por Colin Coller e seu download pode ser feito de www.jtleigh.com/CopySourceAsHtml.

Cache Visualizer

O Visual Studio 2005 inclui um novo recurso de depuração chamado visualizers (visualizadores), que pode ser usado para criar uma visão de dados legível por pessoas, para uso durante o processo de depuração. O Visual Studio 2005, por padrão, inclui vários visualizadores no depurador, com destaque para o visualizador de DataSet, o qual tem uma interface tabular para visualizar e editar os dados dentro de um DataSet. Apesar de os visualizadores padrão serem muito valiosos, talvez a melhor parte dessa nova interface seja que a mesma é completamente extensível. Com muito pouco trabalho, podemos escrever nossos próprios visualizadores para tornar mais fácil a depuração.

Enquanto muitos usuários escrevem visualizadores personalizados para seus próprios tipos complexos, alguns desenvolvedores já estão disponibilizando visualizadores para partes do Framework. Vamos observar um dos visualizadores já disponível construído pela comunidade e ver como pode ser usado para tornar muito mais fácil a depuração.

O cache do ASP.NET representa uma coleção de objetos que estão sendo armazenados para uso posterior. Cada objeto tem algumas configurações armazenadas, tais como o tempo de permanência para qualquer dependência de cache. Não existe um modo fácil durante a depuração de se ter uma idéia do que está no cache, quanto tempo estará lá ou o que estamos visualizando. Brett Johnson constatou esse lapso e escreveu o cache Visualizer para examinar o cache do ASP.NET.

Uma vez carregado e instalado o visualizador, veremos um novo ícone aparecer próximo ao objeto cache dentro da janela de depuração, como mostrado na Figura 13.

Figura 13. Selecionando o Cache Visualizer durante a depuração

Quando clicarmos na lupa para usar o Cache Visualizer, uma caixa de diálogo aparecerá, a qual inclui informações atualizadas a respeito de todos os objetos armazenados no cache do ASP.NET, como podemos ver na Figura 14.

Figura 14. O Cache Visualizer mostra os objetos no cache do ASP.NET

Em Public Cache Entries, podemos ver as entradas acrescentadas ao cache. As entradas em Private Cache Entries são adicionadas pelo ASP.NET. Note que podemos ver informações de expiração, assim como a dependência de arquivos para a entrada de cache.

O Cache Visualizer é uma grande ferramenta para trabalhar com o ASP.NET. Também é um dos melhores visualizadores já desenvolvidos pela comunidade. Podemos obter o Cache Visualizer no blog de Brett em blog.bretts.net.

Para finalizar

Este artigo foi dedicado aos add-ins gratuitos disponíveis para o Visual Studio, existe também um grande número de add-ins que podem ser comprados por um preço razoável. Encorajamos a verificação destas e outras opções, que em alguns casos podem acrescentar uma tremenda funcionalidade a IDE. Neste artigo, vimos rapidamente alguns dos melhores add-ins gratuitos disponíveis para o Visual Studio. Cada add-in faz só uma pequena coisa, mas juntos ajudarão a aumentar a produtividade e permitirão escrever melhor código.

James Avery é consultor .NET pela Infozerk Inc. Escreveu vários livros e artigos. O seu mais recente livro é o Visual Studio Hacks (O'Reilly, 2005). Pode ser contatado pelo e-mail javery@infozerk.com . Blog: www.dotavery.com/blog