Apostila Visual Studio - _pt-br

Visual Studio 1

ÍNDICE CONTROLE DE CÓDIGO FONTE PARA O VISUAL STUDIO......................................................................... 6

INTRODUÇÃO AO CONTROLE DE ORIGEM ................................................................................................................... 6 O QUE HÁ DE NOVO NO CONTROLE DE ORIGEM PARA O VISUAL STUDIO ................................................................. 13 EXECUÇÃO DE TAREFAS DE CONTROLE DE ORIGEM ............................................................................................... 14 COMO: ADICIONAR UM PROJETO AO CONTROLE DE ORIGEM.................................................................................. 14 COMO: ACOPLAR OU DESACOPLAR UMA SOLUÇÃO OU PROJETO ............................................................................ 15 COMO: ALTERAR O LOCAL DA PASTA DE TRABALHO ............................................................................................. 16 COMO CONECTAR OU DESCONECTAR UMA SOLUÇÃO OU UM PROJETO..................................................................... 16 COMO: COPIAR UM ITEM SOB CONTROLE DE ORIGEM............................................................................................. 17 COMO: EXCLUIR UM ITEM CONTROLADO POR ORIGEM........................................................................................... 18 COMO ATIVAR RECUPERAÇÃO AUTOMÁTICA........................................................................................................... 19 COMO DESATIVAR A CRIAÇÃO DA PASTA <SOLUTIONNAME>.ROOT ........................................................................ 19 COMO: ATIVAR CHECK-INS AUTOMÁTICOS........................................................................................................... 19 COMO: DESATIVAR CHECK-OUTS AUTOMÁTICOS................................................................................................... 20 COMO: ATIVAR OU DESATIVAR CONTROLE DE ORIGEM.......................................................................................... 20 COMO: EXCLUIR UM ARQUIVO DE CONTROLE DE ORIGEM...................................................................................... 21 COMO: MOVER UMA RAIZ DE LIGAÇÃO DE PROJETO .............................................................................................. 21 COMO: MOVER UM ITEM CONTROLADO POR FONTE ............................................................................................... 22 COMO: ABRIR UM PROJETO OU SOLUÇÃO DO CONTROLE DE ORIGEM ..................................................................... 22 COMO: RENOMEAR UM ITEM CONTROLADO POR ORIGEM ...................................................................................... 23 COMO: DEFINIR OPÇÕES DE PLUG-IN...................................................................................................................... 24 COMO: TROCAR PLUG-INS DE CONTROLE DE ORIGEM:............................................................................................. 25 COMO: EXIBIR UMA LISTA DE ARQUIVOS COM CHECK-OUT.................................................................................... 25 REFERÊNCIA A INTERFACE DO USUÁRIO DO CONTROLE DE ORIGEM........................................................................ 25 CAIXA DE DIÁLOGO CHANGE SOURCE CONTROL .................................................................................................... 26 CAIXA DE DIÁLOGO CHECK IN (CONTROLE DE CÓDIGO FONTE) ............................................................................. 27 CHECK-OUT PARA A CAIXA DE DIÁLOGO EDIT (CONTROLE DE ORIGEM).................................................................. 28 CAIXA DE DIÁLOGO GET (CONTROLE DE ORIGEM)................................................................................................... 29 JANELA DE CHECK-INS PENDENTES ......................................................................................................................... 30 GUIAS DE PLUG-IN PARA CONTROLE DE ORIGEM (CAIXA DE DIÁLOGO OPTIONS)..................................................... 31 CAIXA DE DIÁLOGO SOURCE CONTROL................................................................................................................... 34 CAIXA DE DIÁLOGO UNDO CHECKOUT (CONTROLE DE CÓDIGO FONTE)................................................................. 35

CONFIGURAÇÕES DO VISUAL STUDIO.......................................................................................................... 36 COMO: ALTERAR CONFIGURAÇÕES SELECIONADAS ................................................................................................ 37 TRABALHANDO COM CONFIGURAÇÕES.................................................................................................................... 38 COMO: COMPARTILHAR CONFIGURAÇÕES ENTRE COMPUTADORES ....................................................................... 38 COMO: ESPECIFICAR CONFIGURAÇÕES PARA UMA EQUIPE ...................................................................................... 40 IMPORT AND EXPORT SETTINGS WIZARD................................................................................................................ 40 ESCOLHA CONFIGURAÇÕES PARA EXPORTAR, IMPORTAR E EXPORTAR CONFIGURAÇÕES ASSISTENTE.................... 41 NOMEIE O ARQUIVO DE CONFIGURAÇÕES, IMPORTAR E EXPORTAR CONFIGURAÇÕES ASSISTENTE ......................... 41 SALVAR CONFIGURAÇÕES ATUAIS, IMPORTAR E ASSISTENTE PARA EXPORTAÇÃO CONFIGURAÇÕES....................... 41 ESCOLHA CONFIGURAÇÕES PARA IMPORTAR, IMPORTAR E ASSISTENTE CONFIGURAÇÕES EXPORTAÇÃO ............... 42 ESCOLHA UM COLEÇÃO DE CONFIGURAÇÕES PARA IMPORTAR, IMPORTAR E ASSISTENTE CONFIGURAÇÕES EXPORTAÇÃO .......................................................................................................................................................... 42 <TASK> COMPLETE, IMPORT AND EXPORT SETTINGS WIZARD ............................................................................... 43

WALKTHROUGHS VISUAL C# ........................................................................................................................... 44 EXPLICAÇÃO PASSO A PASSO: CRIANDO UM XML WEB SERVICES USANDO VISUAL BASIC OU VISUAL C#........... 44 PASSO-A-PASSO: ACESSANDO UM XML WEB SERVICES UTILIZANDO VISUAL BASIC OU VISUAL C# ..................... 48 UM COMPONENTE COM VISUAL C# WALKTHROUGH: CRIAÇÃO .............................................................................. 53 TAREFAS COMUNS USANDO MARCAS INTELIGENTES EM CONTROLES FORMS WINDOWS FAZENDO WALKTHROUGH:................................................................................................................................................................................ 57 COLEÇÕES DOS TIPOS PADRÃO COM O DESIGNERSERIALIZATIONVISIBILITYATTRIBUTE SERIALIZING WALKTHROUGH:..................................................................................................................................................... 58 WALKTHROUGH: DEPURAÇÃO CONTROLES FORMS DO WINDOWS PERSONALIZADOS EM TEMPO DE DESIGN ........... 61 CRIANDO UM CONTROLE DO WINDOWS FORMS QUE TAKES ADVANTAGE DOS RECURSOS DE TEMPO DE DESIGN VISUAL STUDIO WALKTHROUGH:............................................................................................................................ 64 UM CONTROLE COMPOSTO COM VISUAL C# WALKTHROUGH: CRIAÇÃO................................................................. 84 UM COMPONENTE MULTITHREADED SIMPLE COM VISUAL C# WALKTHROUGH: CRIAÇÃO ..................................... 92

Visual Studio 2

WALKTHROUGH: INHERITING A PARTIR DE UM CONTROLE DO WINDOWS FORMS COM VISUAL C# ...................... 100 EXPLICAÇÕES PASSO-A-PASSO DO VISUAL STUDIO .............................................................................. 104

WALKTHROUGHS DE APLICATIVOS CLIENTE RICH ................................................................................................ 104 WALKTHROUGH: CRIANDO UM APLICATIVO CLIENTE RICH COM MFC ................................................................. 105

WALKTHROUGHS APPLICATION DE FORMULÁRIOS DA WEB ........................................................... 114 EXPLICAÇÃO PASSO A PASSO: CRIANDO UMA PÁGINA WEB BÁSICA NO VISUAL WEB DEVELOPER.......................................................................................................................................................... 115 PASSO-A-PASSO: ACESSO A DADOS BÁSICO EM PÁGINAS DA WEB................................................... 124 PASSO-A-PASSO: LIGAÇÃO DE DADOS PARA UM OBJETO CORPORATIVO PERSONALIZADO . 134 EXPLICAÇÃO PASSO A PASSO: DEPURAÇÃO DE PÁGINAS DA WEB NO VISUAL WEB DEVELOPER.......................................................................................................................................................... 141 PASSO-A-PASSO: CRIANDO E USANDO PÁGINAS MESTRAS DO ASP.NET NO VISUAL WEB DEVELOPER.......................................................................................................................................................... 148 PASSO-A-PASSO: PERSONALIZANDO UM SITE USANDO TEMAS NO VISUAL STUDIO.................. 159 EXPLICAÇÃO PASSO A PASSO: CRIANDO UMA PÁGINA WEB PARTS NO VISUAL WEB DEVELOPER.......................................................................................................................................................... 165 EXPLICAÇÃO PASSO A PASSO: CRIANDO UM SITE WEB COM ASSOCIAÇÃO E LOGIN DE USUÁRIO (VISUAL STUDIO) ............................................................................................................................. 175 PASSO-A-PASSO: CRIANDO E USANDO UM SERVIÇO DA WEB ASP.NET NO VISUAL WEB DEVELOPER.......................................................................................................................................................... 188 CRIANDO E ACESSANDO EXPLICAÇÕES PASSO A PASSO DE XML WEB SERVICES ..................... 196 EXPLICAÇÃO PASSO A PASSO: CRIANDO UM XML WEB SERVICES USANDO VISUAL BASIC OU VISUAL C#.............................................................................................................................................................. 197 PASSO-A-PASSO: CRIANDO UM XML WEB SERVICE USANDO C++ E O CLR .................................... 202 WALKTHROUGH: CRIANDO UM SERVIÇO DA WEB XML USANDO ATL SERVER.......................... 207 PASSO-A-PASSO: ACESSANDO UM XML WEB SERVICE USANDO C++ E O CLR............................... 211 PASSO-A-PASSO: ACESSANDO UM XML WEB SERVICE USANDO C++................................................ 215 PASSO-A-PASSO: CRIANDO UM APLICATIVO DISTRIBUÍDO ................................................................ 220 CONTROLE DE CÓDIGO FONTE PARA O VISUAL STUDIO..................................................................... 228

INTRODUÇÃO AO CONTROLE DE ORIGEM ............................................................................................................... 228 O QUE HÁ DE NOVO NO CONTROLE DE ORIGEM PARA O VISUAL STUDIO ............................................................... 235 EXECUÇÃO DE TAREFAS DE CONTROLE DE ORIGEM ............................................................................................. 236 COMO: ADICIONAR UM PROJETO AO CONTROLE DE ORIGEM................................................................................ 236 COMO: ACOPLAR OU DESACOPLAR UMA SOLUÇÃO OU PROJETO .......................................................................... 237 COMO: ALTERAR O LOCAL DA PASTA DE TRABALHO ........................................................................................... 238 COMO CONECTAR OU DESCONECTAR UMA SOLUÇÃO OU UM PROJETO................................................................... 238 COMO: COPIAR UM ITEM SOB CONTROLE DE ORIGEM........................................................................................... 239 COMO: EXCLUIR UM ITEM CONTROLADO POR ORIGEM......................................................................................... 240 COMO ATIVAR RECUPERAÇÃO AUTOMÁTICA......................................................................................................... 240 COMO DESATIVAR A CRIAÇÃO DA PASTA <SOLUTIONNAME>.ROOT ...................................................................... 241 COMO: ATIVAR CHECK-INS AUTOMÁTICOS......................................................................................................... 241 COMO: DESATIVAR CHECK-OUTS AUTOMÁTICOS................................................................................................. 242 COMO: ATIVAR OU DESATIVAR CONTROLE DE ORIGEM........................................................................................ 242 COMO: EXCLUIR UM ARQUIVO DE CONTROLE DE ORIGEM.................................................................................... 243 COMO: MOVER UMA RAIZ DE LIGAÇÃO DE PROJETO ............................................................................................ 243 COMO: MOVER UM ITEM CONTROLADO POR FONTE ............................................................................................. 244 COMO: ABRIR UM PROJETO OU SOLUÇÃO DO CONTROLE DE ORIGEM ................................................................... 244 COMO: RENOMEAR UM ITEM CONTROLADO POR ORIGEM .................................................................................... 245 COMO: DEFINIR OPÇÕES DE PLUG-IN.................................................................................................................... 246 COMO: TROCAR PLUG-INS DE CONTROLE DE ORIGEM:........................................................................................... 247 COMO: EXIBIR UMA LISTA DE ARQUIVOS COM CHECK-OUT.................................................................................. 247 REFERÊNCIA A INTERFACE DO USUÁRIO DO CONTROLE DE ORIGEM...................................................................... 247

Visual Studio 3

CAIXA DE DIÁLOGO CHANGE SOURCE CONTROL .................................................................................................. 247 CAIXA DE DIÁLOGO CHECK IN (CONTROLE DE CÓDIGO FONTE) ........................................................................... 249 CHECK-OUT PARA A CAIXA DE DIÁLOGO EDIT (CONTROLE DE ORIGEM)................................................................ 250 CAIXA DE DIÁLOGO GET (CONTROLE DE ORIGEM)................................................................................................. 251 JANELA DE CHECK-INS PENDENTES ....................................................................................................................... 252 GUIAS DE PLUG-IN PARA CONTROLE DE ORIGEM (CAIXA DE DIÁLOGO OPTIONS)................................................... 253 CAIXA DE DIÁLOGO SOURCE CONTROL................................................................................................................. 256 CAIXA DE DIÁLOGO UNDO CHECKOUT (CONTROLE DE CÓDIGO FONTE)............................................................... 257

CONFIGURAÇÕES DO VISUAL STUDIO........................................................................................................ 259 COMO: ALTERAR CONFIGURAÇÕES SELECIONADAS .............................................................................................. 260 TRABALHANDO COM CONFIGURAÇÕES.................................................................................................................. 261 COMO: COMPARTILHAR CONFIGURAÇÕES ENTRE COMPUTADORES ..................................................................... 261 COMO: ESPECIFICAR CONFIGURAÇÕES PARA UMA EQUIPE .................................................................................... 263 IMPORT AND EXPORT SETTINGS WIZARD.............................................................................................................. 263 ESCOLHA CONFIGURAÇÕES PARA EXPORTAR, IMPORTAR E EXPORTAR CONFIGURAÇÕES ASSISTENTE.................. 264 NOMEIE O ARQUIVO DE CONFIGURAÇÕES, IMPORTAR E EXPORTAR CONFIGURAÇÕES ASSISTENTE ....................... 264 SALVAR CONFIGURAÇÕES ATUAIS, IMPORTAR E ASSISTENTE PARA EXPORTAÇÃO CONFIGURAÇÕES..................... 264 ESCOLHA CONFIGURAÇÕES PARA IMPORTAR, IMPORTAR E ASSISTENTE CONFIGURAÇÕES EXPORTAÇÃO ............. 265 ESCOLHA UM COLEÇÃO DE CONFIGURAÇÕES PARA IMPORTAR, IMPORTAR E ASSISTENTE CONFIGURAÇÕES EXPORTAÇÃO ........................................................................................................................................................ 265 <TASK> COMPLETE, IMPORT AND EXPORT SETTINGS WIZARD ............................................................................. 266

GERENCIAR SOLUÇÕES, PROJETOS E ARQUIVOS................................................................................... 267 INTRODUÇÃO AO SOLUÇÕES, PROJETOS, E ITENS ................................................................................................... 267 PROPRIEDADES DE PROJETO (VISUAL STUDIO) ..................................................................................................... 269 GERENCIANDO PROPRIEDADES DE PROJETO COM O DESIGNER DE PROJETO ........................................................... 269 GERENCIANDO PROPRIEDADES DE APLICATIVO..................................................................................................... 269 COMO: ESPECIFICAR INFORMAÇÕES DE ASSEMBLY.............................................................................................. 269 COMO ALTERAR UM NOME DE CONJUNTO: ............................................................................................................ 269 COMO: ALTERAR O NAMESPACE PARA UM APLICATIVO ....................................................................................... 270 COMO: ALTERAR O TIPO DE APLICATIVO ............................................................................................................. 270 COMO: ALTERAR O OBJETO DE INICIALIZAÇÃO PARA UM APLICATIVO ................................................................ 271 COMO: ESPECIFICA UM ÍCONE DE APLICATIVO..................................................................................................... 272 COMO: ATIVAR ESTILOS VISUAIS ........................................................................................................................ 272 COMO: ESPECIFICAR COMPORTAMENTO DE INSTÂNCIAS PARA UM APLICATIVO .................................................. 273 COMO: ATIVAR AUTENTICAÇÃO DE USUÁRIO PERSONALIZADA ........................................................................... 274 COMO: ESPECIFICAR O COMPORTAMENTO DE DESLIGAMENTO PARA UM APLICATIVO......................................... 274 GERENCIANDO REFERÊNCIAS ................................................................................................................................ 275 REFERÊNCIAS DE PROJETO .................................................................................................................................... 275 SOLUCIONANDO PROBLEMAS DE REFERÊNCIAS QUEBRADAS................................................................................. 276 COMO: ADICIONAR OU REMOVER REFERÊNCIAS NO VISUAL STUDIO .................................................................. 278 COMO: ADICIONAR OU REMOVER NAMESPACES IMPORTADOS............................................................................. 280 COMO: REMOVER REFERÊNCIAS NÃO USADAS................................................................................................... 281 COMO: DEFINIR A PROPRIEDADE COPY LOCAL (COPIAR LOCALMENTE) DE UMA REFERÊNCIA ........................... 282 GERENCIANDO RECURSOS DE APLICATIVO ........................................................................................................... 283 COMO: ADICIONAR OU REMOVER RECURSOS....................................................................................................... 283 COMO: ADICIONAR OU REMOVER RECURSOS DE SEQÜÊNCIA DE CARACTERES..................................................... 285 COMO: EDITAR RECURSOS .................................................................................................................................. 286 COMO: EDITAR RECURSOS QUE SÃO SEQÜÊNCIAS DE CARACTERES ..................................................................... 288 COMO: ASSOCIAR UM EDITOR COM UM TIPO DE RECURSO ................................................................................... 289 RECURSOS VINCULADOS VERSUS RECURSOS INCORPORADOS .............................................................................. 290 COMO: CRIAR RECURSOS INCORPORADOS........................................................................................................... 291 COMO: IMPORTAR OU EXPORTAR RECURSOS ....................................................................................................... 291 GERENCIANDO DEFINIÇÕES DO APLICATIVO.......................................................................................................... 292 CONFIGURAÇÕES DE APLICATIVO.......................................................................................................................... 293 COMO: ADICIONAR OU REMOVER CONFIGURAÇÕES DE APLICATIVO ................................................................... 295 COMO: ACESSAR EVENTOS DE CONFIGURAÇÃO................................................................................................... 296 GERENCIANDO PROPRIEDADES DE PROJETO C# E J#.............................................................................................. 297 COMO DEFINIR PROPRIEDADES DO PROJETO (C#, J#):............................................................................................ 297 COMO: DEFINIR O CAMINHO DE REFERÊNCIA (C#, J#)........................................................................................ 298 COMO: DEFINIR AS PROPRIEDADES DE COMPILAÇÃO (C#, J#) ............................................................................ 299 COMO: ESPECIFICAR EVENTOS DE COMPILAÇÃO ................................................................................................. 300

Visual Studio 4

COMO: ADICIONAR E REMOVER REFERÊNCIAS NO VISUAL STUDIO (C#, J#)........................................................ 300 LOCAL E PROJETOS DA WEB.................................................................................................................................. 301 PROPRIEDADES DE ARQUIVO ................................................................................................................................. 302 TIPOS DE ARQUIVOS E EXTENSÕES DE ARQUIVOS NO VISUAL BASIC, VISUAL C#, E VISUAL J#............................. 304 MODELOS DE PROJETO PADRÃO NO VISUAL STUDIO ............................................................................................. 310 COMO: RESTAURAÇÃO DE MODELOS DE PROJETO PADRÃO ................................................................................. 311 MODELO CLASS LIBRARY..................................................................................................................................... 312 MODELO DE APLICATIVO DE CONSOLE .................................................................................................................. 312 MODELO EMPTY PROJECT..................................................................................................................................... 312 MODELO DE BIBLIOTECA DE CONTROLES DA WEB ................................................................................................ 313 MODELO DE APLICATIVO WINDOWS..................................................................................................................... 313 MODELO DE CONTROLE DE BIBLIOTECA DO WINDOWS ........................................................................................ 313 MODELO DE SERVIÇO DO WINDOWS..................................................................................................................... 313 REFERENCIANDO NAMESPACES E COMPONENTES................................................................................................. 313 REFERÊNCIAS DE PROJETO .................................................................................................................................... 314 SOLUCIONANDO PROBLEMAS DE REFERÊNCIAS QUEBRADAS................................................................................. 314 CONVENÇÕES DE NOMENCLATURA PARA ARQUIVO DE RECURSO .......................................................................... 316 RECURSOS XML ................................................................................................................................................... 317 RECURSOS NÃO-XML........................................................................................................................................... 317 CONFIGURANDO APLICATIVOS USANDO PROPRIEDADES DINÂMICAS..................................................................... 317 INTRODUÇÃO A PROPRIEDADES DINÂMICAS (VISUAL STUDIO).............................................................................. 317

PERSONALIZAR E AUTOMATIZAR O AMBIENTE DE DESENVOLVIMENTO .................................... 323 PERSONALIZAR O AMBIENTE DE DESENVOLVIMENTO............................................................................................ 323 COMO: PERSONALIZAR AJUDA DINÂMICA............................................................................................................. 324 COMO PERSONALIZAR BARRAS DE FERRAMENTAS VISUAL STUDIO (): .................................................................. 327 COMO INICIAR FERRAMENTAS NO VISUAL STUDIO: .............................................................................................. 329 COMO PERSONALIZAR A SEÇÃO DE NOTÍCIAS DA PÁGINA INICIAR:........................................................................ 331 COMO ALTERAR O ITEM EXIBIDO EM INICIAR BACKUP DO AMBIENTE DE DESENVOLVIMENTO DO:........................ 331 TRABALHANDO COM CONFIGURAÇÕES.................................................................................................................. 332 COMO: COMPARTILHAR CONFIGURAÇÕES ENTRE COMPUTADORES ..................................................................... 340 COMO: ALTERAR CONFIGURAÇÕES SELECIONADAS .............................................................................................. 342 COMO: ESPECIFICAR CONFIGURAÇÕES PARA UMA EQUIPE .................................................................................... 342 GERENCIAMENTO DE JANELA................................................................................................................................ 343 TIPOS JANELA........................................................................................................................................................ 343 COMO: ORGANIZAR E ANCORAR JANELAS ........................................................................................................... 345 HOW TO: WINDOWS IDE DE LISTA E ARQUIVOS ACTIVE..................................................................................... 349 CAIXA DE DIÁLOGO DO WINDOWS VISUAL STUDIO ()........................................................................................... 350 CAIXA DE DIÁLOGO COLUNAS ............................................................................................................................... 351 CAIXA DE DIÁLOGO COLUNAS DE CLASSIFICAÇÃO ................................................................................................ 352 COMO: NAVEGAR DENTRO DO AMBIENTE DE DESENVOLVIMENTO INTEGRADO ................................................... 353 AUTOMAÇÃO E EXTENSIBILIDADE PARA VISUAL STUDIO...................................................................................... 353 ESTENDENDO O AMBIENTE VISUAL STUDIO .......................................................................................................... 353 O QUE HÁ DE NOVO NO EXTENSIBILIDADE E AUTOMAÇÃO DO VISUAL STUDIO 2005............................................. 354 NOVOS MEMBROS DE AUTOMAÇÃO PARA VISUAL STUDIO 2005 ........................................................................... 356 PRÁTICAS RECOMENDADAS PARA SEGURANÇA NA AUTOMAÇÃO .......................................................................... 368 O ESPECTRO DE AUTOMAÇÃO VISUAL STUDIO...................................................................................................... 369 ESCOLHENDO A ABORDAGEM DE AUTOMAÇÃO ADEQUADA .................................................................................. 371 FUNCIONAL GRUPOS DE AUTOMAÇÃO ................................................................................................................... 372 ACESSANDO O MODELO DE AUTOMAÇÃO POR USANDO MACROS........................................................................... 373 CRIANDO ADD-INS E ASSISTENTES ........................................................................................................................ 374 REFERÊNCIA CONJUNTOS DE AUTOMAÇÃO E O OBJETO DTE2............................................................................... 375 CONTROLAR PROJETOS E SOLUÇÕES...................................................................................................................... 376 CRIANDO E CONTROLLING AMBIENTE WINDOWS.................................................................................................. 377 COMO CRIAR E ANEXAR A OUTRA INSTÂNCIA DO VISUAL STUDIO: ....................................................................... 378 INTRODUÇÃO À EXTENSIBILIDADE DE PROJETO..................................................................................................... 383 BEM-VINDO AO ASSISTENTE SUPLEMENTO, ASSISTENTE PARA ADICIONAR-IN VISUAL STUDIO ........................... 386

VISUAL STUDIO COMANDOS E OPÇÕES...................................................................................................... 389 JANELA DE COMANDO........................................................................................................................................... 391 JANELA IMMEDIATE .............................................................................................................................................. 393 LOCALIZAR / COMANDO CAIXA ............................................................................................................................. 395 COMANDOS GUIA, PERSONALIZAR CAIXA DE DIÁLOGO VISUAL STUDIO ()............................................................ 396

Visual Studio 5

Visual Studio 6

Controle de Código Fonte para o Visual Studio

Sem sair do ambiente de desenvolvimento, você pode gerenciar seus projetos individuais e de equipe facilmente usando os recursos do controle de código fonte do Microsoft Visual Studio. O controle de código fonte do Visual Studio permite que você:

• Gerencie o acesso ao banco de dados. O controle de código fonte do Visual Studio fornece suporte ao acesso de arquivos compartilhados e individuais. Também provê mecanismos para mesclagem de arquivos.

• Recuperar versões sucessivas de itens sob controle de versão. A maioria dos pacotes do controle de código fonte do Visual Studio armazenam dados que distinguem as diferentes versões de um item sob controle de versão.

• Manter o histórico detalhado dos itens sob controle de versão. Muitos pacotes fornecem mecanismos para armazenar e recuperar o histórico de um item, por exemplo, data e hora de criação.

• Trabalhar de modo colaborativo em projetos e soluções. Com o compartilhamento de arquivos, é possível que diferentes projetos e soluções compartilhem o mesmo item sob controle de versão. Alterações feitas em um item compartilhado são refletidas em todos os projetos e soluções.

• Automatizar as operações de controle de código fonte mais comuns. Por exemplo, um pacote do controle de de código fonte do Visual Studio pode definir uma interface de linha de comando que ofereça suporte a recursos importantes do controle de código fonte. Você pode usar essa interface em arquivos em lotes para automatizar as tarefas de controle de código fonte executadas regularmente.

• Recuperar exclusões acidentais. O controle de código fonte do Visual Studio fornece suporte a restauração da última versão do arquivo em que foi realizado o check-in.

• Economizar espaço em disco no pacote do controle de código fonte e no servidor associado.

Introdução ao controle de origem O Visual Studio oferece suporte ao controle de origem usando a camada Visual Studio Integration Protocol (VSIP) no seu Integrated Development Environment (IDE). VSIP pode hospedar uma variedade de pacotes de controle de origem, geralmente implementados como plug-ins escritos para os protocolos apropriados. Um exemplo de um plug-in de controle de origem é o plug-in SourceSafe LAN suportado pelo Visual SourceSafe. Para obter detalhes do plug-in, consulte a ajuda do Visual SourceSafe.

Observação

O Visual Studio trata pacotes de controle de origem como plug-ins, embora eles possam ser implementados como outros tipos de módulos de software.

Visual Studio 7

O controle de origem do Visual Studio é simplesmente um ambiente para plug-ins de controle de origem de terceiros. Por isso, sua funcionalidade só é ativada pela instalação de um plug-in. Para usar um plug-in de controle da origem de terceiros, você deve, geralmente, instalar o aplicativo de terceiros e/ou o(s) plug-in(s) de controle de origem nos computadores cliente e servidor para seu site. Depois de instalar como indicado pelas instruções de terceiros, sua funcionalidade estará disponível através do Visual Studio. As operações que estão ativas são variáveis, dependendo do plug-in de controle de origem. Você deve consultar a documentação de terceiros para detalhes operacionais de pacotes específicos.

Consulte "Visão Geral (controle de origem)" na ajuda do Visual Studio para obter detalhes de design de controle de origem no Visual Studio. Esta seção da Ajuda também fornece todas as informações que serão necessárias para desenvolver um pacote de controle de origem de terceiros que seja compatível com Visual Studio.

Noções básicas de controle de origem suportados pelo Visual Studio

O suporte de controle de origem básico no Visual Studio inclui a configuração de plug-in de controle de origem e opções de ambiente, comutação de plug-in, acesso ao banco de dados, versionamento e manipulação de projetos do Visual Studio, soluções e arquivos e metadados associados. O controle de origem no Visual Studio também aplica protocolos do controle de acessos ao banco de dados, por exemplo, o estilo de trabalho Lock-Modify-Unlock, no qual um usuário que quer modificar um arquivo deve verificá-lo exclusivamente.

É importante lembrar que você deve usar controle de origem em mecanismos do Visual Studio para interagir com um plug-in de controle de origem. Não use outras aplicações de cliente apresentadas por terceiros que forneçam o plug-in, por exemplo, Visual SourceSafe Explorer. O uso apropriado dos mecanismos de controle de origem no Visual Studio garante que somente arquivos corretos sejam adicionados ao controle de origem e que os arquivos de projeto e solução do Visual Studio sejam atualizados com os detalhes corretos do plug-in específico.

Configuração de Plug-in de Controle de Origem e Comutação

O controle de origem do Visual Studio suporta configuração e comutação de plug-in através da entrada Source Control na caixa de diálogo Options. Esta entrada é acessível selecionando-se Options no menu Tools do Visual Studio. Você usará a caixa de diálogo Options para selecionar o plug-in que você deseja utilizar para controle de origem, e configurar as opções de ambiente para o plug-in.

Antes que você e sua equipe possam aproveitar as vantagens dos recursos de controle de origem no Visual Studio IDE, você deve:

• Determinar se qualquer plug-in de controle de origem está disponível.

• Se o plug-in de controle de origem que você deseja usar não estiver instalado em seu computador, instale o produto de terceiros que ofereça suporte ao plug-in e reinicie o Visual Studio para registrá-lo.

• Criar um banco de dados de controle de origem de acordo com a funcionalidade do determinado plug-in.

• Envie um link, com o local do banco de dados, para todos os membros da equipe.

Acesso ao Banco de dados

Comandos básicos de acesso ao banco de dados, por exemplo, Check Out e Add to Source Control, estão disponíveis no menu File do Visual Studio. No entanto, esses comandos são ativados somente depois que você tiver escolhido o plug-in de

Visual Studio 8

controle de origem que deseja usar. Quando você usa um dos comandos básicos de acesso ao banco de dados, o plug-in que você tiver escolhido chama a correspondente funcionalidade de terceiros e/ou o ambiente para concluir a operação associada.

Algumas operações de acesso são ativadas somente com o plug-in selecionado, enquanto outras operações estão somente disponíveis quando você também tiver selecionado um projeto do Visual Studio, solução, ou arquivo no Solution Explorer do Visual Studio. Por exemplo, você pode usar um comando Add to Source Control depois de ter escolhido um plug-in. Entretanto, para usar um comando Check In, você deve ter um item selecionado no Solution Explorer.

Manipulação de arquivo pelo controle de origem

Você pode adicionar os seguintes arquivos ao controle de origem do Visual Studio:

• Arquivos de solução (*.SLN).

• Arquivo de projeto, por exemplo, arquivos *.csproj, *.vbproj.

• Arquivos de configuração de aplicativos com base em XML, usados para controlar comportamento em tempo de execução de um projeto do Visual Studio.

Arquivos que você não pode adicionar ao controle de origem incluem o seguinte:

• Arquivos de opção de solução de usuário (*.suo).

• Arquivos de opção de projeto de usuários, por exemplo, arquivos *.. csproj.user, *. vbproj.user

• Arquivos de informação da Web, por exemplo, *.csproj.webinfo, *. vbproj.webinfo, que controlam o local da raiz virtual de um projeto da Web

• Criar arquivos de saída, por exemplo, arquivos *.dll e *.exe.

A propagação da alteração do espaço para nome

O controle de origem do Visual Studio oferece suporte à propagação de alteração do espaço para nome em plug-ins controle de origem. Propagação de alteração aplica-se a operações de exclusão, renomeação e mudança de local. Quando você solicitar uma operação para qual a propagação de alteração estiver ativada, o plug-in de controle de origem irá alterar a cópia de trabalho do item controlado por fonte, a cópia principal no banco de dados, e as cópias de outros usuários, quando você fizer o check-in no item e os outros usuários o recuperarem.

Como Controle de Origem Trata Soluções e Projetos

Quando você adiciona uma solução ou projeto ao controle de origem, a primeira coisa que um plug-in de controle de origem deve fazer é identificar uma raiz única para o item que está sendo adicionado. Esta raiz é um caminho ao diretório pai de todas as pastas de trabalho e arquivos que compõem a solução ou projeto.

Uma raiz única geralmente mapeia para um caminho físico no disco. Contudo, se uma solução contém arquivos ou projetos que residem em mais de uma unidade de disco, não há nenhuma pasta física à qual uma raiz única pode fazer o mapa. Uma solução pode mapear a unidade de disco, mas a raiz única de um controle de origem, não. Para apoiar esta situação, o controle de origem do Visual Studio apóia o conceito de uma raiz super-unificada. Este tipo da raiz é um contêiner virtual e

Visual Studio 9

todos os projetos e os arquivos em uma solução controlada por fonte estão localizados abaixo dele.

Quando você adiciona uma solução usando um plug-in de controle de origem com recursos avançados, o plug-in cria uma pasta raiz vazia de solução no banco de dados. Esta pasta conterá todos os itens em uma solução controlada por fonte. Por padrão, essa pasta é < nomedasolucao >.root.

Observação

Quando você adicionar um projeto único ao controle de origem, a pasta .root não será criada.

O uso de solução raiz oferece os seguintes benefícios:

• Menos prompt. A solução raiz minimiza o número potencial de ligações de controle de origem para uma solução e, assim, minimiza o número de avisos aos usuários quando você adiciona uma solução para controle de origem e executa outras tarefas.

• Encapsulamento do projeto. A solução raiz garante que todos os projetos em uma solução possam ser identificados como pertencentes ao mesmo conjunto, mesmo quando uma ou mais projetos residam em diferentes partições ou computadores.

Você pode desativar a criação de pasta < nomedasolucao >.root, mas isso não é recomendável. Para mais informações, consulte COMO: desativar a criação da pasta < nomedasolucao>.root.

Soluções no Visual Studio são bem-formadas ou não. Uma solução bem-formada é uma solução para a qual a estrutura hierárquica no disco combina com a sua estrutura no Solution Explorer. Todos os projetos em uma solução bem-formada são armazenados em subpastas da pasta solução no disco. Se a solução é bem-formada quando você a adiciona ao controle de origem, o plug-in do controle de origem cria uma pasta abaixo da pasta *.root para conter as cópias principais de arquivo de solução (*.sln) e arquivos de opção de solução de usuários (*.suo) para a solução. Finalmente, o plug-in de controle de origem cria uma pasta sob a pasta .sln para cada projeto adicional no banco de dados do controle de origem.

Se uma solução não é bem-formada, o plug-in do controle de origem cria uma pasta para a solução e para o seu projeto inicial. Em seguida, as pastas para cada projeto adicional são criadas em paralelo com a pasta de solução.

Modos de exibição de uma solução ou projetos

Visual Studio fornece três modos diferentes de exibição de uma solução controlada por origem ou projeto: design, controle de origem, e físico. Muitas tarefas de controle de origem são mais fáceis de executar quando não há um mapeamento um-para-um entre os elementos individuais desse modo de visualização. Contudo, se você criar as suas soluções e projetos e os acrescentar ao controle de origem usando as configurações padrões do Visual Studio, suas soluções e projetos não serão, necessariamente, organizados do mesmo modo no disco como eles estão no Solution Explorer e no banco de dados.

O modo design de uma solução ou projeto, que você vê no Solution Explorer, é um retrato lógico do conteúdo de uma solução ou projeto. Geralmente, o modo design é limpo e significativo. Arquivos desnecessários estão ocultos e arquivos de vários locais físicos diferentes são colocados em um contêiner de projeto único.

Visual Studio 10

O modo de controle de origem de uma solução ou projeto, que você vê em um aplicativo autônomo, como Visual SourceSafe Explorer, é também um modo de exibição lógico de uma solução ou projeto. Entretanto, o modo de exibição de controle de origem não é, necessariamente, um reflexo do modo de exibição lógico.

O modo de exibição físico de uma solução ou projeto, que você vê no Windows File Explorer, provavelmente não refletirá a estrutura hierárquica da lógica ou visão do controle de origem.

As diretrizes a seguir podem ajudá-lo a obter fidelidade organizacional entre o modos de exibição de design, físico e controle de origem de suas soluções controladas por fonte e projetos:

• Primeiro, crie uma solução em branco e adicione projetos a ela. Isso o ajuda a manter a relação lógica pai-filho entre uma solução e seus projetos no armazenamento. Em seguida, quando você adicionar a solução ao controle de origem, o modo de exibição de controle de origem e design irá espelhar a hierarquia da solução no disco.

• Atribua a cada solução um nome exclusivo e descritivo que se diferencia do nome de cada um dos projetos contidos.

• Evite adicionar arquivos de link para uma solução ou projeto controlado por fonte origem.

• Se possível, armazene todos os arquivos de uma solução ou projeto em uma unidade de disco.

Conexões de controle de origem e ligações

O Visual Studio define uma conexão como uma ligação de dados ativa entre o Visual Studio e um servidor de banco de dados. Quando você adiciona uma solução ou projeto ao controle de origem, o plug-in de controle de origem copia o item e todo o seu conteúdo do disco para o banco de dados. Uma pasta controle de origem é criada para cada pasta que contém um arquivo solução ou projeto. Após adicionar o item, o plug-in de controle de origem vincula sua cópia de trabalho local de uma solução ou projeto à sua versão no banco de dados.

Cada solução controlada por origem tem, pelo menos, uma ligação de controle de origem. No entanto, um item pode ter várias ligações e requerer várias conexões com o banco de dados. O número de vínculos e conexões depende de como você cria a solução inicialmente e se seus projetos e arquivos estão todos salvos na mesma partição.

Como um exemplo de vínculos e conexões, pense em uma solução bem formada de controle de origem, com vários projetos, como uma casa com várias salas. Quando você constrói a casa, você pode instalar uma linha de dados única de alta velocidade de uma sala à rua. Você instala um roteador atrás de um firewall para distribuir a alimentação de dados para outras salas e você paga um provedor de serviços de Internet para conectar sua casa com a Internet.

Você pode pensar em vínculo de controle de origem como representação da linha de dados única criada para a casa. Quando você abre uma solução controlada por fonte, uma conexão é criada através dessa ligação. A conexão estabelece um 'aperto de mão' entre a sua cópia de trabalho da solução no disco e a cópia mestra da solução no banco de dados.

Se uma solução controlada por origem não for bem formada, você pode vê-la como uma casa na qual cada sala é unida à Internet diretamente. Tarifas de Internet são mais caras do que as da casa de conexão única, os custos de manutenção são

Visual Studio 11

superiores, e mudar para um provedor de serviços de Internet diferente é muito mais difícil e demorado.

Idealmente, uma solução e seu projeto compartilham uma ligação de controle de origem única. Soluções Single-Binding são mais gerenciáveis do que soluções Multiple-Binding. Elas tornam mais fácil:

• Desconectar do controle de origem para trabalhar off-line.

• Conectar-se ao banco de dados após a reconexão com a rede.

• Ramificar em uma etapa.

Você pode criar uma solução de multiprojeto com uma ligação única, criando uma solução em branco antes de adicionar seus projetos. Você também pode fazer isso, selecionando a opção Create Directory for Solution na caixa de diálogo New Project, ao criar um par de solução de multiprojeto.

Se você criar um par de solução de multiprojeto em uma etapa e não selecionar a opção Create Directory for Solution na caixa de diálogo New Project (desativado por padrão), uma segunda ligação será criada quando você adicionar um segundo projeto à solução. Uma ligação é criada para o projeto inicial e para a solução. Ligações adicionais são criadas para cada projeto adicional.

Terminologia de controle de origem

A documentação do Visual Studio usa um número de termos para descrever recursos e conceitos de controle de origem. A tabela a seguir define alguns dos termos comuns.

Versão base

A versão do servidor de um arquivo do qual uma versão local é derivada.

Vinculação

Informação que correlaciona uma pasta de trabalho de uma solução ou projeto no disco à pasta no banco de dados.

Ramificação

Processo de criar uma nova versão, ou ramificação, de um arquivo compartilhado ou projeto sob controle de origem. Uma vez que uma ramificação tenha sido criada, as duas versões sob controle de origem terão um histórico compartilhado até um determinado ponto e históricos divergentes após esse ponto.

Conflito

Duas ou mais alterações diferentes para a mesma linha do código em situações em que dois ou mais desenvolvedores tenham feito o check-out e editado o mesmo arquivo.

Conexão

Uma ligação de dados ativa entre um cliente do controle de origem (por exemplo, Visual Studio) e um servidor de banco de dados do controle de origem.

Banco de dados

Local onde todas as cópias mestre, histórico, estruturas de projeto e informações do usuário são armazenados. Um projeto sempre está contido em um banco de dados. Vários projetos podem ser armazenados em um banco de dados, e vários bancos de dados podem ser usados. Outros termos

Visual Studio 12

normalmente usados para um banco de dados são repositório e armazenamento.

Histórico

Registro de alterações de um arquivo desde que ele tenha sido adicionado, inicialmente, no controle de origem. Com o controle de versão, você pode retornar a qualquer ponto no histórico do arquivo e recuperar o arquivo como ele existia até esse momento.

Rótulo

Nome definido pelo usuário anexado a uma versão específica de um item controlado por fonte.

Cópia local

Arquivo em uma pasta de trabalho do usuário para a qual são copiadas alterações antes que seja feito um check-in. Uma cópia local é, às vezes, chamada de uma cópia de trabalho.

Cópia mestra

A versão mais recente do check-in de um arquivo controlado por fonte, em oposição à cópia local de um arquivo em sua pasta de trabalho. Outros termos para cópia mestra são versão do servidor e versão do banco de dados.

Mesclar

Processo de combinar diferenças entre duas ou mais versões modificadas de um arquivo em uma nova versão de arquivo. Mesclar pode afetar diferentes versões do mesmo arquivo ou alterações feitas a uma mesma versão do arquivo.

Arquivo compartilhado

Um arquivo com versões que residem em mais de uma localidade de controle de origem. Outros termos para um arquivo compartilhado são cópia e atalho.

Raiz solução

Uma pasta vazia em um banco de dados que contém todos os itens de uma solução controlada por origem. Por padrão, essa pasta é < nomedasolucao >.root.

Raiz Super-unificada

Um contêiner virtual abaixo do qual todos os projetos e os arquivos em uma solução controlada por origem estão localizados. Por exemplo [SUR]: \. é a raiz super-unificada de uma solução controlada por origem contendo projetos localizados em [SUR]:\C:\Solucao\Proj1 e [SUR]:\D:\Proj2.

Raiz unificada

Um caminho para a pasta pai de todas as pastas de trabalho e arquivos em uma solução ou projeto controlado por origem. Por exemplo, C:\Solucao é a raiz unificada de uma solução controlada por origem contendo arquivos localizados em C:\Solucao, C:\Solucao\Proj1 e C:\Solucao\Proj2.

Pasta de trabalho

Local no qual as cópias locais de itens controlados por origem são armazenados, geralmente no seu próprio computador. Outro termo para uma pasta de trabalho é espaço de trabalho.

Visual Studio 13

O que há de novo no controle de origem para o Visual Studio O Visual Studio tem dado suporte a controle de origem e integração de plug-ins de controle de origem há algum tempo. Entretanto, a versão atual inclui um número de aperfeiçoamentos de integração. Para informações sobre novos recursos da parte de controle de origem do SDK do ambiente Visual Studio, consulte "Novidades para controle de origem"

Alternância de plug-in

Controle de origem agora permite alternar entre todos os tipos de plug-ins de controle de origem em Options no menu Tools. Esta alternância permite a substituição completa da interface do usuário e permite um plug-in por solução.

Melhorias no acesso ao projeto via aberturas assíncronas

Controle de origem do Visual Studio foi aprimorado para abrir soluções de forma assíncrona e refletir o progresso de uma operação de abertura modificando os ícones no Solution Explorer. O recurso de abertura assíncrona marca projetos que ainda estão sendo baixados com uma ampulheta, e marca projetos totalmente baixados para acesso assim que eles estiverem disponíveis. Isso significa que você pode abrir e começar a trabalhar em um projeto mesmo que o Visual Studio esteja ainda abrindo os outros projetos na solução.

Observação

Este recurso está apenas disponível para Visual Basic, C#, J# e projetos da Web e não possui suporte de todos os plug-ins de controle de origem.

Melhorias na caixa de diálogo do Visual Studio para dar suporte a controle de origem

Os seguintes aperfeiçoamentos de acesso a arquivo foram feitos nas caixas de diálogo do Visual Studio:

• Agora você pode adicionar projetos ao controle de origem e abri-los facilmente usando a nova guia Source Control Stores na caixa de diálogo Open Project.

• Você pode adicionar um arquivo existente do controle de origem a um projeto usando a caixa de diálogo Add Existing Item.

• Você pode adicionar automaticamente soluções e projetos ao controle de origem marcando a caixa de seleção Add to Source Control na caixa de diálogo New Project.

Sincronização de exclusões, renomeações e movimentações

Para oferecer suporte a propagação de alteração de namespace, a versão mais recente de controle de origem sincroniza exclusões, renomeações, e movimentações com o banco de dados. Quando você fizer uma alteração você será solicitado a propagar a alteração, enquanto outros usuários poderão sincronizar através de operações de recuperação. Em versões anteriores, se você excluía, renomeava ou movia um item no servidor, ele permanecia na sua pasta de trabalho mesmo após a sincronização.

Melhorias nas operações básicas de controle de origem

Visual Studio 14

Os seguintes aperfeiçoamentos foram feitos nas operações básicas de controle de origem do Visual Studio:

• Você pode agora fazer um check-out de um arquivo de uma pasta de trabalho local sem precisar baixar pela rede a versão mais recente do arquivo no banco de dados.

• Agora checkouts são automáticos e número de solicitações é reduzido.

• Você tem uma opção para configurar o Visual Studio para automaticamente obter do controle de origem a última versão de todos os itens da solução quando você abrir uma solução .

• Você pode configurar o Visual Studio para fazer silenciosamente check-out de arquivos em edição e fazer automaticamente check-in das suas alterações quando você fechar a solução.

Suporte ao Visual Web Developer

O Visual Web Developer pode agora acessar recursos de controle de origem de projeto na Web, como baixar em qualquer local. Em versões anteriores do Visual Studio, o local estava embutido em código para baixar em c:\inetpub\wwwroot.

Consulte também

Execução de Tarefas de Controle de Origem Esta seção descreve tarefas gerais de controle de origem que você pode executar no Visual Studio para qualquer plug-in. Operações básicas de controle de origem como check in, check out e exibição de histórico são amplamente específicas de plug-in, embora essas operações possam fazer uso de alguns dos elementos de interface de usuário padrão suportados pelo pacote de controle de origem do Visual Studio. Para tarefas de plug-in-específico, entretanto, você deve consultar a documentação do plug-in de controle de origem específico.

Observação

Muitos desses procedimentos referem-se à seleção de comandos básicos de controle de origem do menu File do Visual Studio. Alternativamente, você pode acessar muitos dos comandos clicando com o botão direito do mouse em um item controlado por fonte no Solution Explorer.

COMO: Adicionar um projeto ao controle de origem O controle de origem do Visual Studio permite adicionar um projeto e seu arquivo de solução ao controle de origem ao mesmo tempo. Se uma solução já estiver sob controle de origem, você pode adicionar um novo projeto a ela. Fazendo check-in de uma solução automaticamente coloca qualquer novos projetos que esta contém sob controle de origem.

Para adicionar um projeto e solução ao controle de origem

1. No Visual Studio, crie um novo projeto. Se você tiver dúvidas sobre como fazer isso, procure a Ajuda do Visual Studio.

2. Selecione a solução que contém o novo projeto.

3. No menu File, clique em Source Control.

Visual Studio 15

4. Clique em Add Solution to Source Control e selecione a base de dados de projeto à qual quer adicionar a solução usando os procedimentos do plug-in de controle de origem sendo utilizado.

Para adicionar os projetos selecionados ao controle de origem

1. No Visual Studio, abra uma solução existente no Solution Explorer.

2. Crie novos projetos conforme necessário na solução. Se você tiver dúvidas sobre como fazer isso, há vários procedimentos na Ajuda do Visual Studio.

3. Faça o check-out do arquivo de solução, pois o controle de origem precisa incluir os novos detalhes do projeto nesse arquivo. Use o procedimento de check-out específicos para o plug-in de controle de origem em uso.

4. No menu File, clique em Source Control, e em seguida, clique em Add Selected Projects to Source Control

5. Você será solicitado a decidir se deseja adicionar os projetos como subpastas da solução ou como pastas separadas. Na maioria das situações, você deve adicionar os projetos à pasta da solução no banco de dados.

6. Faça o check-in da solução de volta no controle de origem, usando o procedimento de check-in específico para o plug-in de controle de origem em uso.

COMO: acoplar ou desacoplar uma solução ou projeto Você deve ligar uma solução ou projeto ao controle de origem de maneira que este item tenha acesso aos comandos básicos de controle de origem, tais como Check Out, Check In, e Get. Uma ligação associa a cópia local do item à cópia mestre no banco de dados.

Desacoplar uma solução ou projeto controlado por origem remove o item do controle de origem, desassociando a cópia local da cópia mestre no banco de dados, e desativando todos os comandos de controle de origem. Talvez você precise desacoplar um item se:

• Você precisar religá-lo à versão de backup do banco de dados quando o servidor primário for desligado. Você pode conectar a um servidor de backup, religar a sua cópia da solução à cópia mestre do servidor no banco de dados de backup, e continuar trabalhando normalmente. Para mais informações, consulte COMO: conectar ou desconectar uma solução ou projeto.

• Você desejar iniciar uma nova ramificação sem nenhum histórico de controle de origem em uma pasta de banco de dados diferente.

• Você desejar utilizar um outro plug-in de controle de origem .

Desacoplar um item não o remove permanentemente do banco de dados. Para obter mais informações de como excluir um item, consulte COMO: excluir um item controlado por origem.

Para ligar uma solução ou projeto ao controle de origem

1. No Visual Studio, abra o Solution Explorer e selecione uma solução ou projeto a ser ligado.

2. No menu File, clique em Source Control, depois em Change Source Control.

Visual Studio 16

3. Na caixa de diálogo Change Source Control, clique em Bind.

4. Selecione o banco de dados e local ao qual ligar, e clique em OK.

Para desacoplar uma solução ou projeto do controle de origem

1. No Visual Studio, abra o Solution Explorer e selecione uma solução ou projeto a ser desacoplado.


3. Na caixa de diálogo Change Source Control, clique em Unbind.

4. Clique em OK.

COMO: alterar o local da pasta de trabalho Às vezes o Solution Explorer indica locais de pasta por um sublinhado ondulado. Essas entradas representam caminhos inválidos relativos à pasta de trabalho. Para corrigir caminhos inválidos, você deve alterar o local da pasta de trabalho.

Para alterar o local da pasta de trabalho

1. No Visual Studio, abra o Solution Explorer.

2. Clique em um caminho inválido na coluna Enter Working Copy Location Here.

3. Clique no botão de reticências (…)

4. Digite um caminho válido, por exemplo, http://<host local>/pasta1, e clique em OK. Se a pasta ainda não existir, o Visual Studio criará uma.

Como conectar ou desconectar uma solução ou um projeto Conforme descrito em Introdução ao Controle de Código Fonte, uma solução no Visual Studio pode ter um ou mais vínculos com o controle de código fonte. Uma conexão é criada automaticamente sempre que um item é vinculado ao controle de código fonte conforme descrito em Como vincular ou desvincular uma solução ou um projeto. Pode-se criar uma conexão manualmente conforme descrito neste tópico.

Se você desconectar seu computador da rede ou perder a conexão por alguma outra razão, você deve desconectar temporariamente os vínculos da solução a fim de editar os projetos e os arquivos nela contidos. Quando você desconecta uma solução do controle de código fonte, o único comando básico que você pode usar é o comando de check-out. Ao realizar o check-out de um item desconectado, a cópia local do item, contida na sua pasta de trabalho, torna-se editável. Quando for possível acessar o banco de dados novamente, você pode reconectar a solução e sincronizar sua cópia local com a cópia mestre mais recente.

Procedimentos

Para conectar uma solução ou um projeto ao controle de código fonte

1. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem conectados.

Visual Studio 17

2. No meu File , clique em Source Control e depois em Change Source Control.

3. Na caixa de diálogo Change Source Control, clique em Connect.

4. Clique em OK.

Para desconectar uma solução ou projeto de controle de código fonte

1. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem desconectados.

2. No menu File, clique em Source Control e depois em Change Source Control.

3. Na caixa de diálogo Change Source Control, clique em Disconnect.

4. Clique em OK.

COMO: copiar um item sob controle de origem Você pode copiar um projeto de uma solução sob controle de origem para outra, ou copiar um arquivo de um projeto sob controle de origem para outro. Quando você copia um item, uma nova ramificação é criada no banco de dados, junto com o histórico e outros metadados do item. Criar ramificações permite que sua equipe desenvolva duas versões de um produto simultaneamente e independentemente.

Observação

Se você copiar um projeto sob controle de origem para uma solução que não está sob controle de origem, não poderão ser criadas ramificações no projeto.

Para copiar um projeto sob controle de origem


2. Clique com o botão direito do mouse na solução de destino no Solution Explorer.

3. No menu File, clique em Add e depois em Existing Project.

4. Na caixa de diálogo Add Existing Project, clique no nome de seu plug-in de controle de origem.

5. Clique duas vezes no banco de dados contendo o projeto que você deseja copiar.

6. Selecione o projeto, e clique em Add.

7. Clique em OK.

Para copiar um arquivo sob controle de origem


2. Clique com o botão direito do mouse no projeto de destino no Solution Explorer. Este projeto deve estar no mesmo banco de dados que o projeto de origem.

3. No menu File, clique em Add e depois em Existing Item.

Visual Studio 18

4. Na caixa de diálogo Add Existing Item, clique no nome de seu plug-in de controle de origem.

5. Clique duas vezes no banco de dados que contém o arquivo que você deseja copiar.

6. Selecione o arquivo, e clique em Add.

7. Clique em OK.

COMO: excluir um item controlado por origem Quando você exclui um item controlado por origem, o Visual Studio exclui automaticamente a cópia local, se o plug-in de controle de origem apoiar a propagação de modificação de espaço para nome. Caso contrário, ele o consultará para obter instruções sobre exclusão. Para mais informações sobre propagação de modificação de espaço para nome, consulte Introdução ao controle de origem.

A maioria dos plug-ins para controle de origem para o Visual Studio não exclui permanentemente itens de um banco de dados. Para obter mais informações sobre como excluir permanentemente um item de controle de origem, consulte a documentação do produto de terceiros para seu plug-in.

Para excluir um item controlado por origem

1. No Visual Studio, abra Solution Explorer.

2. Clique com o botão direito do mouse no item que deseja excluir, depois clique Delete ou Remove.

Observação

O comando Remove só estará disponível para projetos a base de referência, como projetos C++.

1. Você será solicitado para fazer o check-out no item. Faça o check-out como apoiado pelo seu plug-in de controle de origem.

2. Se tiver clicado em Remove, anteriormente, clique em Delete na caixa de diálogo que aparece.

3. Na caixa de diálogo Source Control, clique em Delete the item(s) locally and in the source control store.

4. Em Solution Explorer, faça o check-in do item como apoiado pelo seu plug-in de controle de origem.

5. Notifique a exclusão a qualquer pessoa que possa ter feito o check-out do projeto ao qual o item excluído pertence.

6. Se houver suporte para a propagação de modificação de espaço para nome, permita que os outros usuários façam a atualização de suas cópias locais. Eles receberão uma mensagem notificando-os da exclusão.

7. Se não houver suporte à propagação de modificação de espaço para nome, você terá de informar aos outros usuários para removerem manualmente suas cópias locais do item excluído.

Visual Studio 19

Como ativar recuperação automática Você pode configurar o Visual Studio para recuperar automaticamente a versão mais recente de um item sob controle de versão sempre que você abri-lo. Isso garante que a cópia local permanecerá sincronizada com a cópia mestra.

Procedimentos

Para obter a versão mais recente automaticamente

1. No Visual Studio, no menu Tools, clique em Options.

2. Na caixa de diálogo Options, clique em Source Control e em seguida clique em Environment.

3. Marque a caixa de seleção Get everything when a solution or project is opened.

4. Clique em OK.

Como desativar a criação da pasta <solutionname>.root Quando você adiciona uma solução ao controle de código fonte, o respectivo plug-in cria automaticamente uma pasta < solutionname >.root vazia no banco de dados. Essa pasta irá conter a raiz unificada da solução. Para mais informações sobre a raiz unificada, consulte Introdução ao controle de código fonte.

Cuidado

Desativar a criação automática da pasta < solutionname >.root irá alterar o comportamento do plug-in sempre que uma solução com vários projeto for adicionada ao controle de código fonte. Por exemplo, operações que adicionam projetos levarão mais tempo para concluir. Além disso, você terá que responder a solicitações redundantes ao executar operações de controle de código fonte em vários projetos.

Para desativar a criação automática da pasta < solutionname >.root

1. Na área de trabalho do Windows, clique em Start e, em seguida, clique em Run

2. Digite Regedit e clique em OK.

3. Abra \SourceControl HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\ < número de versão >.

4. Selecione a chave DoNotCreateSolutionRootFolderInSourceControl e clique em Edit e depois em Modify.

5. Na caixa de dados Value, troque 0 por 1.

6. Clique em OK para aceitar a alteração do registro.

COMO: Ativar Check-ins automáticos Você pode configurar o Visual Studio para que efetue automaticamente check-in nas suas alterações no controle de origem quando você fechar uma solução.

Visual Studio 20

Automatizar o processo de check-in garante que seus trabalhos mais recentes se tornem periodicamente disponíveis para outros membros da equipe, mesmo se você esquecer fazer check-in manualmente.

Para ativar checkins automáticos


2. Na caixa de diálogo Options, clique em Source Control, clique em Environment.

3. Marque a caixa de seleção Check in everything when closing a solution or project.

4. Clique em OK.

COMO: desativar check-outs automáticos O controle de origem no Visual Studio permite check-outs automáticos por padrão. Esta seção descreve como você pode configurar o Visual Studio para desativar check-outs automáticos.

Procedimentos

Para desativar check-outs automáticos


2. Na caixa de diálogo Options, clique em Source Control, e depois clique em Environment.

3. Na caixa Editing, desmarque a caixa de seleção Check out automatically.

4. Clique em OK.

COMO: ativar ou desativar controle de origem O controle de origem no Visual Studio estará disponível somente se um plug-in válido de controle de origem estiver instalado e registrado para ser usado em seu computador. O plug-in é registrado durante a instalação do software de terceiros. O Visual Studio usa esse registro para localizar os plug-ins e as localidade de seus bancos de dados padrão sempre que você abrir a IDE do Visual Studio. Ela lista todos os plug-ins disponíveis na aba Plug-in Selection da entrada Source Control na caixa de diálogo Options.

Se você não tiver nenhum plug-in de controle de origem compatível instalado em seu computador, o controle de origem no Visual Studio não está ativado. Você não verá nenhuma entrada Source Control no menu File.

Cuidado

Você pode usar um plug-in de controle de origem no Visual Studio e o aplicativo autônomo de controle de origem correspondente para gerenciar o mesmo projeto ou solução. Entretanto, fazer check-outs de itens de ambos os programas para a mesma pasta de trabalho não é recomendável. Isso pode levar a situações em que soluções e projetos não podem ser acessados no controle de origem.

Visual Studio 21

Para ativar um determinado plug-in de controle de origem


2. Na caixa de diálogo Options , clique em Source Control, clique em Plug-in Selection.

3. Selecione o plug-in de controle de origem que deseja usar.

4. Clique em OK.

Para desativar completamente o controle de origem


2. Na caixa de diálogo Options, clique em Source Control, clique em Plug-in Selection.

3. Selecione None na caixa Current source control plug-in.

4. Clique em OK.

COMO: excluir um arquivo de controle de origem Se a solução em você estiver trabalhando contém arquivos que não requerem controle de origem, você pode utilizar o comando Exclude from Source Control para marcar adequadamente o arquivo. Quando você fizer isso, o arquivo permanecerá no banco de dados, mas não é mais realizado check-in ou check-out do mesmo a partir do projeto que o contém.

Observação

Arquivos gerados são excluídos do controle de origem por padrão. Um arquivo gerado é um que pode ser recriado inteiramente pelo Visual Studio, de acordo com o conteúdo de outro arquivo do Visual Studio.

Para excluir um arquivo do controle de origem

1. No Visual Studio, abra Solution Explorer e selecione o arquivo a ser excluído.

2. No menu File, clique em Source Control, clique em Exclude from Source Control.

3. Quando você estiver pronto para colocar o arquivo sob controle de origem, você pode acessar o menu File, clicar em Source Control e então desmarcar Exclude from Source Control.

COMO: mover uma raiz de ligação de projeto Você talvez necessite mover a raiz de ligação de um projeto se alguns arquivos que você deseja adicionar ao projeto estiverem localizados fora da raiz do projeto.

Para mover uma raiz de ligação de projeto

1. No Visual Studio, abra o Solution Explorer e selecione um projeto que contém arquivos que estejam fora da pasta da solução ou raiz do projeto.

Visual Studio 22



4. Na caixa de mensagem, clique em Unbind para confirmar que você deseja remover o projeto do controle de origem.

5. Se a solução e o projeto compartilham uma ligação de controle de origem, desacople a solução também.

6. Com o projeto selecionado, acesse novamente a caixa de diálogo Change Source Control e clique em Bind.

7. Se solicitado, faça logon no seu banco de dados de controle de origem.

8. Selecione a pasta pai na qual todos os arquivos no projeto estão armazenados. Na maioria dos casos, a pasta <nomesolução>.root é esta pasta.

9. Se você teve que desacoplar a solução juntamente com o projeto, você deve religá-la a uma pasta de banco de dados.

COMO: mover um item controlado por fonte No Visual Studio, você pode mover um item controlado por origem de uma pasta de projeto ou solução para outro. Quando você move um item, você move todo o histórico e metadados de controle de origem associados se o plug-in de controle de origem apoiar a propagação de modificação de espaço para nome. Tanto a origem quanto os itens de destino envolvidos em uma operação de mudança de local devem ser localizados no mesmo banco de dados de controle de origem. Para mais informações sobre propagação de modificação de espaço para nome, consulte Introdução ao controle de origem.

Observação

A operação de mudança só pode ocorrer entre dois projetos na mesma solução, ou entre duas soluções. Para uma mudança de local ser ativada, uma solução e seus projetos devem compartilhar uma vinculação de controle de origem. Para mais informações, consulte COMO: acoplar ou desacoplar uma solução ou projetos.

Para mover um item controlado por origem


2. Clique no item que você deseja mover e arraste-o para a solução ou projeto de destino no Solution Explorer.

COMO: abrir um projeto ou solução do controle de origem Quando você abre um projeto ou solução do controle de origem, o Visual Studio baixa a cópia mestra mais recente do item e de todos os arquivos contidos para a pasta de trabalho local. Depois que você recuperar uma cópia local do item, você não precisá abri-lo a partir do controle de origem novamente. Você pode continuar

Visual Studio 23

a usar os comandos de controle de origem para o seu plug-in específico de controle de origem.

Cuidado

Se você repetir um dos procedimentos neste tópico, você criará várias pastas de trabalho e várias instâncias dos arquivos que elas contêm.

Para abrir um projeto ou solução do controle de origem

1. No Visual Studio, no menu File, clique em Open.

2. Clique em Project/Solution.

3. Na caixa de diálogo Open Project , selecione Close Solution if not already selected.

4. No lado esquerdo da caixa, clique em My <source control plug-in> Stores, e depois clique em Open.

5. Procure e selecione o seu arquivo de projeto (*.proj) ou de solução (*.sln), altere a pasta de destino, e depois clique em Open.

6. Se você já tiver uma cópia local da solução ou do projeto que você está abrindo do controle de origem, você será solicitado a substituir a cópia local de todos os arquivos e projetos na solução. Responda às perguntas conforme necessário.

Para abrir um projeto da Web do controle de origem


2. Clique em Web Site.

3. Na caixa de diálogo Open Web Site, clique em My <source control plug-in> Stores, depois clique em Open.

4. Procure e selecione o projeto da Web, altere a pasta de destino, e depois clique em Open.

5. Se você já tiver uma cópia local do projeto da Web que você está abrindo do controle de origem, você será solicitado a substituir a cópia local de todos os arquivos e projetos na solução. Responda às perguntas conforme necessário.

COMO: Renomear um item controlado por origem Quando você renomeia um item controlado por origem, o Visual Studio renomeia a cópia local automaticamente se o plug-in de controle de origem suporta propagação da alteração de namespace. Caso contrário, ele consultará você para obter instruções de renomeação. Para mais informações sobre propagação de alterações de namespaces, consulte Introdução ao controle de origem.

Para renomear um item de origem controlada


2. Clique com o botão direito do mouse no arquivo a ser renomeado, clique Rename.

Visual Studio 24

3. Digite um novo nome e pressione Enter.

4. Você será solicitado para fazer check-out do item. Efetue o check-out conforme o suporte de seu plug-in de controle de origem.

5. Na caixa de diálogo Source Control, clique em Rename or move the item(s) locally and in the source control store.

6. No Solution Explorer, efetue o check-in do item conforme o suporte de seu plug-in de controle de origem.

7. Notifique qualquer pessoa que possa ter efetuado check-out do item que você renomeou.

8. Se houver suporte para propagação da alteração de namespace, faça com que os outros usuários efetuem um get para atualizar suas cópias locais. Eles receberão uma mensagem notificando-os sobre a operação de renomeação.

9. Se não houver suporte para a propagação da alteração do namespace, é necessário informar aos outros usuários para que renomeiem suas cópias locais manualmente para refletir a alteração do nome.

COMO: definir opções de plug-in Dependendo da como você gerenciar seus itens em controle de origem, você pode desejar alterar algumas das opções padrão de controle de origem antes de usar o banco de dados. Essas opções estão disponíveis através da Configuração Options no menu Tools do Visual Studio.

Observação

Consulte a documentação do plug-in de controle de origem em uso para uma lista completa das opções no nível do banco de dados e das mais avançadas, além de instruções sobre como configurá-las.

Para definir opções de plug-in

1. No Visual Studio, no menu Tools, clique em Options e, em seguida, em Source Control.

2. Na caixa de diálogo Options, clique em Plug-in Selection, assegure-se que seu plug-in é o indicado, e clique em OK.

3. Selecione Environment na caixa de diálogo Options.

4. Na caixa Source Control Environment Settings, selecione a função para a qual você deseja definir as opções de controle de origem. O Visual Studio seleciona automaticamente as opções de controle de origem padrão para a função que você tiver selecionado. Se você desmarcar qualquer uma das opções padrão, a caixa Source Control Environment Settings exibe a Opção Custom para indicar que você personalizou o perfil originalmente selecionado.

5. Personalize o perfil, marcando ou desmarcando as caixas de seleção do controle de origem.

6. Clique em OK.

7. Agora clique em Plug-in Settings na caixa de diálogo Options.

Visual Studio 25

8. Nessa aba, você pode definir configurações para cada função do plug-in. Clicando no botão Advanced tem-se acesso às configurações avançadas para a função que você está configurando.

9. Quando concluir todas as configurações do plug-in, clique em OK para sair da caixa de diálogo Options.

Como: Trocar plug-ins de controle de origem: Se você tiver instalado mais de um plug-in para controle de origem para o Visual Studio, você pode trocá-los a qualquer momento. Lembre-se que projetos controlados por um plug-in de controle de origem não podem ser adicionados a uma solução gerenciada por um plug-in diferente. Uma vez que você acrescenta uma solução ou projeto ao controle de origem que usa um plug-in, você não pode acrescentar o mesmo item ao controle de origem que usa outro plug-in, a menos que você remova, primeiro, o item do controle de origem.

Para mudar o plug-in padrão de controle de origem


2. Na caixa de diálogo Options clique em Source Control, depois em Plug-in Selection.

3. Selecione um plug-in e clique OK.

COMO: exibir uma lista de arquivos com check-out Você pode usar a janela Pending Checkins para exibir uma lista dos arquivos com check-out na solução atual. O controle de origem do Visual Studio permite que você faça um check-in de arquivos desta janela com um único clique de botão.

Para exibir uma lista de arquivos modificados

1. No Visual Studio, no menu View, clique em Pending Checkins.

2. Encaixe a janela conforme desejado.

3. Se você desejar fazer check-in de arquivos desta janela, selecione-os e clique no botão Check In.

Referência a Interface do Usuário do controle de origem Esta seção descreve as caixas de diálogo usadas pelo controle de origem no Visual Studio. As caixas de diálogo a seguir são modelos que o desenvolvedor de plug-in pode adaptar conforme necessário. Você pode ou não ver essas caixas de diálogo no Visual Studio, dependendo do plug-in que está sendo usado para controle de origem:

• Verifique em

• Verificar saída para editar

• Obter

• Desfazer Checkout

Visual Studio 26

Caixa de diálogo Change Source Control Cria e gerencia as conexões e ligações que vinculam uma solução ou projeto localmente salvos a uma pasta no banco de dados.

Observação

Não é possível usar o Visual Studio para vincular, desvincular, conectar ou desconectar um aplicativo da Web criado utilizando as FrontPage Server Extensions.

Acesso à caixa de diálogo

No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control e depois em Change Source Control.

Observação

Esta caixa de diálogo também está disponível clicando com o botão direito do mouse sobre o item no Solution Explorer.

Vincular

Associa os itens selecionados a uma localidade do servidor de controle de origem especificado. Por exemplo, você pode usar este botão para criar um vinculo à pasta mais recentemente utilizada do servidor de controle de origem e banco de dados. Se uma pasta recente do servidor ou do banco de dados não puder ser encontrada, você será solicitado a especificar outra.

Procurar

Permite que você procure uma nova localidade para o item especificado no servidor de controle de origem.

Colunas

Identifica colunas para exibição e a ordem na qual elas são exibidas.

Conectar

Cria uma conexão entre itens selecionados e o servidor de controle de origem.

Conectado

Exibe o status da conexão de uma solução ou projeto selecionado.

Desconectar

Desconecta a cópia local de uma solução ou projeto no seu computador da cópia mestre no banco de dados. Utilize esse comando antes de desconectar seu computador do servidor de controle de origem, por exemplo, ao trabalhar off-line em seu laptop.

OK

Aceita alterações feitas na caixa de diálogo.

Provedor

Exibe o nome do plug-in de controle de origem.

Atualizar

Visual Studio 27

Atualiza as informações de conexão para todos os projetos listados nesta caixa diálogo.

Servidor Binding

Indica a ligação de um item a um servidor de controle de origem.

Nome do servidor

Exibe o nome do servidor de controle de origem ao qual a solução ou projeto correspondente está acoplada.

Solution/Project

Exibe o nome de cada projeto e solução na seleção atual.

Classificação

Altera a ordem de classificação de colunas exibidas.

Status

Identifica o status de vinculação e conexão de um item. As possíveis opções são:

Opção Descrição

Válido Especifica que o item está corretamente vinculado e conectado a pasta do servidor ao qual ele pertence.

Inválido Especifica que o item está incorretamente vinculado ou desconectado da pasta à qual ele pertence. Use o comando Add to Source Control ao invés do comando Bind para este item.

Desconhecido Especifica que status do item sob controle de origem ainda não foi determinado.

Não controlado

Especifica que o item não se encontra sob controle de origem.

Desagrupar

Exibe a caixa de diálogo Source Control que permite que você remova os itens selecionados do controle de origem e permanentemente disassocie-os das suas pastas.

Observação

Se você desvincular um projeto da Web, será impossível revinculá-lo a seu servidor de controle de origem original até que você altere a localidade de sua cópia de trabalho.

Caixa de diálogo Check In (Controle de Código Fonte) Verifica um arquivo, solução ou projeto alterado no banco de dados do controle de código fonte. Check-ins também podem ser feitos a partir da janela Pending Checkins.

Visual Studio 28


No Visual Studio, selecione um item na janela Solution Explorer. No menu File, clique em Source Control depois em Check In.

Observação

Esta caixa de diálogo também é disponibilizada clicando-se com o botão direito no item na janela Solution Explorer.

Check In

Realiza o check-in de todos os itens selecionados.

Columns

Identifica as colunas a serem exibidas e a ordem na qual elas são exibidas.

Comments

Especifica um comentário a ser associado com a operação de check-in.

Don't show Check in dialog box when checking in items

Impede que a caixa de diálogo seja exibidas durante operações de check-in.

Flat View

Exibe os arquivos onde está sendo feito o check-in como listas simples sob sua conexão com controle de código fonte.

Name

Exibe os nomes dos itens onde deve-se fazer o check-in. Os itens aparecem com as caixas de seleção ao lado selecionadas. Se você não desejar fazer check-in de um item específico, desmarque sua caixa de seleção.

Options

Exibe opções de check-in específicas de plug-ins de controle de código fonte quando a seta à direita do botão é selecionada.

Sort

Altera a ordem de classificação das colunas de exibição.

Tree View

Exibe a pasta e a hierarquia dos itens nos quais você estiver realizando o check-in.

Check-out para a caixa de diálogo Edit (controle de origem) Faz check-out de soluções, projetos ou itens individuais do controle de origem. Fazer check-out de um item pode copiar a cópia mestre atual para o seu computador local e remover o seu atributo de somente leitura. Opcionalmente você pode configurar o comando Check Out For Edit para fazer check-out somente da versão local. A menos que o pacote de controle de origem esteja configurado para dar suporte a checkouts compartilhados, fazer check-out de um item também bloqueia o item de maneira que ele estará em somente leitura para outros usuários.

Visual Studio 29

Caixa de diálogo Access

No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control, depois clique em Check Out For Edit.

Observação

Esta caixa de diálogo também está disponível clicando com o botão direito do mouse no item no Solution Explorer.

Verificar saída

Faz check-out de todos os itens selecionados.

Colunas

Identifica as colunas para exibição e a ordem na qual elas são exibidas.

Comentários

Especifica um comentário para associar à operação de check-out.

Não caixa diálogo Show Check Out quando check-out itens

Impede que a caixa de diálogo seja exibida durante operações de check-out.

Exibir simples

Exibe os itens do check-out em progresso como listas simples sob sua conexão de controle de origem.

Editar

Permite que você modifique um item sem fazer seu check-out. O botão Edit aparece somente se você tiver o Visual Studio configurado para dar suporte à edição de arquivos com check-in.

Nome

Exibe os nomes dos itens disponíveis para check-out. Os itens que estão selecionados aparecem com caixas de seleção ao seu lado. Se você não desejar fazer check-out de um item específico, desmarque sua caixa de seleção.

Opções

Exibe opções de check-out específicas do plug-in de controle de origem quando a seta à direita do botão é clicada.

Classificação

Altera a ordem de classificação das colunas exibidas.

Exibir árvore

Exibe a hierarquia de pastas e arquivos para o item do check-out em progresso.

Caixa de diálogo Get (controle de origem) Recupera uma cópia somente para leitura do item selecionado do banco de dados para sua pasta de trabalho, ou outra pasta que você especificar.

Visual Studio 30


No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control, depois em Get.

Observação

Esta caixa de diálogo também está disponível clicando-se com o botão direito do mouse sobre o item no Solution Explorer.

Ação

Especifica a ação a ser executada nos itens a ser recuperados.

Colunas


Exibir simples

Exibe os arquivos sendo recuperados como listas simples sob suas conexões ao controle de origem.

Hora modificado

Exibe o momento em que um item foi modificado pela última vez.

Nome

Exibe os nomes dos itens a ser recuperados. Os itens aparecem com as caixas de seleção ao lado dos mesmos selecionadas. Se você não desejar recuperar um item específico, desmarque a caixa de seleção correspondente.

Opções

Exibe opções de recuperação específicas do plug-in do Source Safe quando a seta à direita do botão é clicada.

Classificação


Exibir árvore

Exibe a hierarquia de pastas e arquivos para os itens sendo recuperados.

Janela de check-ins pendentes Exibe todos os arquivos com check-out na solução ou projeto atual. Você pode usar esta janela para fazer check-in de todos os arquivos com um único clique de botão.

Caixa de diálogo de acesso

No Visual Studio, no menu View, clique em Pending Checkins.

Change type

Identifica o tipo de alteração que foi feita para o item selecionado.

Check In

Efetua check-in dos itens selecionados.

Columns

Visual Studio 31

Identifica as colunas para exibição e a ordem na qual elas serão exibidas.

Comments


Flat View

Exibe os arquivos que você está efetuando check-in na forma de listas simples em sua conexão de controle de origem.

Name

Exibe os nomes dos itens com check-in a ser efetuado. Os itens aparecem com as caixas de seleção ao seus lados selecionadas. Se você não desejar fazer o check-in de um item específico, desmarque sua caixa de seleção.

Options

Exibe opções de check-in específicas de plug-ins quando a seta à direita do botão é clicada.

Sort


Tree View

Exibe a hierarquia das pasta e arquivos que você estiver efetuando check-in.

Undo checkout

Reverte o check-out de um item selecionado, o qual perde qualquer alteração feita desde o check out.

Guias de plug-in para controle de origem (caixa de diálogo Options) Permitem a personalização de funções de controle de origem e configurações de plug-in no Visual Studio. As guias de plug-in fazem parte da caixa de diálogo Options do Visual Studio, localizada sob a entrada Source Control:

• Plug-in Selection Alterna entre os plug-ins de controle de origem.

• Environment Especifica as configurações de ambiente para as funções padrões definidas pelo Visual Studio. Por exemplo, se o usuário for um desenvolvedor independente, conflitos com outros usuários não são geralmente criados ao manter itens com check-out após um check-in. Para esta função, o Visual Studio seleciona automaticamente a opção Keep items checked out when checking in.

• Plug-in Settings Especifica opções para identificar o plug-in de controle de origem associado a um projeto ou solução.

Guia Access

No Visual Studio, no menu Tools, clique em Options, e depois em Source Control. Opções são definidas para Plug-in Selection, Environment, e Plug-in Settings.

Lista de elementos de interface do usuário, Selection Plug-in

Altera o plug-in atual de controle de origem associado ao IDE do Visual Studio, e faz dele o plug-in padrão. O plug-in selecionado é refletido na entrada Source

Visual Studio 32

Control no menu File do Visual Studio. Clique em OK para registrar sua alteração e alternar a operação para o plug-in escolhido por você.

Observação

Você pode usar esta parte da caixa de diálogo Options para desativar o controle de origem clicando em None na lista de plug-ins

Lista de elementos de interface do usuário, Environment

Permitir que itens a serem editadas checked-in

Especifica que itens com check-in podem ser editados na memória. Se este item estiver selecionado, um botão Edit aparecerá na caixa de diálogo Check Out For Edit quando você tentar editar um item com check-in.

Check in tudo ao fechar uma solução ou projeto

Especifica que você irá fazer check-in de todos os itens ao fechar uma solução ou projeto.

Itens Checked-in

Contém configurações para salvar e editar itens com check-in.

Não Mostrar caixa de diálogo check-out quando check-out itens

Especifica que o Visual Studio deve exibir o comando Check Out Now no menu File. Nesse caso, uma caixa de diálogo de check-out não é exibida.

Não Mostrar caixa de diálogo check-in ao verificar em itens

Especifica que o Visual Studio deve exibir o comando Check In Now no menu File. Nesse caso, uma caixa de diálogo de check-in não será exibida.

Não mostrar esta caixa de diálogo novamente

Especifica que o Visual Studio não deve mostrar as configurações de ambiente de controle de origem.

Edição

Especifica a maneira com que itens devem ser manipulados na edição. As opções possíveis são:

Opção Descrição

Prompt for checkout Especifica que o Visual Studio deve emitir um prompt para um check-out.

Prompt for exclusive checkouts

Especifica que o Visual Studio deve emitir um prompt para check-outs exclusivos.

Check out automatically Indica que o Visual Studio deve fazer check-out de itens automaticamente.

Do nothing Especifica que o Visual Studio não deve fazer nada na edição.

Obter tudo quando uma solução ou projeto for aberto

Visual Studio 33

Recupera a versão mais recente de todos os itens quando você abre uma solução ou projeto.

Manter itens check-out ao verificar na

Especifica que itens em processo de check-in devem permanecer com check-out para você. Se você desejar alterar esta opção para um check-in específico, clique na seta de Options na caixa de diálogo Check In, e desmarque a opção Keep Checked Out.

Redefinir

Redefine confirmações.

Salvar

Especifica a maneira com que itens devem ser manipulados quando você os salva. As opções possíveis são:

Opção Descrição

Prompt for checkout Especifica que o Visual Studio deve emitir um prompt para check-out em uma operação de salvar.

Check out automatically

Especifica que o Visual Studio deve fazer check-out automaticamente em uma operação de salvar.

Save as Especifica que o Visual Studio deve apresentar um prompt Save as em uma operação de salvar.

Configurações de ambiente controle de origem

Especifica o nome do plug-in de controle de origem para o qual você está definindo opções de ambiente.

Lista de elementos de interface do usuário, Plug-in Settings

Avançadas

Permite que você defina opções adicionais para usar o plug-in de controle de origem . O botão Advanced só está disponível quando um plug-in de controle de origem válido está instalado no computador local. As configurações avançadas são específicas para o plug-in.

Identificação de logon

Especifica o nome de usuário para efetuar logon no plug-in de controle de origem. Se seu plug-in der suporte, esse nome será colocado automaticamente na caixa de diálogo de logon usada pelo plug-in de controle de origem para acessar o servidor. Para ativar essa opção, desative logons de usuário automáticos do seu plug-in de controle de origem, e reinicie o Visual Studio.

Observação

A identificação de logon somente pode ser editada quando um plug-in válido de controle de origem estiver instalado na máquina local.

Visual Studio 34

Executar atualizações de status em segundo plano

Atualiza automaticamente os ícones de controle de origem no Solution Explorer à medida que o status de item se altera. Se você tiver atrasos ao executar operações intensivas no servidor, especialmente quando abrir uma solução ou projeto do controle de origem, desmarcar esta opção pode melhorar o desempenho.

Configurações plug-in

Especifica o nome do plug-in de controle de origem para o qual você está fazendo configurações.

Caixa de diálogo Source Control Permite que você remova itens do controle de código fonte e desfaça permanentemente a associação entre os itens e suas pastas. Esta caixa de diálogo é usada para propagar as operações excluir, renomear e mover.


No Visual Studio, clique em um item com o botão direito do mouse, em seguida, clique em Delete ou Rename. O conteúdo da caixa de diálogo varia dependendo do comando.

Lista de elementos da interface do usuário para renomeações ou movimentações

Make my current choice the default action for all future renames or moves

Especifica que sua escolha será a ação padrão das operações posteriores de renomear ou mover. Você pode redefinir o padrão em

Only rename or move item(s) locally

Especifica que os itens devem ser renomeados localmente. Os itens renomeados ou movidos não mais estarão sob controle de versão.

Rename or move the item(s) locally and in the source control store

Especifica que os itens devem ser renomeados localmente e no banco de dados. A versão mais recente da solução ou projeto não refletirá a renomeação ou a movimentação até o próximo check-in.

You are about to rename or move the following

Lista os itens que você selecionou para serem renomeados ou movidos.

Lista de elementos da interface do usuário para exclusões

Delete the item(s) locally and in the source control store

Especifica que os itens devem ser excluídos localmente e no banco de dados. A versão mais recente da solução ou projeto não refletirá a operação de exclusão até o próximo check-in.

Make my current choice the default action for all future deletes

Especifica que a sua escolha será a ação padrão das operações posteriores de exclusão.

Only delete item(s) locally

Visual Studio 35

Especifica que os itens devem ser excluídos localmente. Outros membros da equipe não são afetados por essa opção até o próximo check-in. Você precisará excluir manualmente os itens no banco de dados após o check-in.

You are about to delete the following

Lista os itens que você selecionou para exclusão.

Caixa de diálogo Undo Checkout (Controle de Código Fonte) Reverte a opção de check-out do item selecionado na janela Solution Explorer. Você perderá qualquer alteração feita desde o último check-out.


No Visual Studio, selecione um item na janela Solution Explorer. No menu File, clique em Source Control e em seguida clique em Undo Checkout.

Observação


Columns


Flat View

Exibe os itens como listas simples sob a sua conexão com o controle de código fonte.

Name

Exibe os nomes dos itens para os quais será desfeito o check-out. Os itens aparecem com as caixas de seleção ao seu lado selecionadas. Se você não deseja desfazer o check-out de um item, desmarque sua caixa de seleção.

Options

Exibe opções para desfazer o check-out específicas de plug-ins de controle de código fonte quando a seta à direita do botão é selecionada.

Sort


Tree View

Exibe a pasta e a hierarquia dos itens nos quais você está revertendo o check-out.

Undo Checkout

Reverte o check-out.

Visual Studio 36

Configurações do Visual Studio

Configurações no Visual Studio consistir de personalizações feitas para o ambiente de desenvolvimento integrado (IDE) com base em diferentes tipos de atividades de desenvolvimento e seus próprios personalizações. Essas personalizações incluir mostrar ou ocultar determinada layouts janela, colocação dos comandos de menu, nomes de menu, modelos disponíveis na caixa de diálogo Novo projetos, janelas de ferramentas, predefinidas combinações de teclas de atalho, e ajuda filtros, e assim por diante.

Com configurações, você pode:

• Criar uma cópia das suas configurações ativa para uso em uma segunda máquina

• Compartilhar suas configurações Ativa com outros desenvolvedores

• Permitir todos os membros da equipe para usar as mesmas configurações em Selecione áreas, como o editor, sem remover personalizações para outras áreas individuais

Quais são configurações? Configurações são personalizações ao IDE, como layouts janela, padrões editor, e opções caixa diálogo disponíveis que você pode salvar, Exportar, importar, ou redefinir para facilitar o IDE para usar.

As configurações Ativa consistem em duas partes: predefinidas personalizações do arquivo instalado.vssettings você selecionou na primeira vez você iniciou Visual Studio e qualquer personalização IDE subseqüentes que você fez. Configurações ativa são salvas por padrão no currentsettings.vssettings arquivo.

Para obter mais informações sobre as configurações predefinidas disponíveis com Visual Studio, consulte os seguintes tópicos.

Como configurações funcionam? Quando você inicia Visual Studio, primeiro é necessário para selecionar uma coleção configurações que contém configurações predefinidas projetadas para corresponder seus hábitos de desenvolvimento. Se você atualizar para outro edição do Visual Studio, você também terá a opção de aplicar configurações a outros edição na usando a My Previous Settings opção. A coleção configurações é o primeiro elemento de suas configurações ativa. Cada vez que fizer uma alteração em uma configuração controlada pelo Visual Studio, como alterar a cor do commented código no Editor, a alteração é automaticamente salvo para currentsettings.vssettings juntamente com as configurações predefinidas. O Visual Studio aplica suas configurações ativa automaticamente sempre que você iniciar o Visual Studio.

Em alguns casos, você pode alterar as configurações aplicadas como parte de uma coleção predefinida Por exemplo, se uma coleção configurações simplificada caixa de diálogo Opções, ocultando páginas, você pode exibir essas páginas manualmente, selecionando Show all settings. Em outros casos, você não pode substituir a configuração predefinida sem aplicar uma coleção diferente. Para obter uma lista detalhada das personalizações incluídos no configurações predefinidas, consulte Configurações do Visual Studio. Para obter informações sobre como aplicar coleções configurações diferentes, consulte Como: Alterar configurações selecionadas.

Visual Studio 37

Configurações podem ser aplicadas de duas maneiras: completamente você pode substituir as configurações Ativa com novas configurações ou você pode substituir uma parte de suas configurações ativa. Importar um arquivo que contém todas as categorias configurações possíveis.vssettings ou aplicar outra coleção configurações dois substituirão as configurações ativa completamente. Importar um arquivo que contém somente um subconjunto das categorias configurações ou unselecting categorias configurações em um arquivo.vssettings.vssettings só se aplica essas configurações que estiver selecionadas, deixando as configurações ativos para as categorias restantes intacto.

Ajuda e Configurações

Coleções configurações predefinidas também fornecer personalizações à Ajuda. Configurações especificam o padrão How Do I Página na Ajuda. Eu selecionado como pendente eu página filtros fazer o conteúdo que aparece no índice analítico e no índice,, bem como fornece conteúdo personalizado na caixa como guia. Você pode alterar o ativo How Do I página na lista drop-down como pendente eu outras páginas.

Configurações e segurança Algumas categorias configurações podem conter informações sobre você ou seu computador que pode ser uma questão de segurança se você compartilhar suas configurações com outros usuários. Inversamente, se você pretende importar configurações fornecidas por outras pessoas, você precisará estar ciente das categorias dentro do arquivo configurações que podem ser uma questão de segurança. Um ícone aparece ao lado essas categorias com as possíveis questões de segurança. Essas categorias configurações incluem:

• Favoritos

• Importar e exportar configurações

Como: Alterar configurações selecionadas Você pode aplicar um sub-set das configurações de uma coleção configurações diferentes para as configurações atuais para criar um ambiente de desenvolvimento mais personalizada. Para obter mais informações sobre configurações predefinidas, consulte Configurações do Visual Studio.

Para alterar configurações selecione 1. No menu Tools, escolha Import and Export Settings.

2. Na Welcome to the Import and Export Settings Wizard Página, clique em Import selected environment settings e clique em Next.

3. Na página Save Current Settings, selecionar Yes, save my current settings, e clique em Next

4. No Which collection of settings do you want to import, selecione uma coleção configurações na lista e clique em Next.

5. No Which settings do you want to import, expanda a lista e selecione apenas a categorias ou itens de categoria que você deseja que se aplicam as configurações atuais.

6. Clique em Finish.

A Reset Complete página lista os erros associados a redefinindo as configurações com Details.

Visual Studio 38

Trabalhando com configurações Esta seção contém informações sobre a aplicação, exportar e importar configurações para personalizar o ambiente de desenvolvimento integrado (IDE) para melhor correspondência seu estilo de desenvolvimento. Você também pode encontrar informações gerais sobre como configurações funcionam e os tipos de itens que são personalizadas através das configurações. Além disso, aprender a especificar um conjunto de configurações de uso da equipe.

COMO: Compartilhar configurações entre computadores Você pode exportar configurações para o editor, projetos, depuração, fontes e cores, e outras áreas IDE a um arquivo que você pode importar e usar em outro computador, como seu computador de desenvolvimento segundo ou computador um colega na.

Exportar configurações para um arquivo Você pode optar por exportar todas ou algumas das suas configurações atuais a um arquivo.vssettings que você pode usar em um computador segundo ou compartilhar com outros desenvolvedores.

Para exportar configurações

1. No menu Tools, escolha Import and Export Settings.

2. Na Welcome to the Import and Export Settings Wizard Página, clique em Export selected environment settings e clique em Next.

3. No Which settings do you want to export?, selecione as categorias você pretende exportar e, em seguida, clique em Next Configurações.

Observação

Algumas categorias configurações podem conter informações sobre você ou seu computador que pode ser uma questão de segurança. Essas categorias configurações são identificadas por um ícone de aviso amarelo e preto.

4. No What do you want to name your settings file, digite um nome para o arquivo de configurações.

5. Se você gostaria de salvar o arquivo em um local diferente, clique Browse ou digite um novo caminho para Store my settings file in this directory.


7. Na página Export Complete, examine os erros associados à exportação as configurações com Details.

Importar um arquivo.vssettings Após ter criado um arquivo.vssettings, você pode usar esse arquivo em outros computadores ao importar esse arquivo para outra instalação do Visual Studio. Você também pode importar arquivos de configuração criados por outros usuários e aplicar essas configurações para o Visual Studio.

Se você está importando o arquivo configurações contém todas as categorias configurações possíveis, importar esse arquivo completamente substitui as configurações existentes. Importar o arquivo se um arquivo de configurações

Visual Studio 39

contém apenas um subconjunto das categorias configurações, apenas aplica essas categorias e não afeta as configurações atuais para categorias não importadas.

Um desenvolvedor na equipe por exemplo, tem exportadas todas as sua configurações para um arquivo para que outras pessoas na equipe podem utilizá-lo. Se você desejar se aplicar as configurações de fontes e cores e as configurações teclado desse arquivo, somente você pode limpar todos os outras categorias configurações e apenas aplicar as configurações selecionadas sem alterar as configurações atuais para as categorias restantes

Para importar configurações



3. Logon Save Current Settings, optar Yes, save my current settings por criar um backup de suas personalizações IDE atuais; optar No, just import new settings, overwriting my current settings por continuar sem fazer o backup suas personalizações IDE atuais.

4. No What collection of settings do you want to import?, selecione um arquivo na lista ou clique Browse para localizar um arquivo de configurações e clique em Next.

5. No Which settings do you want to import?, selecione as configurações opções você pretende importar do arquivo.vssettings selecionado.

Observação

Algumas categorias configurações podem conter informações que podem ser uma questão de segurança. Essas categorias configurações são identificadas por um ícone de aviso amarelo e preto.


7. Na caixa Save Current Settings de diálogo, decidir se deve ou não para salvar as configurações atuais.

8. Na página Import Complete, examine os erros associados a importar as configurações em Details.

Compartilhar um arquivo único.vssettings entre computadores Em vez de criar uma cópia das suas configurações atuais e usando a cópia em outro computador, você pode compartilhar um arquivo.vssettings único em um compartilhamento de rede. Essa técnica pode ser útil se você desejar as personalizações mesmas exatas disponíveis em todas as vezes em vários computadores.

Quando você compartilhar um arquivo.vssettings único em vários computadores, personalizações feitas, independentemente do computador no qual você torná-los na, são salvas para o arquivo.vssettings. A lista Tarefas por exemplo, se você fechar a lista de tarefas em um computador, na próxima vez que você iniciar o Visual Studio em outros computadores, não será exibida.

Para compartilhar um arquivo único configurações entre computadores

1. No menu Tools, escolha Options

2. Na pasta Environment, escolha Import and Export Settings.

Visual Studio 40

3. Na Automatically save my settings to this file, digite uma pasta compartilhada ou clique Browse para localizar um compartilhamento de rede.

4. Clique em OK.

5. No segundo computador, repita as etapas 1 a 4.

Como: Especificar configurações para uma equipe Quando estiver trabalhando em um grupo, ele pode ser útil para que cada desenvolvedor usar as configurações mesmas exatas em algumas áreas do ambiente de desenvolvimento integrado (IDE), como o editor. Você pode incentivar Essa consistência criando um arquivo.vssettings para um subconjunto de categorias configurações disponíveis que todos os desenvolvedores de seu grupo podem usar. Quando aplicado, essas configurações da equipe não seria substituem qualquer categoria não especificada no arquivo.vssettings, permitindo que desenvolvedores individuais para manter personalizações feitas para outras áreas do IDE. Para obter informações sobre como criar um arquivo.vssettings, consulte COMO: Compartilhar configurações entre computadores.

O Visual Studio verifica que você estiver usando a versão mais recente do arquivo.vssettings de grupo sempre que você iniciar o Visual Studio. Quaisquer alterações feitas no arquivo.vssettings são aplicadas automaticamente.

Para especificar um arquivo.vssettings para uso em um grupo 1. Partir do Tools menu, escolha Options.


3. Selecione Use team settings file.

4. Insira um UNC ou caminho local, ou clique Browse para localizar o arquivo.vssettings de grupo.

5. Clique OK para aplicar as configurações.

Import and Export Settings Wizard Use este assistente para exportar configurações, importar configurações, ou substituir as configurações para usar uma coleção configurações predefinidas.

Opção Descrição

Exportar configurações de ambiente selecionada

Salvar um subconjunto ou todas as suas configurações existentes para que você pode usar essas configurações em outro computador.

Importar configurações de ambiente selecionada

Aplica as configurações em um arquivo você tiver recebido. Substitui existentes configurações com os do arquivo importado.

Redefinir todas as configurações

Permite que você se reverter as configurações de volta para uma das configurações predefinidas disponíveis com o produto.

Você pode acessar este assistente a partir do Tools Menu, escolhendo Import and Export Settings.

Visual Studio 41

Escolha Configurações para exportar, importar e exportar configurações Assistente

Use esta página do Assistente para configurações a importação e exportação para especificar algumas ou todas as suas configurações atuais ser exportados para um arquivo para uso em outros computadores. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

• COMO: Compartilhar configurações entre computadores

Which settings do you want to export?

Selecione para exportar todas as configurações, ou especificar um sub-set das configurações por categoria ou item de categoria.

Observação

Configurações que podem conter informações de identificação sobre você ou seu computador são marcadas com um gráfico de aviso. Essas configurações não são selecionados por padrão, mas são automaticamente selecionados se você escolher All Settings.

Nomeie O arquivo de configurações, importar e exportar configurações Assistente

Use esta página do Assistente para configurações a importação e exportação para especificar o nome e local do arquivo que irá conter as configurações exportadas. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

COMO: Compartilhar configurações entre computadores

What do you want to name your settings file?

Digite um nome personalizado para as configurações exportadas.

Store my settings file in this directory.

Especifica o diretório padrão no qual as configurações exportadas serão salvos. Clique Browse para especificar uma pasta personalizada.

Salvar configurações atuais, importar e Assistente para exportação configurações

Use esta página do Assistente para configurações a importação e exportação para salvar as configurações ativos antes de importar novas configurações. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.


Yes, save my current settings

Selecione esta opção para criar um backup das suas configurações atuais. Mais tarde você pode optar por importar essas configurações para retornar ao estado IDE atual.

Visual Studio 42

Setting file name Digite um nome personalizado para as configurações atuais.

Store my settings file in this directory

Especifica o diretório padrão no qual as configurações atuais serão salvos. Clique Browse para especificar uma pasta personalizada.

No, just import new settings, overwriting my current settings

Selecione esta opção se você não quiser backup as configurações atuais. Se você está importando o arquivo configurações contém configurações para itens de categoria você ter personalizado, as configurações importadas substituirá as alterações.

Escolha Configurações para importar, importar e Assistente configurações exportação

Use esta página do Assistente para configurações a importação e exportação para especificar a coleção Configurações você pretende importar. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.


Which settings do you want to import?

Selecione uma coleção na lista, ou clique Browse para localizar uma coleção diferente para importar.

Description

Exibe informações sobre a coleção configurações que são otimizadas para. Somente disponível para Default Settings.

Escolha um coleção de configurações para importar, importar e Assistente configurações exportação

Use esta página do assistente Importar e exportar configurações para especificar uma coleção configurações predefinidos ou uma coleção configurações personalizadas você deseja importar para uso no IDE. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

• Como: Alterar configurações selecionadas

Which collection of settings do you want to import?

Lista as coleções configurações disponíveis. Clique Browse para navegar para uma coleção configurações que não aparece na lista.

Description

Exibe informações sobre a coleção configurações que são otimizadas para. Para obter mais informações sobre coleções configurações predefinidas, consulte Configurações do Visual Studio.

Visual Studio 43

<task> Complete, Import and Export Settings Wizard Esta página do importação e assistente exportar para configurações exibe informações sobre a tarefa configurações concluída com êxito ou não e todos os erros que foram encontrados. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

Details

Exibe informações sobre qualquer sucesso ou falhas.

Visual Studio 44

Walkthroughs Visual C# As explicações passo a passo fornecem instruções passo a passo para cenários comuns, que o torna um bom local para iniciar o aprendizado sobre o produto ou uma área de um recurso específico.

Esta seção contém links para C# programação orientações e depuração orientações.

Explicação Passo a Passo: Criando um XML Web Services usando Visual Basic ou Visual C#

Explicação passo a passo a seguir descreve o processo para criar um XML Web Services que converte temperaturas medidas em Fahrenheit para Celsius usando Visual Basic ou C# visual.

Você durante esta explicação passo a passo, você irá realizar as atividades a seguir:

• Criar um XML Web Services usando o modelo projeto serviço ASP.NET Web.

• Implementar o XML Web Services.

• Executar o XML Web Services no modo de depuração.

• Implantar o XML Web Services.

Para concluir o explicação passo a passo, você precisará ter acesso a uma máquina que atende aos requisitos para criar um projeto da Web. Para obter mais informações, consulte Tour guiado da criação de sites no Visual Web Developer e Passo a passo: Criando e usando um serviço da Web do ASP.NET no Visual Web Developer.

Criar projeto serviço XML da Web

O Visual Studio fornece um modelo de projeto ASP.NET Web Service para ajudá-lo a criar XML Web Services no Visual Basic e Visual C#.

Para criar um ASP.NET Web Service Project 1. No menu File, escolha New Web Site.

2. Na caixa de diálogo New Web Site, selecione o ícone ASP.NET Web Service.

3. Digite o endereço do servidor Web no qual você irá desenvolver o XML Web Services e especifique TempConvert1 como o nome do diretório, tal como " http://MyServer/TempConvert1 ". Por padrão, o projeto usa seu computador local, " http://localhost ".

Observação

Para alguns tipos de projeto, o caixa de texto Name está disponível porque especificando a localidade define em vez disso o nome do projeto. Por exemplo, aplicativos da Web e XML Web Services estão localizados em um servidor Web e derivam seus nomes do diretório virtual especificado no servidor.

Observação

Você desenvolve XML Web Services em um servidor de desenvolvimento. Por padrão, o servidor de desenvolvimento é sua máquina local. Normalmente, voce desenvolve e constrói o projeto em um

Visual Studio 45

servidor de desenvolvimento, e então você o implementa em outro servidor (o servidor se implementação) que irá hospedar o XML Web service usando um projeto de implementação. Entretanto, se você estiver desenvolvendo diretamente no servidor que hospedará o XML Web Services, o servidor de desenvolvimento e o servidor de implantação são os mesmos.

4. Clique OK para criar o projeto.

O Visual Studio automaticamente cria os arquivos necessários e inclui as referências necessárias para suportar um XML Web Services. Quando você criar um projeto XML Web Services no Visual Studio, verá o criador de componente para Service1.asmx.

Implementar o serviço da Web XML

A próxima etapa é escrever o código para implementar a funcionalidade do XML Web Services que os clientes irão acessar. Para XML Web Services criados no Visual Studio, um arquivo oculto code-behind associado ao arquivo.asmx do XML Web Services que o Visual Studio criou para você contém esse código. Para obter mais informações, consulte COMO: Criar um Método de Serviço da Web XML.

Para adicionar um método de XML Web Service 1. No arquivo código Service.vb, localize o código para a declaração de classe

Service. Substituia o código de atributo System.Web.Services.WebService com o seguinte código antes da declaração de classe (mostrada em negrito):

Visual Basic <System.Web.Services.WebService( _ Namespace:="http://Walkthrough/XmlWebServices/", _

Description:="A temperature conversion service.")> _ Public Class Service

[System.Web.Services.WebService( Namespace="http://Walkthrough/XmlWebServices/",

Description="A temperature conversion service.")] public class Service :

System.Web.Services.WebService

Unindo o atributo WebService à classe Public se torna possível a inclusão de informação adicional sobre o XML Web Service, como um namespace para o XML Web Service e uma descrição para o XML Web Service. A propriedade description desse atributo está incluída na página de ajuda de Service. Para obter mais informações, consulte COMO: Usar o Atributo WebService.

2. Na classe Service, adicione o seguinte código para declarar a função ConvertTemperature:

Visual Basic <WebMethod(Description:="This method converts a temperature in " & _ "degrees Fahrenheit to

a temperature in degrees Celsius.")> _ Public Function ConvertTemperature(ByVal dFahrenheit

As Double) _ As Double Return ((dFahrenheit - 32) * 5) / 9 End Function

[WebMethod(Description="This method converts a temperature in " + "degrees Fahrenheit to a

temperature in degrees Celsius.")] public double ConvertTemperature(double dFahrenheit) {

return ((dFahrenheit - 32) * 5) / 9; }

Anexando o atributo WebMethod a um método Public expõe esse método como parte do XML Web Services. A propriedade description deste atributo está incluído na página ajuda de Service e na página de ajuda Service Methods. Para obter mais informações, consulte COMO: Usar o Atributo WebMethod.

3. Clique com o botão direito do mouse Service.asmx em Solution Explorer e clique Set as Start Page no menu de atalho.

Visual Studio 46

4. Salvar a solução.

Depurar o XML Web Service

O Visual Studio oferece vários métodos para criar e executar um XML Web Services a partir da IDE, tais como:

• Iniciar (com depuração)

• Iniciar sem depuração

• Modo de Exibição no navegador

Como um projeto Visual Studio, este XML Web Services tem configurações separadas para as versões de lançamento e depuração. Como você criou este projeto usando o modelo de projeto do serviço da Web ASP.NET, Visual Studio automaticamente criou essas configurações e definiu as opções padrão apropriadas e outras configurações. Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Nesta explicação passo a passo, será colocado um ponto de interrupção no XML Web Services e usado o método Start (with Debugging). Para obter mais informações, consulte Como Depurar XML Web Services em Código Não Gerenciado.

Antes de depuração, verifique as configurações de depuração. Para obter mais informações, consulte Projetos Serviço da Web XML depuração preparação:.

Para usar um ponto de interrupção e iniciar o XML Web Services com depuração 1. No menu Debug, escolher New Breakpoint, então Break At Function.

Na guia Function, digite ConvertTemperature na caixa Function e clique OK para adicionar um ponto de interrupção na declaração de método ConvertTemperature.

2. No menu Debug, clique em Start, clique Ok na janela Debugging Not Enabled para iniciar depuração.

Este comando instrui o Visual Studio a executar o XML Web Services no depurador. O Visual Studio cria o projeto e o implanta para o servidor de desenvolvimento designado. Após a conclusão, o navegador padrão exibe o arquivo.asmx a partir do servidor de implantação.

Quando você abre um arquivo.asmx em um navegador, o XML Web Services retorna uma página Service auxiliar que fornece informações sobre o XML Web Services. O Service Description link leva você para um documento XML que contém a descrição serviço formal do XML Web Services. Para obter mais informações, consulte XML Web Service Description.

3. Na página de ajuda Service, clique no link ConvertTemperature.

4. Na caixa dFahrenheit, digite o número 212, e clique no botão Invoke.

Quando o processamento atingir a função ConvertTemperature, o processamento pára. O depurador Visual Studio realça a linha que contém o ponto de interrupção; enquanto ele é interrompido, você pode executar uma variedade de tarefas. Para obter mais informações, consulte Explicação detalhada sobre o depurador e Exibindo Dados no Depurador.

5. No menu Debug, clique em Continue para continuar o processamento.

6. O XML Web Services responde retornando o valor convertido em um documento XML semelhante ao seguinte:

Visual Studio 47

<?xml version="1.0" encoding="utf-8" ?> <double

xmlns="http://Walkthrough/XmlWebServices/">100</double>

Para interromper a execução do XML Web Services e retornar ao editor de código, no menu Debug, clique em Stop Debugging.

7. No menu Debug, clique em Delete All Breakpoints.

Implantando o XML Web Service

Para tornar seu XML Web Services disponível para outros, você deve implantá-lo em um servidor Web que seja acessível para os clientes que você queira dar suporte. Para distribuir o XML Web Services para um servidor que não seja o servidor de desenvolvimento, você pode adicionar um projeto Web Setup ou copiar os arquivos necessários para o servidor de destino. Nesta explicação passo a passo, você pode escolher como implantar este XML Web Services. Para obter mais informações, consulte COMO: Implantar Serviços da Web XML no Código Gerenciado.

Para implantar o XML Web Services usando um projeto Web Setup 1. No menu File, aponte para Add, e clique New Project.

2. Selecionar o nó Other, e o nó Setup and Deployment Projects, e clique em Web Setup Project.

3. Na caixa Name, digitar TempConvert1WebSetup, e clique OK.

Observação

Por padrão, o instalador usa o nome do projeto de implantação ao criar o diretório virtual em seu servidor de implantação.

4. No painel esquerdo do File System Editor, selecione Web Application Folder. Para obter mais informações, consulte File System Editor.

5. No Solution Explorer, clique com o botão direito do mouse em TempConvert1WebSetup, aponte para Add, e clique Project Output.

6. Na caixa de diálogo Add Project Output Group, selecione Content Files. Para obter mais informações, consulte Como adicionar e remover Outputs Project no File System Editor:.

o O grupo Content Files consiste dos seguintes arquivos para o XML Web Services: Service1.asmx, GLOBAL.asax, e Web.config. Para obter mais informações, consulte COMO: Implantar Serviços da Web XML no Código Gerenciado.

7. Clique em OK.

8. No Solution Explorer, clique com o botão direito do mouse no projetoTempConvert1WebSetup, e no menu de atalho, clique Build.

Isso cria um arquivo do Windows Installer no diretório de projeto local. Executar este arquivo instala o aplicativo da Web.

Para implantar o XML Web Services, copiando o projeto 1. No Solution Explorer, selecione o projeto TempConvert1.

2. No menu Project, clique em Copy Web Site.

3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de diálogo Open Web Site. Navegue para a localidade para a qual você deseja copiar o projeto.

Visual Studio 48

4. No painel Source Web Site, selecione os arquivos para copiar e movê-los para o painel Remote Web Site, clicando no ícone de seta à direita. .

5. Clique Copy Web Site para copiar o site.

Finalmente, para criar um aplicativo cliente que acesse esse XML Web Services, consulte um destes procedimentos:

• Passo-a-Passo: acessando um XML Web Services utilizando Visual Basic ou Visual C#

• Acessar um serviço da Web XML usando C++ Walkthrough:

• Acessar um serviço da Web XML usando C++ e o CLR Walkthrough:

Passo-a-Passo: acessando um XML Web Services utilizando Visual Basic ou Visual C#

A explicação passo-a-passo a seguir descreve o processo para acessar um XML Web Services de um aplicativo criado com Visual Basic ou Visual C#.

Durante o curso desta explicação passo a passo, você irá realizar as atividades a seguir:

• Criar um aplicativo cliente usando o modelo de projeto de aplicativo ASP.NET.

• Adicionar uma referência da Web para um XML Web Services.

• Escrever código para acessar o XML Web Services.

• Executar o aplicativo da Web no modo de depuração.

• Implantar o aplicativo da Web.

Para concluir a explicação passo a passo, você deve fornecer o seguinte:

• Devido ao fato desta explicação passo a passo usar um aplicativo da Web para acessar um XML Web Services, você deve fornecer uma máquina que atenda aos requisitos para criar um projeto da Web. Para obter mais informações, consulte Tour guiado da criação de sites no Visual Web Developer. Você também precisará de permissões suficientes para ser capaz de criar projetos XML Web Services no computador onde seu servidor Web está. Para obter detalhes, consulte Segurança de site ASP.NET (Visual Studio).

• Um XML Web Services criado a partir desta explicação passo a passo: o Explicação Passo a Passo: Criando um XML Web Services usando

Visual Basic ou Visual C#

Criando um projeto cliente de XML Web Services

Nesta explicação passo a passo, você vai criar um aplicativo simples da Web que acessa o XML Web Services TempConvert1, que foi o nome dado ao XML Web Services criado no Explicação Passo a Passo: Criando um XML Web Services usando Visual Basic ou Visual C#.

Observação

Se você alterou o nome do XML Web Services temperatura de conversão ao criá-lo, basta substituir os nomes apropriados onde aparece o nome TempConvert1 ao longo desta explicação passo a passo.

Criar um aplicativo ASP.NET

Visual Studio 49

1. No menu File, escolha New Web Site.

2. Na caixa de diálogo New Web Site, selecione o ícone ASP.NET Web Site.

3. Digite o endereço do servidor Web no qual você irá desenvolver o aplicativo da Web e especifique TempConvertClient1 como o nome do diretório, tal como " http://MyServer/TempConvertClient1 ". Por padrão, o projeto usa sua máquina local, " http://localhost ".

Observação

Para alguns tipos de projeto, a caixa de texto Name está indisponível porque a especificação da localidade define o nome do projeto no lugar. Por exemplo, aplicativos da Web e XML Web Services estão localizados em um servidor Web e derivam seus nomes do diretório virtual especificado nesse servidor.

Observação

Você desenvolve aplicativos da Web em um servidor de desenvolvimento. Por padrão, o servidor de desenvolvimento é sua máquina local. Tipicamente, você desenvolve e compila o projeto em um servidor de desenvolvimento e depois você o implanta em outro servidor (o servidor de implantação) que hospeda o aplicativo da Web usando um projeto de implantação. Entretanto, se você estiver desenvolvendo diretamente no servidor que hospeda o aplicativo da Web, o servidor de desenvolvimento e o servidor implantação são os mesmos.

4. Clique em OK para criar o projeto.

5. No Solution Explorer, clique com o botão direito do mouse em Default.aspx e escolha View Designer para abrir o designer.

6. Da guia Web Forms da Toolbox, arraste uma Text Box, uma Label e um Button para a superfície de design de Default.aspx e organize-os ao seu gosto.

7. Clique com o botão direito do mouse no botão adicionado, Button1, e clique em Properties no menu de atalho. Na janela Properties, defina a propriedade Text como Convert.

8. Clique com o botão direito do mouse no rótulo adicionado, Label1, e clique em Properties no menu de atalho. Na janela Properties, desmarque a propriedade Text para fazer deste um rótulo em branco.

Adicionando uma referência da Web

Descoberta de XML Web Services é o processo pelo qual um cliente localiza um XML Web Services e obtém sua descrição de serviço. O processo de descoberta de XML Web Services no Visual Studio envolve interrogar um site da Web seguindo um algoritmo predeterminado. A meta do processo é localizar a descrição de serviço, que é um documento XML que usa o WSDL (Web Services Description Language). Para obter mais informações, consulte Descoberta de XML Web Service.

A descrição de serviço descreve quais serviços estão disponíveis e como interagir com os serviços. Sem uma descrição de serviço, é impossível interagir com um XML Web Services programaticamente. Para obter mais informações, consulte Descrição de XML Web Service.

Seu aplicativo deve ter um meio para se comunicar com o XML Web Services e para localizá-lo em tempo de execução. Adicionar uma referência da Web ao seu projeto para o XML Web Services faz isso por gerar uma classe proxy que interfaceia com o XML Web Services e fornece uma representação local do XML Web Services. Para

Visual Studio 50

obter mais informações, consulte Referências da Web e Gerando um Proxy de XML Web Service.

Adicionar uma referência da Web 1. No menu Website, escolha Add Web Reference.

2. Na caixa URL da caixa de diálogo Add Web Reference, digite o URL para obter a descrição de serviço do XML Web Services que você deseja acessar, tal como http://localhost/TempConvert1/Service1.asmx. Clique no botão Go para recuperar informações sobre o XML Web Services.

- ou -

Se o XML Web Services está na máquina local, clique no link Web services on the local machine no painel do navegador. Clique no link para o XML Web Services TempConvert1 na lista fornecida para recuperar informações sobre o XML Web Services.

3. Na caixa Web reference name, renomeie a referência da Web para ConvertSvc, que é o namespace que você usará para essa referência da Web.

4. Clique em Add Reference para adicionar uma referência da Web para o XML Web Services destino. Para obter mais informações, consulte Adicionando e Removendo Referências da Web.

O Visual Studio baixa a descrição de serviço e gera uma classe proxy para interfacear entre seu aplicativo e o XML Web Services.

Acessando o XML Web Services

Quando você adiciona uma referência para o XML Web Services ao seu projeto, a próxima etapa consiste em criar uma instância da classe proxy do XML Web Services. Você pode acessar os métodos do XML Web Services da mesma maneira que você acessa quaisquer métodos de objeto, chamando métodos na classe proxy. Quando o aplicativo chama esses métodos, o código da classe proxy gerado pelo Visual Studio lida com as comunicações entre seu aplicativo e o XML Web Services.

Primeiro, você criará uma instância da classe proxy do XML Web Services. Em seguida, você pegará um valor, fornecido em TextBox1, e fará uma chamada para o método ConvertTemperature do XML Web Services usando a classe proxy. Você então irá exibir o valor retornado do XML Web Services no Label1.

Acessar o XML Web Services 1. Clique duas vezes no botão Convert em WebForm1.aspx para criar um

método de tratamento de evento para este botão e para exibir o arquivo code-behind.

2. Insira o código a seguir: ' Visual Basic Protected Sub Button1_Click(ByVal sender As Object, _ ByVal e as EventArgs)

Handles Button1.Click Dim ws As New ConvertSvc.Service Dim dFahrenheit As Double Dim

dCelsius As Double Try dFahrenheit = Convert.ToDouble(TextBox1.Text) dCelsius =

ws.ConvertTemperature(dFahrenheit) Label1.Text = dCelsius.ToString() Catch Label1.Text =

"Conversion failed." End Try End Sub // C# protected void Button1_Click (System.Object sender,

System.EventArgs e) { try { ConvertSvc.Service1 ws = new ConvertSvc.Service1(); double

dFahrenheit = Convert.ToDouble(TextBox1.Text); double dCelsius =

ws.ConvertTemperature(dFahrenheit); Label1.Text = dCelsius.ToString(); } catch { Label1.Text =

"Conversion failed."; } }

Visual Studio 51

Observação

O nome da classe de XML Web Services gerado ao adicionar uma referência da Web pode diferir daquele mostrado acima como Service1.

3. Selecione Default.aspx no Solution Explorer.

4. No menu Website, clique em Set as Start Page.

5. Salve a solução.

Para obter mais informações, consulte Acessando um XML Web Services em Código Gerenciado.

Depurando o cliente de XML Web Services

O Visual Studio oferece vários métodos para criar e executar um aplicativo da Web a partir do IDE, tais como:

• Start (with Debugging)

• Start without Debugging

• View in Browser

Como um projeto do Visual Studio, este aplicativo da Web tem configurações separadas para versões Release e Debug. Desde que você criou este projeto usando o modelo de projeto de aplicativo ASP.NET, o Visual Studio automaticamente criou essas configurações e definiu as opções padrão apropriadas e outras configurações. Para obter mais informações, consulte Configurações Debug e Release.

Nesta explicação passo a passo, você colocará um ponto de interrupção no evento Button1_Click e usará o método Start (with debugging). Para obter mais informações, consulte Depurando XML Web Services em Código Gerenciado.

Antes da depuração, verifique as configurações de depuração. Para obter mais informações, consulte Preparação de Depuração: Aplicativos ASP.NET.

Usar um ponto de interrupção e iniciar o aplicativo da Web com depuração 1. No menu Debug, clique em New Breakpoint e em seguida escolha Break

At Function.

Digite Button1_Click na caixa Function e clique em OK para colocar um ponto de interrupção no manipulador de eventos Button1_Click. Para obter mais informações, consulte Visão geral sobre pontos de interrupção.

2. No menu Debug, clique em Start, depois clique em Ok na janela Debugging Not Enabled para iniciar a depuração.

Este comando instrui o Visual Studio a executar o aplicativo da Web no depurador. O Visual Studio compila o projeto e o implanta no servidor de desenvolvimento designado. Após a conclusão, o navegador padrão inicia e navega para o arquivo .aspx no servidor implantação.

3. Depois que a página é exibida no navegador, digite o número 212 na caixa de texto e depois clique no botão Convert.

Quando o processamento atinge o manipulador de eventos Button1_Click, o processamento pára. O depurador do Visual Studio realça a linha que contém o ponto de interrupção e, enquanto interrompido, você poderá executar uma

Visual Studio 52

variedade de tarefas. Para obter mais informações, consulte Usando o Depurador e Ferramentas de Depuração para Inspeção de seu Programa.


5. O XML Web Services responde retornando o valor convertido e o aplicativo define o texto do Label1 para 100.

Para interromper a execução do aplicativo da Web e retornar ao editor de código, no menu Debug, clique em Stop Debugging.

6. No menu Debug, clique em Clear All Breakpoints.

Implantando o cliente

Para tornar seu aplicativo da Web disponível para outros, você deve implantá-lo em um servidor Web que seja acessível para os clientes que você deseja dar suporte. Para implantar o aplicativo da Web em um servidor que não seja o servidor de desenvolvimento, você pode adicionar um Web Setup Project ou copiar os arquivos necessários para o servidor de destino. Nesta explicação passo a passo, você pode escolher como implantar este aplicativo da Web. Para obter mais informações, consulte Implantando Aplicativos e Componentes.

Implantar o aplicativo da Web usando um Web Setup Project 1. No menu File, aponte para Add e depois clique em New Project.

2. Selecione o nó Other e depois o nó Setup and Deployment Projects e depois clique em Web Setup Project.

3. Na caixa Name, digite TempConvertClient1WebSetup e depois clique em OK.

Observação



5. No Solution Explorer, clique com o botão direito do mouse em TempConvertClient1WebSetup, aponte para Add e depois clique em Project Output.

6. Na caixa de diálogo Add Project Output Group, selecione Content Files. Para obter mais informações, consulte Adicionando e Removendo Saídas de Projetos no File System Editor.

o O grupo Content Files consiste nos arquivos restantes para o aplicativo da Web, tais como WebForm1.aspx e Web.config.

7. Clique em OK.

8. No Solution Explorer, clique com o botão direito do mouse no projeto TempConvertClient1WebSetup e, no menu de atalho, clique em Build.

Isso cria um arquivo do Windows Installer no diretório do projeto local. Executar este arquivo instala o aplicativo da Web.

Implantar o aplicativo da Web, copiando o projeto 1. No Solution Explorer, selecione o projeto TempConvertClient1.


Visual Studio 53

3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de diálogo Open Web Site. Navegue para a localidade que você deseja copiar o projeto.

4. No painel Source Web Site, selecione os arquivos para copiar e mova-os para o painel Remote Web Site, clicando no ícone da seta direita.

5. Clique em Copy Web Site para copiar o site da Web.

Um componente com Visual C# Walkthrough: criação Componentes forneça reutilizáveis código sob a forma de objetos. É conhecido como um aplicativo que usa código é um componente,, criando objetos e chamar suas propriedades e métodos, um Cliente. Um cliente pode ou não pode estar no mesmo conjunto como um componente ele usa.

Os seguintes procedimentos criar no entre si, de forma a ordem na qual você realizá-las é importante.

Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Criando o projeto

Para criar a biblioteca de classes CDemoLib e o componente CDemo 1. No menu File, selecione New e Project Para abrir caixa New Project de

diálogo. Selecione o Class Library modelo de projeto a partir da lista de Visual C# tipos de projeto, e digite CDemoLib na caixa Name.

Observação

Sempre especifique o nome de um novo projeto ao criá-la. Isso define o espaço para nome raiz, nome conjunto, e nome do projeto, e também garante que o componente padrão será no espaço para nome correto.

2. No Solution Explorer, clique com o botão direito do mouse CDemoLib e selecione Properties a partir do menu de atalho. Observe que a Default namespace caixa contém CDemoLib.

A raiz é usado para qualificar os nomes dos componentes no conjunto. Por exemplo, se dois conjuntos de módulos (assemblies) fornecer componentes nomeado CDemo, você pode especificar seu CDemo componente usando CDemoLib.CDemo Feche a caixa de diálogo.

3. A partir do Project menu, escolha Add Component.

4. Na caixa Add New Item de diálogo, selecione Component Class e digite CDemo.cs na caixa Name. Clique Add para crate o componente.

Um componente denominado CDemo é adicionado à sua biblioteca de classe.

5. No Solution Explorer, clique com o botão direito do mouse CDemo.cs e escolha View Code a partir do menu de atalho. Abre o editor de código.

Visual Studio 54

Aviso imediatamente após public partial class CDemo. o : Component Esta seção designa a classe da qual a classe herda. Por padrão, um componente herda da classe Component fornecida pelo sistema. A Component classe fornece vários recursos para o componente, incluindo a capacidade para usar designers.

6. No Solution Explorer, clique com o botão direito do mouse Class1.cs e escolha Delete. Isso exclui a classe padrão que é fornecido com a biblioteca de classes, como ele não será ser usado nessa explicação passo a passo.

7. No menu File, optar Save All por salvar o projeto.

Adicionando Constructors e Destructors

Construtores controlar a maneira como o componente foi inicializado; o Finalize método controla a forma ele tears pressionada. Código no construtor e o Finalize método da CDemo classe mantém uma contagem do número de CDemo objetos em execução no existência.

Para adicionar código para o construtor e destruidor da classe CDemo 1. No total de ocorrências de um número de identificação para cada instância

da CDemo classe, e. Adicione variáveis de membros para manter uma execução o Code Editor public readonly int InstanceID; private static int NextInstanceID = 0; private static long

ClassInstanceCount = 0;

Porque e NextInstanceID variáveis de membros são declaradas static, eles existem somente no nível de classe. o InstanceCount Todas as instâncias do CDemo que acessar esses membros usará os mesmos locais de memória. Membros estático serão inicializados na primeira vez a CDemo classe é mencionado no código. Isso pode ser a primeira vez um CDemo objeto é criado, ou na primeira vez um dos membros estático é acessado.

2. Localizar public CDemo() e public CDemo(IContainer container), a construtores padrão para a CDemo classe. No Visual C#, todos os construtores ter o mesmo nome que a classe. O componente pode ter vários construtores, com parâmetros diferentes, mas deve todas terão o mesmo nome que o componente.

Observação

O nível de acesso dos construtores determina os clientes serão capazes de criar instâncias da classe.

3. Adicione o código a public CDemo() Seguir para incrementar a contagem instância quando um novo CDemo for criado, e para definir o número de identificação de instância.

Observação

Sempre adicionar seu código após a chamada para InitializeComponent. Nesse momento, os componentes constituintes ter sido inicializada.

4. InstanceID = NextInstanceID ++; ClassInstanceCount ++;

5. Como um readonly membro, InstanceID pode ser definida somente no construtor.

Observação

Usuários familiarizados com será multithreading destacar bastante rightly que atribuir InstanceID e incrementando NextInstanceID deve ser uma operação atômico. Isso e outros problemas relacionados a

Visual Studio 55

segmentação está ilustrado no Um componente Multithreaded Simple com Visual C# Walkthrough: criação.

6. Adicione o seguinte método depois do fim do construtor: ~CDemo() { ClassInstanceCount --; }

Este método é chamado e é signified pelo caractere til (~) na frente do nome de classe. a destruidor, O gerenciador de memória chama o destruidor imediatamente antes ele finalmente reclaims memória ocupado pelo objeto CDemo. Ao implementar um destruidor você pode executar limpeza apenas antes o componente é removido da memória. No entanto, como você poderá ver posteriormente nessa explicação passo a passo, há bons motivos para recursos versão anterior.

Adicionar uma propriedade à classe

A CDemo classe tem apenas uma propriedade, uma propriedade estática que permite que o cliente para descobrir quantos CDemo objetos não estão na memória a qualquer dado momento. Métodos podem ser criados no uma maneira semelhante.

Para criar uma propriedade para a classe CDemo • Adicione a seguinte declaração propriedade à classe CDemo, para permitir que

clientes se recuperar o número de instâncias do CDemo. public static long InstanceCount { get { return ClassInstanceCount; } }

Teste o componente

Para testar o componente, é necessário um projeto que o utiliza. Este projeto deve ser o primeiro projeto que inicia quando você pressiona o botão Executar.

Para adicionar o projeto cliente CDemoTest como o projeto de inicialização para a solução 1. No menu File, aponte para Add e escolha New Project para abrir a Add

New Project caixa de diálogo.

2. Selecione o Windows Application modelo de projeto, digite CDemoTest na caixa Name e clique em OK.

3. Na Solution Explorer, clique com o botão direito do mouse CDemoTest e clique na Set as Startup Project partir do menu de atalho.

Para usar o CDemo componente, o projeto teste cliente deve ter uma referência para o projeto de biblioteca de classes. Após adicionar a referência, ele é uma boa idéia para adicionar uma using instrução ao aplicativo de teste para simplificar o uso de componente.

Para adicionar uma referência para o projeto de biblioteca de classes 1. Clique com botão direito no Solution Explorer, mouse no References nó

imediatamente abaixo CDemoTest, e selecione Add Reference a partir do menu de atalho.

2. Na caixa Add Reference de diálogo, selecione a Projects guia.

3. Clique duas vezes o CDemoLib projeto de biblioteca de classes. Aparecerá CDemoLib sob o References nó para o CDemoTest projeto.

4. No Solution Explorer, clique com o botão direito do mouse Form1.cs e selecione View Code a partir do menu de atalho.

Visual Studio 56

Ou seja, CDemoLib.CDemo adicionando a referência à CDemoLib, você pode usar o nome totalmente qualificado do componente CDemo—.

Para adicionar uma usando instrução • Adicione a instrução a seguir using para a lista de using instruções na parte

superior da para Form1. o Code Editor using CDemoLib;

Adicionando a using instrução, você pode omitir o nome da biblioteca, e consultar o tipo componente como CDemo.

Você agora criará e usar um programa de teste para testar o componente.

Noções básicas sobre vida útil de objeto

O CDemoTest programa será ilustram vida útil de objeto do .NET Framework, criando e liberar um grande número de CDemo objetos.

Para adicionar código para criar objetos e versão CDemo 1. Clique Form1.cs[Design] para retornar para o designer.

2. Arraste até a Form1 superfície de design. e Button Um Timer na guia All Windows Forms do Toolbox

O componente nonvisual Timer aparece em uma superfície de design separadas abaixo do formulário.

3. Clique duas vezes no ícone do timer1 para criar um método tratamento de eventos do evento do componente Tick timer1. Colocar o seguinte código no método tratamento de eventos. this.Text = "CDemo instances: " + CDemo.InstanceCount;

Legenda do formulário em cada escala do timer, exibirá a contagem instância atual para a CDemo classe. O nome de classe é usado como um qualificador para a propriedade — estáticos InstanceCount não está há necessidade de criar uma instância do CDemo para acessar um membro estático.

4. Localizar o construtor para Form1 (public Form1(). e adicione o código a seguir após a chamada para InitializeComponent()), timer1.Enabled = true;

Isso irá iniciar o cronômetro tão logo o formulário é criado.

5. Clique na Form1.cs [Design] guia para retornar para o designer.

6. Clique duas vezes no Form1, para criar um método tratamento de eventos para eventos do botão Click. o Button Colocar o seguinte código no método tratamento de eventos. CDemo cd; int ct; for (ct = 0; ct < 1000; ct++) cd = new CDemo();

Esse código pode aspecto estranhos para você. Conforme cada instância do CDemo é criado, a instância anterior será liberado. Quando o for loop for feito, haverá somente uma instância do CDemo Esquerda. Quando o método tratamento de eventos-sai, mesmo essa instância será lançado, porque a variável cd sairá do escopo.

Como você pode ter guessed já não acontecem bastante dessa maneira.

Para executar e depurar o CDemoTest e CDemo projetos 1. Pressione F5 para iniciar a solução.

Visual Studio 57

O projeto cliente for iniciado, e Form1 será exibido. Observe que a legenda do formulário exibe " 0 ". instâncias CDemo:

2. Clique no botão. A legenda do formulário deve exibir " 1000". instâncias CDemo:

As instâncias de CDemo foram todos liberados pelo tempo procedimento tratamento de eventos do botão Click concluído. Por que não elas foi finalizado? Além BRIEF, o gerenciador de memória finalizes objetos em segundo plano, com prioridade baixa. A prioridade apenas é bumped backup se obtém o Sistema com memória insuficiente. Este lenta esquema coleção lixo permite a alocação Objeto muito rápida.

3. Clique no botão Mais várias vezes, observando a legenda. Em algum momento, o número de instâncias irá descartar inesperadamente Isso significa o gerenciador de memória que tem recuperou a memória de alguns dos objetos.

Observação

Se você clicou mais de 10 vezes, e o número de CDemo instâncias não tiver diminuído, talvez precise ajustar o código de modo que ele usa mais memória. Fechar o formulário para retornar ao ambiente de desenvolvimento, e aumentar o número de iterações no for loop para 10000. Em seguida, execute o projeto novamente.

4. Repita a etapa 3. Você obterá farther neste momento antes o gerenciador de memória finalizes mais objetos.

Na verdade, sempre que você repita a etapa 3, você provavelmente será capaz para alocar mais CDemo objetos antes a memória etapas Gerenciador no. Isso é porque mais e mais dos Visual Studio é trocado Out, deixando mais espaço para instâncias de CDemo.

5. Fechar o formulário para retornar ao ambiente de desenvolvimento.

Tarefas comuns usando marcas inteligentes em controles Forms Windows fazendo Walkthrough:

Como você construir formulários e controles para seu aplicativo do Windows Forms, há várias tarefas você executará repetidamente. Estes são alguns das tarefas realizadas normalmente você encontrará:

• Adicionar ou remover uma guia na uma TabControl.

• Encaixe um controle para seu pai.

• Alterar a orientação de um SplitContainer controle.

Para acelerar o desenvolvimento, muitos controles oferecem marcas inteligentes que são menus contextuais que permitem a você para executar tarefas comuns como essas em um único gesto em tempo de criação. Essas tarefas são chamados verbos de marca inteligente.

Marcas inteligentes permanecem anexado a uma instância de controle para sua vida útil no designer e estão sempre disponíveis.

Tarefas ilustradas nesta explicação passo a passo incluem:

• Criar um Projeto Windows Forms

Visual Studio 58

• Usando marcas inteligentes

• Habilitando e desabilitando marcas inteligentes

Quando você tiver terminado, você terá uma compreensão da função executado por esses recursos importantes layout.

Observação


Criando o projeto

A primeira etapa é para criar o projeto e configurar o formulário.

Para criar o projeto 1. Criar um projeto chamado " SmartTagsExample " aplicativo baseado no

Windows. Para obter detalhes, consulte Como: Criar um projeto de aplicativos Windows.

2. Selecione o formulário no Windows Forms Designer.

Usando marcas inteligentes

Marcas inteligentes estão sempre em tempo de criação em controles que oferecem-los disponíveis.

Para usar marcas inteligentes 1. Arraste até o formulário. de um TabControl a Toolbox Observe o glifo de

marca inteligente ( . o TabControl) que aparece na parte lateral do

2. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o glifo, selecione o Add Tab item. Observar se uma nova página guia foi adicionado ao TabControl.

3. Arraste um TableLayoutPanel controle de até seu formulário. o Toolbox

4. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o glifo, selecione o Add Column item. Observar que uma nova coluna será adicionada para o TableLayoutPanel controle.

5. Arraste um SplitContainer controle de até seu formulário. o Toolbox

6. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o glifo, selecione o Horizontal splitter orientation item. Observar que a SplitContainer barra divisora do controle agora é orientado horizontalmente.

Coleções dos tipos padrão com o DesignerSerializationVisibilityAttribute Serializing Walkthrough:

Às vezes os controles personalizados será expor uma coleção como uma propriedade. Essa explicação passo a passo demonstra como usar a DesignerSerializationVisibilityAttribute classe para controlar como uma coleção é serializado em tempo de criação. Aplicar o Content valor a sua propriedade coleção garante que a propriedade será ser serializado.

Visual Studio 59

Para copiar o código contidas neste tópico como uma lista simples, consulte COMO: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute.

Observação


Pré-requisitos

A fim de concluir este explicação passo a passo, será necessário:

• Permissões suficientes para poder para criar e executar projetos aplicativo do Windows Forms no computador onde o Visual Studio está instalado.

Criar um controle que possui uma coleção Serializable

A primeira etapa consiste em criar um controle que tenha uma coleção Serializable como uma propriedade. Você pode editar o conteúdo da coleção usando este que você pode acessar a partir da Properties janela. o Collection Editor

Para criar um controle com uma coleção Serializable 1. Criar um Projeto Biblioteca de Controle do Windows chamado

SerializationDemoControlLib. Para obter mais informações, consulte Modelo de Biblioteca de Controle do Windows.

2. Renomear UserControl1 para SerializationDemoControl. Para obter mais informações, consulte Renomear identificadores como:.

3. Na janela Properties, defina o valor da propriedade System.Windows.Forms.Padding.All para 10.

4. Coloca um TextBox controle no SerializationDemoControl.

5. Selecione o TextBox controle. Na janela Properties, defina as propriedades a seguir.

Propriedade Alterar para

Multiline true

Dock Fill

ScrollBars Vertical

ReadOnly true

6. Em declarar um campo denominado stringsValue na SerializationDemoControl matriz de seqüência. o Code Editor

C# // This field backs the Strings property. private String[] stringsValue = new String[1];

7. Defina a Strings propriedade no SerializationDemoControl.

Observação

O Content valor é usado para ativar a serialização de coleção.

C#

Visual Studio 60

// When the DesignerSerializationVisibility attribute has // a value of "Content" or "Visible" the designer

will // serialize the property. This property can also be edited // at design time with a CollectionEditor.

[DesignerSerializationVisibility( DesignerSerializationVisibility.Content )] public String[] Strings { get {

return this.stringsValue; } set { this.stringsValue = value; // Populate the contained TextBox with the

values // in the stringsValue array. StringBuilder sb = new StringBuilder(this.stringsValue.Length); for

(int i = 0; i < this.stringsValue.Length; i++) { sb.Append(this.stringsValue[i]); sb.Append("\r\n"); }

this.textBox1.Text = sb.ToString(); } }

Observação

As seqüências que você digitou aparecem na TextBox. do SerializationDemoControl

A serialização uma propriedade da coleção

Para testar o comportamento serialização do seu controle, você será colocar ele em um formulário e alterar o conteúdo da coleção com o Collection Editor.. o Collection Editor Você pode ver o estado coleção serializado olhando para um arquivo de designer especial, no qual código emite. o Windows Forms Designer

Para serializar uma coleção 1. Adicionar um projeto do Aplicativo do Windows à solução. Para obter mais

informações, consulte Caixa de diálogo Add New Project. Nome do projeto SerializationDemoControlTest.

2. Na Toolbox, localização na guia chamado SerializationDemoControlLib Components. Em nessa guia, você encontrará o SerializationDemoControl. Para obter mais informações, consulte A caixa de ferramentas com Components personalizado Walkthrough: Populating automaticamente.

3. Local em seu formulário. um SerializationDemoControl

4. Localizar a Strings propriedade na janela Properties. Clique a Strings propriedade, na elipse seguida, clique no String Collection Editor. ( ) botão para abrir

5. Digitar várias seqüências no String Collection Editor. Separe-os, pressionando a tecla ENTER no final de cada seqüência. Clique em OK Quando você tiver terminado inserir seqüências.

Observação

As seqüências que você digitou aparecem na TextBox. do SerializationDemoControl

1. No Solution Explorer, clique no Show All Files botão.

2. Abra o Form1 nó. Beneath é um arquivo chamado Form1.Designer.cs ou Form1.Designer.vb. Este é o arquivo no qual emite código que representa o estado de seu formulário e seus controles filho Design-time. o Windows Forms Designer Abrir este arquivo no Code Editor.

3. Abra a região denominada Windows Form Designer generated code e localize a seção rotulada serializationDemoControl1. Sob este rótulo é o código que representa o estado de seu controle serializado. As seqüências você digitou na etapa 5 aparecem em uma atribuição para a Strings propriedade. O exemplo de código a seguir mostra um código semelhante ao que será exibida se você digitado seqüências " red ", " laranjas ", e " Amarelo ".

Visual Studio 61

C# this.serializationDemoControl1.Strings = new string[] { "red", "orange", "yellow"};

C# [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

Observação

Nesse caso, emite nenhuma atribuição para a Strings propriedade. o Windows Forms Designer

Próximas etapas

Depois que você sabe como serializar uma coleção de tipos padrão, considere integrar os controles personalizados mais profundamente para o ambiente em tempo de criação. Os tópicos a seguir descrevem como aprimorar a integração em tempo de criação do seu controles personalizados:

• Arquitetura Design-time

• Atributos do Windows Forms controles

• Visão geral da serialização designer

• Criando um controle do Windows Forms que Takes Advantage dos recursos de tempo de design visual studio Walkthrough:

Walkthrough: depuração controles Forms do Windows personalizados em tempo de design

Quando você cria um controle personalizado, você geralmente achará necessário para depurar seu comportamento em tempo de criação. Isso é especialmente verdadeiro se você estiver criando um designer personalizado para o controle personalizado. Para obter detalhes, consulte Criando um controle do Windows Forms que Takes Advantage dos recursos de tempo de design visual studio Walkthrough:.

Você pode depurar os controles personalizados usando o Visual Studio, exatamente como você deseja depurar as outras classes .NET Framework. A diferença é que você irá depurar uma instância separada do Visual Studio que esteja executando código do seu controle personalizado


• Criar um Projeto Windows Forms para hospedar o controle personalizado

• Criar um Projeto Biblioteca de Controle

• Adicionar uma propriedade a seu controle personalizado

• Adicionando o controle personalizado ao formulário host

• Como configurar o projeto para design-time depuração

• Depuração seu controle personalizado em tempo de criação

Quando você tiver terminado, você terá uma compreensão das tarefas necessárias para depuração o comportamento em tempo de criação de um controle personalizado.

Visual Studio 62

Observação


Criando o projeto

A primeira etapa consiste em criar o projeto de aplicativo. Você usará este projeto para criar o aplicativo que hospeda o controle personalizado.

Para criar o projeto • Criar um projeto do Aplicativo do Windows chamado " DebuggingExample ".

Para obter detalhes, consulte Como: Criar um projeto de aplicativos Windows.

Criar um Projeto Biblioteca de Controle

A próxima etapa é para criar o projeto Biblioteca de Controle e configurar o controle personalizado.

Para criar o projeto Biblioteca de Controle 1. Adicione um Windows Control Library projeto para a solução. Para obter

detalhes, consulte Caixa de diálogo Add New Project. Nome do projeto " DebugControlLibrary ".

2. Adicionar um novo UserControl item para o projeto DebugControlLibrary. Para obter detalhes, consulte Como: Adicionar novos itens de projeto. Dê o novo arquivo de origem uma nome de base de " DebugControl ".

3. Usando a Solution Explorer, exclusão, excluindo o arquivo com um nome de base de código padrão do projeto controlar " " UserControl1. Para obter detalhes, consulte COMO: Remover, excluir, e excluir itens.

4. Compilar uma solução.

Ponto de Verificação

Neste ponto, você será capaz para ver o controle personalizado no Toolbox.

Para verificar o seu andamento • Localizar o nova guia chamada DebugControlLibrary Components e clique

para selecioná-lo. Ao ser aberto, você verá seu controle listados como DebugControl com o ícone padrão ao lado dela.

Adicionar uma propriedade ao seu controle personalizado

Para demonstrar que o controle personalizado na código sendo executado em tempo de criação, será adicionar uma propriedade e definir um ponto de interrupção no código que implementa a propriedade.

Para adicionar uma propriedade ao seu controle personalizado 1. Aberto DebugControl no Code Editor. Adicione o seguinte código para a

definição de classe:

C# private string demoStringValue = null;

[Browsable(true)]

public string DemoString

{ get

Visual Studio 63

{ return this.demoStringValue; }

set { demoStringValue = value; } }


Adicionando seu controle personalizado ao formulário host

Para depurar o comportamento em tempo de criação do seu controle personalizado, você irá colocar uma instância da classe controle personalizado em um formulário host.

Para adicionar o controle personalizado ao formulário host 1. No projeto " DebuggingExample ", abra Form1 no Windows Forms

Designer.

2. Na Toolbox, abra a DebugControlLibrary Components guia e arraste uma DebugControl instância para o formulário.

3. Localizar a DemoString propriedade personalizada na janela Properties. Observação que você pode alterar seu valor como você faria qualquer outra propriedade. Também Observe que quando a DemoString propriedade está selecionada, seqüência de caracteres de descrição da propriedade aparece na parte inferior da janela Properties.

Configurando o Project para depuração de tempo de design

Você para depurar comportamento em tempo de criação do seu controle personalizado, será depurar uma instância separada do Visual Studio que esteja executando código do seu controle personalizado.

Para configurar o projeto para design-time depuração 1. Clique com o botão direito do mouse no projeto DebugControlLibrary no e

selecione Properties. o Solution Explorer

2. Na folha DebugControlLibrary de propriedades, selecione a Debug guia.

Na seção Start Action, marque Start external program. Não será depuração uma instância separada do Visual Studio, portanto clique a elipse. ( ) botão para procurar por Visual Studio IDE O nome do arquivo executável é devenv.exe, e se você instalado para o local padrão, seu caminho será " 8\Common7\IDE\devenv.exe Visual Studio C:\Program Files\Microsoft ".

3. Clique OK para fechar a caixa de diálogo.

4. Clique com o botão direito do mouse o DebugControlLibrary projeto e selecione Set as StartUp Project Para ativar essa configuração de depuração.

Depuração seu controle personalizado em tempo de design

Agora você está pronto para depurar o controle personalizado à medida que ele é executado em modo de design. Quando você iniciar a sessão de depuração, será criada uma nova instância do Visual Studio, e irá usá-lo para carregar a solução " DebuggingExample ". Quando você abre Form1 em uma instância do seu controle personalizado será criado e será iniciado executando. o Forms Designer

Para depurar o controle personalizado em tempo de criação 1. Abrir o DebugControl arquivo de origem no e colocar um ponto de

interrupção no Set acessador da propriedade DemoString. o Code Editor

Visual Studio 64

2. Pressione F5 para iniciar a sessão de depuração. Observe que uma nova instância do Visual Studio é criado. Você pode distinguir entre as instâncias de duas maneiras:

o A instância de depuração tem a palavra Running em sua barra de título

o A instância de depuração tem o Start Botão em sua Debug barra de ferramentas desativado

O ponto de interrupção é definido na instância de depuração.

3. Na nova instância do Visual Studio, abra a solução " DebuggingExample ". A solução você pode localizar facilmente selecionando Recent Projects no File menu. O arquivo solução " DebuggingExample.sln " será listado como o arquivo mais recentemente usado.

4. Abrir Form1 em e selecione o DebugControl controle. o Forms Designer

5. Alterar o valor da propriedade DemoString. Observe que quando você confirmar a alteração, a instância de depuração do Visual Studio obtém foco e a execução pára em seu ponto de interrupção. Você pode passo único através o acessador Propriedade exatamente como. seria qualquer outro código seu

6. Quando você tiver terminado com a sessão de depuração, você pode sair, descartando a instância do Visual Studio hospedado ou clicando no Stop Debugging botão na instância de depuração.

Próximas etapas

Agora que você pode depurar os controles personalizados em tempo de criação, existem muitas possibilidades para expandir o controle na interação com o Visual Studio IDE.

• Você pode usar a DesignMode propriedade da classe Component para escrever código que será executada apenas em tempo de criação Para obter detalhes, consulte DesignMode.

• Há vários atributos você pode aplicar a propriedades seu controle para manipular o controle personalizado na interação com o designer. Você pode encontrar esses atributos no espaço para nome System.ComponentModel.

• Você pode escrever um designer personalizado para o controle personalizado. Isso permite total controle sobre a experiência de design usando a infra-estrutura extensível Designer expostos pelo Visual Studio. Para obter detalhes, consulte Criando um controle do Windows Forms que Takes Advantage dos recursos de tempo de design visual studio Walkthrough:.

Criando um controle do Windows Forms que Takes Advantage dos recursos de tempo de design visual studio Walkthrough:

A experiência em tempo de design para um controle personalizado pode ser aperfeiçoada pela criação um designer personalizado associado.

Essa explicação passo a passo ilustra como criar um designer personalizado para um controle personalizado. Você irá implementar um MarqueeControl tipo e uma classe designer associado, chamado MarqueeControlRootDesigner.

O MarqueeControl tipo implementa uma exibição semelhante a um letreiro digital theater, com luzes animado e texto flashing.

Visual Studio 65

O designer para este controle interage com o ambiente de design para fornecer uma experiência Design-time personalizado. Com o designer personalizado, você pode montar uma implementação personalizada MarqueeControl com luzes animado e flashing texto em várias combinações. Você pode usar o controle montado em um formulário como qualquer outro controle Windows Forms.


• Criando o projeto

• Criar um Projeto Biblioteca de Controle

• Referência a Project controle personalizado

• Definir um controle personalizado e seus designer personalizado

• Criando uma instância de seu controle personalizado

• Configurando o Project para depuração de tempo de design

• Implementar O controle personalizado

• Criando um controle filho para O controle personalizado

• Criar o controle filho MarqueeBorder

• Criando um designer personalizado para sombra e propriedades de filtro

• Tratamento alterações componente

• Adicionando verbos criador ao seu designer personalizado

• Criando um UITypeEditor personalizada

• Testando o controle personalizado no criador

Quando você tiver terminado, o controle personalizado será algo como o seguinte aspecto:

Para a listagem código completo, consulte COMO: Criar um controle de formulários do Windows que tira vantagem de recursos em tempo de criação.

Observação


Pré-requisitos


• Permissões suficientes para poder para criar e executar projetos aplicativo do Windows Forms no computador onde o Visual Studio está instalado.

Criando o projeto

Visual Studio 66

A primeira etapa consiste em criar o projeto de aplicativo. Você usará este projeto para criar o aplicativo que hospeda o controle personalizado.

Para criar o projeto • Criar um projeto do Aplicativo do Windows chamado " MarqueeControlTest ".

Para obter mais informações, consulte Como: Criar um projeto de aplicativos Windows.

Criar um Projeto Biblioteca de Controle

A próxima etapa consiste em criar o projeto Biblioteca de Controle. Você criará um novo controle personalizado e seu designer personalizado correspondente.

Para criar o projeto Biblioteca de Controle 1. Adicione um projeto Biblioteca de Controle do Windows para a solução. Para

obter mais informações, consulte Caixa de diálogo Add New Project. Nome do projeto " MarqueeControlLibrary ".

2. Usando Solution Explorer, Excluir controle padrão do projeto, excluir o arquivo de origem nomeado " UserControl1.cs " ou " UserControl1.vb ", acordo com o idioma de escolha. Para obter mais informações, consulte COMO: Remover, excluir, e excluir itens.

3. Adicionar um novo UserControl item para o MarqueeControlLibrary projeto. Dar o novo arquivo de origem uma nome de base de " MarqueeControl ".

4. Usando Solution Explorer, criar uma nova pasta no projeto MarqueeControlLibrary. Para obter mais informações, consulte Como: Adicionar novos itens de projeto.Nomeie a nova pasta " Design ".

5. Clique com o botão direito do mouse na Design pasta e adicionar uma nova classe. Fornecer o arquivo de origem uma nome de base de " MarqueeControlRootDesigner ".

6. Será necessário para usar tipos de montagem System.Design, então adicionar essa referência para o MarqueeControlTest projeto. Para obter mais informações, consulte COMO: Adicionar e remover referências no Visual Studio (C#, J#).

Referência a Project controle personalizado

Você usará o MarqueeControlTest projeto para testar o controle personalizado. O projeto teste tornará conhecer o controle personalizado quando você adiciona uma referência ao conjunto MarqueeControlLibrary Projeto.

Para fazer referência o projeto de controle personalizado • No projeto MarqueeControlTest, adicione uma referência ao conjunto

MarqueeControlLibrary Projeto. Certifique-se de usar a Projects guia na caixa Add Reference de diálogo em vez de referência montagem MarqueeControlLibrary diretamente.

Definir um controle personalizado e seus designer personalizado

O controle personalizado será derivar a partir da UserControl classe. Isso permite que o controle para conter outros controles, e ele fornece o controle uma grande quantidade de funcionalidade padrão.

O controle personalizado não terá um designer personalizado associado. Isso permite que você para criar uma experiência design exclusivo adequado especificamente para o controle personalizado.

Visual Studio 67

Você associar o controle ao seu designer, usando a DesignerAttribute classe. O designer personalizado porque você estiver desenvolvendo o comportamento Design-time inteiro do seu controle personalizado, será implementa a IRootDesigner interface.

Para definir um controle personalizado e seu designer personalizado 1. Abrir o MarqueeControl arquivo de origem no Code Editor. Na parte superior

do arquivo, importar os espaços para nome a seguir:

C# using System; using System.Collections; using System.ComponentModel; using

System.ComponentModel.Design; using System.Drawing; using System.Windows.Forms; using

System.Windows.Forms.Design;

2. Adicionar a declaração da MarqueeControl Classe. o DesignerAttribute Isto associa o controle personalizado com seu designer.

C# [Designer( typeof( MarqueeControlLibrary.Design.MarqueeControlRootDesigner ), typeof(

IRootDesigner ) )] public class MarqueeControl : UserControl {

3. Abrir o MarqueeControlRootDesigner arquivo de origem no Code Editor. Na parte superior do arquivo, importar os espaços para nome a seguir:


System.ComponentModel.Design; using System.Diagnostics; using System.Drawing.Design; using

System.Windows.Forms; using System.Windows.Forms.Design;

4. Coloque a definição para a MarqueeControlRootDesigner classe entre um espaço para nome chamado " MarqueeControlLibrary.Design ". Esta Declaração coloca o designer em um espaço para nome especial reservado para tipos relacionados design-.

Além disso, alterar da declaração do MarqueeControlRootDesigner para herdar da classe DocumentDesigner.

C# namespace MarqueeControlLibrary.Design {

[ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]

[ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]

[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Deman

d, Name = "FullTrust")] public class MarqueeControlRootDesigner : DocumentDesigner {

5. Definir o construtor para a MarqueeControlRootDesigner classe. Inserir uma WriteLine instrução no corpo construtor. Este será útil para fins de depuração.

C# public MarqueeControlRootDesigner() { Trace.WriteLine("MarqueeControlRootDesigner ctor"); }

Criando uma instância de seu controle personalizado

Para observar o comportamento em tempo de design personalizado do seu controle, você irá colocar uma instância do seu controle no formulário no MarqueeControlTest projeto.

Visual Studio 68

Para criar uma instância de seu controle personalizado 1. Adicionar um novo UserControl item para o MarqueeControlTest projeto.

Dar o novo arquivo de origem uma nome de base de " DemoMarqueeControl ".

2. Na parte superior do arquivo, importar espaço para nome MarqueeControlLibrary:

Visual Basic Imports MarqueeControlLibrary using MarqueeControlLibrary;

3. Alterar da declaração do DemoMarqueeControl para herdam a MarqueeControl classe.

Visual Basic Public Class DemoMarqueeControl Inherits MarqueeControl public class DemoMarqueeControl :

MarqueeControl

4. Criar o projeto.

5. Aberto Form1 no Windows Forms Designer.

6. Localizar na guia " Meus Controles de usuário " na e abri-lo. o Toolbox Arraste até o formulário. de um DemoMarqueeControl a Toolbox

7. Criar o projeto.

Configurando o Project para depuração de tempo de design

Quando você estiver desenvolvendo uma experiência Design-time personalizado, ele será necessário para depurar o controles e componentes. Não é uma maneira simples para instalar o seu projeto para permitir a depuração em tempo de criação. Para obter mais informações, consulte Walkthrough: depuração controles Forms do Windows personalizados em tempo de design.

Para configurar o projeto para design-time depuração 1. Clique com o botão direito do mouse o MarqueeControlLibrary projeto e

selecione Properties.

2. Na caixa de diálogo ' páginas Propriedades MarqueeControlLibrary ', selecione a Configuration Properties página.

3. Na seção Start Action, marque Start External Program. Não será depuração uma instância separada do Visual Studio, portanto clique a elipse. ( ) botão para procurar por Visual Studio IDE O nome do arquivo executável é devenv.exe, e se você instalado para o local padrão, seu caminho será " .NET\Common7\IDE\devenv.exe Visual Studio C:\Program Files\Microsoft. "

4. Clique OK para fechar a caixa de diálogo.

5. Clique com o botão direito do mouse o MarqueeControlLibrary projeto e selecione Definir como Projeto iniciar para ativar essa configuração de depuração " ".

Ponto de Verificação

Você está pronto para depurar o comportamento em tempo de criação do seu controle personalizado. Após você ter determinado se o ambiente de depuração está configurada corretamente, você testará a associação entre o controle personalizado e o designer personalizado.

Para testar o ambiente de depuração e a associação de designer

Visual Studio 69

1. Abrir o MarqueeControlRootDesigner arquivo de origem no e coloque um ponto de interrupção na instrução WriteLine. o Code Editor

2. Pressione F5 para iniciar a sessão de depuração. Observe que uma nova instância do Visual Studio é criado.

3. Na nova instância do Visual Studio, abra a solução " MarqueeControlTest ". A solução você pode localizar facilmente selecionando Recent Projects no File menu. O arquivo solução " MarqueeControlTest.sln " será listado como o arquivo mais recentemente usado.

4. Aberto no designer. o DemoMarqueeControl Observe que a instância de depuração do Visual Studio obtém foco e a execução pára em seu ponto de interrupção. Pressione F5 para continuar a sessão de depuração.

Neste ponto, tudo está no lugar para que você possa desenvolver e depurar o controle personalizado e seu designer personalizado associado. Se o restante dessa explicação passo a passo será concentrar nos detalhes da implementação recursos do controle e o criador.

Implementar O controle personalizado

O MarqueeControl com um pouco de personalização. é um UserControl Ela expõe dois métodos: Start, que inicia a animação Letreiro digital, e Stop, que interrompe a animação. Porque e StopMarquee métodos, respectivamente, em cada filho controlar que implementa IMarqueeWidget. contém controles filho que implementa a IMarqueeWidget interface, Start e Stop Enumerar cada controle filho e chamada ao MarqueeControlStartMarquee A aparência do e MarqueeText controles é dependente para o layout, então MarqueeControl substitui o OnLayout método e chama PerformLayout em controles filho desse tipo. o MarqueeBorder

Isso é a extensão das personalizações MarqueeControl. Os recursos de tempo de execução são implementadas pelo e MarqueeControlRootDesigner Classes. e MarqueeText controles, e os recursos em tempo de criação são implementadas pelo MarqueeBorder o MarqueeBorderDesigner

Para implementar o Controle Personalizado 1. Abrir o MarqueeControl arquivo de origem no Code Editor. Implementar e Stop

Métodos. o Start

C# public void Start() { // The MarqueeControl may contain any number of // controls that

implement IMarqueeWidget, so // find each IMarqueeWidget child and call its // StartMarquee

method. foreach( Control cntrl in this.Controls ) { if( cntrl is IMarqueeWidget ) { IMarqueeWidget

widget = cntrl as IMarqueeWidget; widget.StartMarquee(); } } } public void Stop() { // The

MarqueeControl may contain any number of // controls that implement IMarqueeWidget, so find

// each IMarqueeWidget child and call its StopMarquee // method. foreach( Control cntrl in

this.Controls ) { if( cntrl is IMarqueeWidget ) { IMarqueeWidget widget = cntrl as

IMarqueeWidget; widget.StopMarquee(); } } }

2. Substituir o OnLayout método.

C# protected override void OnLayout(LayoutEventArgs levent) { base.OnLayout (levent); // Repaint

all IMarqueeWidget children if the layout // has changed. foreach( Control cntrl in this.Controls ) {

if( cntrl is IMarqueeWidget ) { Control control = cntrl as Control; control.PerformLayout(); } } }

Visual Studio 70

Criando um controle filho para O controle personalizado

O MarqueeControl: o MarqueeBorder controle e o MarqueeText controle. hospedará dois tipos de controle filho

• MarqueeBorder esse controle pinta uma borda de " luz " ao redor suas bordas. O memória flash luzes em seqüência, para que eles apareçam para ser mover-se a borda. A velocidade na qual o memória flash luzes é controlada pela propriedade chamado UpdatePeriod. Várias outras propriedades personalizadas determinar outros aspectos da aparência do controle. Dois métodos, chamado StartMarquee e StopMarquee, controle quando a animação inicia e interrompe.

• MarqueeText esse controle pinta uma seqüência flashing. Como o MarqueeBorder controle, a velocidade na qual o texto pisca é controlada pela propriedade UpdatePeriod. O MarqueeText controle tem também e StopMarquee métodos em comum com o MarqueeBorder controle. o StartMarquee

Em tempo de criação, em qualquer combinação. permite esses tipos dois controle a ser adicionado à MarqueeControlRootDesigner uma MarqueeControl

Recursos comuns dos dois controles são factored em uma interface denominada IMarqueeWidget. Isso permite para descobrir os controles filho relacionados MARQUEE-e conceda a eles Tratamento especial. o MarqueeControl

Para implementar o recurso animação periódicos, você irá usar BackgroundWorker objetos de espaço para nome System.ComponentModel. Você pode usar Timer objetos, mas quando vários IMarqueeWidget objetos estão presentes, o segmento de UI único pode ser impossível acompanhar a animação.

Para criar um controle filho para o controle personalizado 1. Adicionar um novo item classe ao projeto MarqueeControlLibrary. Dar o

novo arquivo de origem uma nome de base de " IMarqueeWidget ".

2. Abrir o IMarqueeWidget arquivo de origem no e alterar a declaração de class para interface: o Code Editor

C# // This interface defines the contract for any class that is to // be used in constructing a

MarqueeControl. public interface IMarqueeWidget {

3. Adicione o seguinte código para a IMarqueeWidget interface para expor dois métodos e uma propriedade que manipulam a animação Letreiro digital:

C# // This interface defines the contract for any class that is to

// be used in constructing a MarqueeControl.

public interface IMarqueeWidget

{ // This method starts the animation. If the control can

// contain other classes that implement IMarqueeWidget as

// children, the control should call StartMarquee on all

// its IMarqueeWidget child controls.

void StartMarquee();

// This method stops the animation. If the control can

// contain other classes that implement IMarqueeWidget as

// children, the control should call StopMarquee on all

// its IMarqueeWidget child controls.

Visual Studio 71

void StopMarquee();

// This method specifies the refresh rate for the animation,

// in milliseconds.

int UpdatePeriod

{ get; set; } }

4. Adicionar um novo UserControl item para o MarqueeControlLibrary projeto. Dar o novo arquivo de origem uma nome de base de " MarqueeText ".

5. Arraste um BackgroundWorker componente de até seu MarqueeText controle. o Toolbox Esse componente permitirá que o MarqueeText controle para atualizar próprio assincronamente.

6. Na janela Propriedades, defina as BackgroundWorker propriedades para true e WorkerSupportsCancellation do componente WorkerReportsProgess. Essas configurações permitem que o BackgroundWorker Componente para aumentar o ProgressChanged evento periodicamente e para cancelar Atualizações assíncronas. Para obter mais informações, consulte Componente BackgroundWorker.

7. Abrir o MarqueeText arquivo de origem no Code Editor. Na parte superior do arquivo, importar os espaços para nome a seguir:

C# using System; using System.ComponentModel; using System.ComponentModel.Design; using

System.Diagnostics; using System.Drawing; using System.Threading; using

System.Windows.Forms; using System.Windows.Forms.Design;

8. Alterar da declaração do MarqueeText para herdar de Label e para implementar a IMarqueeWidget interface:

C# [ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]

public class MarqueeText : Label, IMarqueeWidget {

9. Declare as variáveis que correspondem às propriedades expostos, instância e inicializar-los no construtor. O isLit campo determina se o texto está para ser pintura com a cor determinado pela LightColor propriedade.

C# // When isLit is true, the text is painted in the light color; // When isLit is false, the text is painted

in the dark color. // This value changes whenever the BackgroundWorker component // raises the

ProgressChanged event. private bool isLit = true; // These fields back the public properties. private

int updatePeriodValue = 50; private Color lightColorValue; private Color darkColorValue; // These

brushes are used to paint the light and dark // colors of the text. private Brush lightBrush; private

Brush darkBrush; // This component updates the control asynchronously. private

BackgroundWorker backgroundWorker1; public MarqueeText() { // This call is required by the

Windows.Forms Form Designer. InitializeComponent(); // Initialize light and dark colors // to the

control's default values. this.lightColorValue = this.ForeColor; this.darkColorValue =

this.BackColor; this.lightBrush = new SolidBrush(this.lightColorValue); this.darkBrush = new

SolidBrush(this.darkColorValue); }

10. Implementa a IMarqueeWidget interface.

Visual Studio 72

O StartMarquee e StopMarquee chamar métodos do componente RunWorkerAsync e BackgroundWorkerCancelAsync métodos para iniciar e parar a animação.

O Category e Browsable atributos são aplicadas para a UpdatePeriod propriedade para ele apareça em uma seção personalizado da janela Propriedades chamada " digital ".

C# public virtual void StartMarquee() { // Start the updating thread and pass it the UpdatePeriod.

this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod); } public virtual void

StopMarquee() { // Stop the updating thread. this.backgroundWorker1.CancelAsync(); }

[Category("Marquee")] [Browsable(true)] public int UpdatePeriod { get { return

this.updatePeriodValue; } set { if (value > 0) { this.updatePeriodValue = value; } else { throw new

ArgumentOutOfRangeException("UpdatePeriod", "must be > 0"); } } }

11. Implementar a assessores Propriedade. Você irá expor duas propriedades aos clientes: LightColor e DarkColor. O Category e Browsable atributos são aplicados a essas propriedades, para as propriedades apareçam em uma seção personalizado da janela Propriedades chamada " digital ".

C# [Category("Marquee")] [Browsable(true)] public Color LightColor { get { return

this.lightColorValue; } set { // The LightColor property is only changed if the // client provides a

different value. Comparing values // from the ToArgb method is the recommended test for //

equality between Color structs. if (this.lightColorValue.ToArgb() != value.ToArgb()) {

this.lightColorValue = value; this.lightBrush = new SolidBrush(value); } } } [Category("Marquee")]

[Browsable(true)] public Color DarkColor { get { return this.darkColorValue; } set { // The

DarkColor property is only changed if the // client provides a different value. Comparing values //

from the ToArgb method is the recommended test for // equality between Color structs. if

(this.darkColorValue.ToArgb() != value.ToArgb()) { this.darkColorValue = value; this.darkBrush =

new SolidBrush(value); } } }

12. Implementar os manipuladores para o BackgroundWorker componente na DoWork e ProgressChanged eventos.

O DoWork manipulador de eventos sleeps para o número de milissegundos especificado pelo UpdatePeriod raises depois o ProgressChanged evento, até parar a animação ao chamar CancelAsync seu código.

O ProgressChanged manipulador de eventos alterna o texto entre seu estado para dar a aparência de flashing claras e escuras.

C# // This method is called in the worker thread's context, // so it must not make any calls into the

MarqueeText control. // Instead, it communicates to the control using the // ProgressChanged

event. // // The only work done in this event handler is // to sleep for the number of milliseconds

specified // by UpdatePeriod, then raise the ProgressChanged event. private void

backgroundWorker1_DoWork( object sender, System.ComponentModel.DoWorkEventArgs e) {

BackgroundWorker worker = sender as BackgroundWorker; // This event handler will run until

the client cancels // the background task by calling CancelAsync. while

(!worker.CancellationPending) { // The Argument property of the DoWorkEventArgs // object

holds the value of UpdatePeriod, which // was passed as the argument to the RunWorkerAsync //

Visual Studio 73

method. Thread.Sleep((int)e.Argument); // The DoWork eventhandler does not actually report //

progress; the ReportProgress event is used to // periodically alert the control to update its state.

worker.ReportProgress(0); } } // The ProgressChanged event is raised by the DoWork method. //

This event handler does work that is internal to the // control. In this case, the text is toggled

between its // light and dark state, and the control is told to // repaint itself. private void

backgroundWorker1_ProgressChanged(object sender,

System.ComponentModel.ProgressChangedEventArgs e) { this.isLit = !this.isLit; this.Refresh(); }

13. Substituir o OnPaint método para ativar a animação.

C# protected override void OnPaint(PaintEventArgs e) { // The text is painted in the light or dark

color, // depending on the current value of isLit. this.ForeColor = this.isLit ? this.lightColorValue :

this.darkColorValue; base.OnPaint(e); }

Criar o controle filho MarqueeBorder

O MarqueeBorder controle é um pouco mais sofisticado que o MarqueeText controle. Ele tem mais propriedades e a animação no método OnPaint está mais envolvido. Em princípio, ele é bastante semelhante ao controle MarqueeBorder.

Porque o MarqueeBorder controle pode ter controles filho, ele precisará estar ciente de Layout eventos.

Para criar o controle MarqueeBorder 1. Adicionar um novo UserControl item para o MarqueeControlLibrary

projeto. Dar o novo arquivo de origem uma nome de base de " MarqueeBorder ".

2. Arraste um BackgroundWorker componente de até seu MarqueeBorder controle. o Toolbox Esse componente permitirá que o MarqueeBorder controle para atualizar próprio assincronamente.

3. Na janela Propriedades, defina as BackgroundWorker propriedades para true e WorkerSupportsCancellation do componente WorkerReportsProgess. Essas configurações permitem que o BackgroundWorker Componente para aumentar o ProgressChanged evento periodicamente e para cancelar Atualizações assíncronas. Para obter mais informações, consulte Componente BackgroundWorker.

4. Abrir o MarqueeBorder arquivo de origem no Code Editor. Na parte superior do arquivo, importar os espaços para nome a seguir:

C# using System; using System.ComponentModel; using System.ComponentModel.Design; using

System.Diagnostics; using System.Drawing; using System.Drawing.Design; using

System.Threading; using System.Windows.Forms; using System.Windows.Forms.Design;

5. Alterar da declaração da MarqueeBorder Herdar do Panel e para implementar a IMarqueeWidget interface.

C# [Designer(typeof(MarqueeControlLibrary.Design.MarqueeBorderDesigner ))]

[ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]

public class MarqueeBorder : Panel, IMarqueeWidget {

http://msdnwiki.microsoft.com/pt-br/mtpswiki/system.windows.forms.panel(VS.80).aspx

Visual Studio 74

6. Declarar dois enumerações de gerenciamento de estado do MarqueeBorder controle: MarqueeSpinDirection, que determina a direção na qual as luzes " girar " ao redor da borda, e MarqueeLightShape, que determina a forma das luzes (quadrado ou circular). Coloque essas declarações antes declaração da MarqueeBorder classe.

C# // This defines the possible values for the MarqueeBorder // control's SpinDirection property.

public enum MarqueeSpinDirection { CW, CCW } // This defines the possible values for the

MarqueeBorder // control's LightShape property. public enum MarqueeLightShape { Square,

Circle }

7. Declare as variáveis que correspondem às propriedades expostos, instância e inicializar-los no construtor.

C# public static int MaxLightSize = 10; // These fields back the public properties. private int

updatePeriodValue = 50; private int lightSizeValue = 5; private int lightPeriodValue = 3; private

int lightSpacingValue = 1; private Color lightColorValue; private Color darkColorValue; private

MarqueeSpinDirection spinDirectionValue = MarqueeSpinDirection.CW; private

MarqueeLightShape lightShapeValue = MarqueeLightShape.Square; // These brushes are used to

paint the light and dark // colors of the marquee lights. private Brush lightBrush; private Brush

darkBrush; // This field tracks the progress of the "first" light as it // "travels" around the marquee

border. private int currentOffset = 0; // This component updates the control asynchronously.

private System.ComponentModel.BackgroundWorker backgroundWorker1; public

MarqueeBorder() { // This call is required by the Windows.Forms Form Designer.

InitializeComponent(); // Initialize light and dark colors // to the control's default values.

this.lightColorValue = this.ForeColor; this.darkColorValue = this.BackColor; this.lightBrush = new

SolidBrush(this.lightColorValue); this.darkBrush = new SolidBrush(this.darkColorValue); // The

MarqueeBorder control manages its own padding, // because it requires that any contained

controls do // not overlap any of the marquee lights. int pad = 2 * (this.lightSizeValue +

this.lightSpacingValue); this.Padding = new Padding(pad, pad, pad, pad);

SetStyle(ControlStyles.OptimizedDoubleBuffer, true); }

8. Implementa a IMarqueeWidget interface.

O StartMarquee e StopMarquee chamar métodos do componente RunWorkerAsync e BackgroundWorkerCancelAsync métodos para iniciar e parar a animação.

Como o MarqueeBorder controle pode conter controles filho, o StartMarquee método enumera todos os controles filho e chama StartMarquee naqueles que implementam IMarqueeWidget. O StopMarquee método tem uma implementação semelhante.

C# public virtual void StartMarquee() { // The MarqueeBorder control may contain any number of //

controls that implement IMarqueeWidget, so find // each IMarqueeWidget child and call its

StartMarquee // method. foreach (Control cntrl in this.Controls) { if (cntrl is IMarqueeWidget) {

IMarqueeWidget widget = cntrl as IMarqueeWidget; widget.StartMarquee(); } } // Start the

updating thread and pass it the UpdatePeriod.

this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod); } public virtual void

Visual Studio 75

StopMarquee() { // The MarqueeBorder control may contain any number of // controls that

implement IMarqueeWidget, so find // each IMarqueeWidget child and call its StopMarquee //

method. foreach (Control cntrl in this.Controls) { if (cntrl is IMarqueeWidget) { IMarqueeWidget

widget = cntrl as IMarqueeWidget; widget.StopMarquee(); } } // Stop the updating thread.

this.backgroundWorker1.CancelAsync(); } [Category("Marquee")] [Browsable(true)] public virtual

int UpdatePeriod { get { return this.updatePeriodValue; } set { if (value > 0) {

this.updatePeriodValue = value; } else { throw new

ArgumentOutOfRangeException("UpdatePeriod", "must be > 0"); } } }

Implementar a assessores Propriedade. O MarqueeBorder controle tem várias propriedades para controlar sua aparência.

C# [Category("Marquee")] [Browsable(true)] public int LightSize { get { return this.lightSizeValue; }

set { if (value > 0 && value <= MaxLightSize) { this.lightSizeValue = value; this.DockPadding.All =

2 * value; } else { throw new ArgumentOutOfRangeException("LightSize", "must be > 0 and <

MaxLightSize"); } } } [Category("Marquee")] [Browsable(true)] public int LightPeriod { get {

return this.lightPeriodValue; } set { if (value > 0) { this.lightPeriodValue = value; } else { throw

new ArgumentOutOfRangeException("LightPeriod", "must be > 0 "); } } } [Category("Marquee")]

[Browsable(true)] public Color LightColor { get { return this.lightColorValue; } set { // The

LightColor property is only changed if the // client provides a different value. Comparing values //

from the ToArgb method is the recommended test for // equality between Color structs. if

(this.lightColorValue.ToArgb() != value.ToArgb()) { this.lightColorValue = value; this.lightBrush =

new SolidBrush(value); } } } [Category("Marquee")] [Browsable(true)] public Color DarkColor {

get { return this.darkColorValue; } set { // The DarkColor property is only changed if the // client

provides a different value. Comparing values // from the ToArgb method is the recommended test

for // equality between Color structs. if (this.darkColorValue.ToArgb() != value.ToArgb()) {

this.darkColorValue = value; this.darkBrush = new SolidBrush(value); } } } [Category("Marquee")]

[Browsable(true)] public int LightSpacing { get { return this.lightSpacingValue; } set { if (value >=

0) { this.lightSpacingValue = value; } else { throw new

ArgumentOutOfRangeException("LightSpacing", "must be >= 0"); } } } [Category("Marquee")]

[Browsable(true)] [EditorAttribute(typeof(LightShapeEditor),

typeof(System.Drawing.Design.UITypeEditor))] public MarqueeLightShape LightShape { get {

return this.lightShapeValue; } set { this.lightShapeValue = value; } } [Category("Marquee")]

[Browsable(true)] public MarqueeSpinDirection SpinDirection { get { return

this.spinDirectionValue; } set { this.spinDirectionValue = value; } }

9. Implementar os manipuladores para o BackgroundWorker componente na DoWork e ProgressChanged eventos.

O DoWork manipulador de eventos sleeps para o número de milissegundos especificado pelo UpdatePeriod raises depois o ProgressChanged evento, até parar a animação ao chamar CancelAsync seu código.

O ProgressChanged manipulador de eventos aumenta a posição da luz " base ", do qual o estado luz / escuro de outros luzes é determinado, e chama o Refresh método para fazer com que o controle para redesenhar próprio.

C#

Visual Studio 76

// This method is called in the worker thread's context, // so it must not make any calls into the

MarqueeBorder // control. Instead, it communicates to the control using // the ProgressChanged

event. // // The only work done in this event handler is // to sleep for the number of milliseconds

specified // by UpdatePeriod, then raise the ProgressChanged event. private void

backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) {

BackgroundWorker worker = sender as BackgroundWorker; // This event handler will run until

the client cancels // the background task by calling CancelAsync. while

(!worker.CancellationPending) { // The Argument property of the DoWorkEventArgs // object

holds the value of UpdatePeriod, which // was passed as the argument to the RunWorkerAsync //

method. Thread.Sleep((int)e.Argument); // The DoWork eventhandler does not actually report //

progress; the ReportProgress event is used to // periodically alert the control to update its state.

worker.ReportProgress(0); } } // The ProgressChanged event is raised by the DoWork method. //

This event handler does work that is internal to the // control. In this case, the currentOffset is

incremented, // and the control is told to repaint itself. private void

backgroundWorker1_ProgressChanged( object sender,

System.ComponentModel.ProgressChangedEventArgs e) { this.currentOffset++; this.Refresh(); }

10. Implementar os métodos auxiliar, IsLit e DrawLight.

O IsLit método determina a cor de uma luz em uma posição determinado. Luzes que são " lit " são tiradas com a cor determinado por propriedade LightColor, e aqueles que são " escuro " são tiradas com a cor determinado pela DarkColor propriedade.

O DrawLight método desenha uma luz utilizando a cor apropriada, Forma, e posição.

C# // This method determines if the marquee light at lightIndex // should be lit. The currentOffset

field specifies where // the "first" light is located, and the "position" of the // light given by

lightIndex is computed relative to this // offset. If this position modulo lightPeriodValue is zero, //

the light is considered to be on, and it will be painted // with the control's lightBrush. protected

virtual bool IsLit(int lightIndex) { int directionFactor = (this.spinDirectionValue ==

MarqueeSpinDirection.CW ? -1 : 1); return ( (lightIndex + directionFactor * this.currentOffset) %

this.lightPeriodValue == 0 ); } protected virtual void DrawLight( Graphics g, Brush brush, int

xPos, int yPos) { switch (this.lightShapeValue) { case MarqueeLightShape.Square: {

g.FillRectangle(brush, xPos, yPos, this.lightSizeValue, this.lightSizeValue); break; } case

MarqueeLightShape.Circle: { g.FillEllipse(brush, xPos, yPos, this.lightSizeValue,

this.lightSizeValue); break; } default: { Trace.Assert(false, "Unknown value for light shape.");

break; } } }

11. Substituir e OnPaint Métodos. o OnLayout

O OnPaint método desenha as luzes ao longo das bordas do controle MarqueeBorder.

Como o OnPaint método dependerá da dimensões do controle MarqueeBorder, você precisa para chamar ele sempre que for alterado o layout. Para isso, substituir OnLayout e chame Refresh.

C#

Visual Studio 77

protected override void OnLayout(LayoutEventArgs levent) { base.OnLayout(levent); // Repaint

when the layout has changed. this.Refresh(); } // This method paints the lights around the border

of the // control. It paints the top row first, followed by the // right side, the bottom row, and the

left side. The color // of each light is determined by the IsLit method and // depends on the light's

position relative to the value // of currentOffset. protected override void OnPaint(PaintEventArgs

e) { Graphics g = e.Graphics; g.Clear(this.BackColor); base.OnPaint(e); // If the control is large

enough, draw some lights. if (this.Width > MaxLightSize && this.Height > MaxLightSize) { // The

position of the next light will be incremented // by this value, which is equal to the sum of the //

light size and the space between two lights. int increment = this.lightSizeValue +

this.lightSpacingValue; // Compute the number of lights to be drawn along the // horizontal edges

of the control. int horizontalLights = (this.Width - increment) / increment; // Compute the

number of lights to be drawn along the // vertical edges of the control. int verticalLights =

(this.Height - increment) / increment; // These local variables will be used to position and // paint

each light. int xPos = 0; int yPos = 0; int lightCounter = 0; Brush brush; // Draw the top row of

lights. for (int i = 0; i < horizontalLights; i++) { brush = IsLit(lightCounter) ? this.lightBrush :

this.darkBrush; DrawLight(g, brush, xPos, yPos); xPos += increment; lightCounter++; } // Draw

the lights flush with the right edge of the control. xPos = this.Width - this.lightSizeValue; // Draw

the right column of lights. for (int i = 0; i < verticalLights; i++) { brush = IsLit(lightCounter) ?

this.lightBrush : this.darkBrush; DrawLight(g, brush, xPos, yPos); yPos += increment;

lightCounter++; } // Draw the lights flush with the bottom edge of the control. yPos = this.Height -

this.lightSizeValue; // Draw the bottom row of lights. for (int i = 0; i < horizontalLights; i++) {

brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush; DrawLight(g, brush, xPos, yPos);

xPos -= increment; lightCounter++; } // Draw the lights flush with the left edge of the control.

xPos = 0; // Draw the left column of lights. for (int i = 0; i < verticalLights; i++) { brush =

IsLit(lightCounter) ? this.lightBrush : this.darkBrush; DrawLight(g, brush, xPos, yPos); yPos -=

increment; lightCounter++; } } }

Criando um designer personalizado para sombra e propriedades de filtro

A MarqueeControlRootDesigner classe fornece a implementação para o designer raiz. Além deste Designer, que opera em será necessário um designer personalizado que está associado ao controle MarqueeBorder especificamente. o MarqueeControl Este criador fornece personalizado comportamento que seja apropriado no contexto do designer raiz personalizado.

Especificamente, o MarqueeBorderDesigner será " sombra " e filtrar certas propriedades sobre o MarqueeBorder Controle, alterar sua interação com o ambiente de design.

Interceptando chamadas para um componente na propriedade acessador é conhecido como " Sombreamento. " Ele permite que um designer para controlar o valor definido pelo usuário e opcionalmente passar esse valor para o componente está sendo criado.

Para esse exemplo, que impede o usuário de fazer o MarqueeBorder controle invisível ou desativado durante o tempo de design. e Enabled será propriedades ser sombreado pela Visible o MarqueeBorderDesigner

Os designers também pode adicionar e remover propriedades. Para esse exemplo, a DockPadding propriedade será removido em tempo de criação, porque o MarqueeBorder controle programaticamente Define o enchimento com base no tamanho das luzes especificado pela propriedade LightSize.

Visual Studio 78

A classe base de MarqueeBorderDesigner é ComponentDesigner, que tem métodos que pode alterar os atributos, propriedades e eventos expostos por um controle em tempo de criação:

• PreFilterProperties

• PostFilterProperties

• PreFilterAttributes

• PostFilterAttributes

• PreFilterEvents

• PostFilterEvents

Ao alterar a interface pública de um componente usar esses métodos, você deve seguir estas regras:

• Adicionar ou remover itens no apenas os PreFilter métodos

• Modificar itens existentes em apenas os PostFilter métodos

• Sempre chamar o implementação básica primeiro nos PreFilter métodos

• Sempre chamar o implementação básica última nos PostFilter métodos

Adhering com essas regras garante que todos os designers no ambiente Design-time tenham uma exibição consistente de todos os componentes que está sendo criado.

A ComponentDesigner classe fornece um dicionário para gerenciar os valores das propriedades sombreado, que relieves você da necessidade para criar variáveis instância específica.

Para criar um designer personalizado às propriedades de sombra e filtro 1. Clique com o botão direito do mouse na Design pasta e adicionar uma nova

classe. Fornecer o arquivo de origem uma nome de base de " MarqueeBorderDesigner ".

2. Abrir o MarqueeBorderDesigner arquivo de origem no Code Editor. Na parte superior do arquivo, importar os espaços para nome a seguir:


System.ComponentModel.Design; using System.Diagnostics; using System.Windows.Forms; using

System.Windows.Forms.Design;

3. Alterar da declaração do MarqueeBorderDesigner para herdar de ParentControlDesigner, e delimite a definição para a MarqueeBorderDesigner classe com espaço para nome MarqueeControlLibrary.Design.

Como o MarqueeBorder controle pode conter controles filho, MarqueeBorderDesigner herdado ParentControlDesigner, qual interação alças o pai-filho.

C# namespace MarqueeControlLibrary.Design {

[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Deman

d, Name = "FullTrust")] public class MarqueeBorderDesigner : ParentControlDesigner {

4. Substituir o implementação básica de PreFilterProperties.

C#

Visual Studio 79

protected override void PreFilterProperties(IDictionary properties) {

base.PreFilterProperties(properties); if (properties.Contains("Padding")) {

properties.Remove("Padding"); } properties["Visible"] = TypeDescriptor.CreateProperty(

typeof(MarqueeBorderDesigner), (PropertyDescriptor)properties["Visible"], new Attribute[0]);

properties["Enabled"] = TypeDescriptor.CreateProperty( typeof(MarqueeBorderDesigner),

(PropertyDescriptor)properties["Enabled"], new Attribute[0]); }

5. Implementar e Visible Propriedades. o Enabled Essas implementações sombra propriedades do controle.

C# public bool Visible { get { return (bool)ShadowProperties["Visible"]; } set {

this.ShadowProperties["Visible"] = value; } } public bool Enabled { get { return

(bool)ShadowProperties["Enabled"]; } set { this.ShadowProperties["Enabled"] = value; } }

Tratamento alterações componente

A MarqueeControlRootDesigner classe fornece a experiência Design-time personalizadas para sua MarqueeControl instâncias. A maior parte da funcionalidade Design-time é herdada da classe DocumentDesigner; seu código será implementar dois personalizações específicas: tratamento alterações componente, e adicionar verbos Designer.

Como usuários criar suas MarqueeControl instâncias, o designer raiz acompanhará alterações e seus controles filho. o MarqueeControl O ambiente em tempo de design oferece um serviço conveniente, IComponentChangeService, para rastreamento altera para estado componente.

Você adquirir uma referência a esse serviço consultando o ambiente com o GetService método. Se a consulta for bem-sucedida, o designer pode anexar um manipulador para o ComponentChanged evento e executar quaisquer tarefas são necessários para manter um estado consistente em tempo de criação.

Você no caso da MarqueeControlRootDesigner classe, irá chamar o Refresh método em cada IMarqueeWidget objeto contido no MarqueeControl. Isso fará com que o IMarqueeWidget objeto para redesenhar próprio adequadamente quando propriedades como seu pai Size são alteradas.

Para lidar com alterações componente 1. Abrir o MarqueeControlRootDesigner arquivo de origem no e substituem o

Initialize Método. o Code Editor Chamar o implementação básica de Initialize e para consultar o IComponentChangeService.

C# base.Initialize(component); IComponentChangeService cs =

GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (cs != null) {

cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged); }

2. Implementar o OnComponentChanged manipulador de eventos. Testar tipo do componente de envio, e se ele for. chamar o Refresh método an IMarqueeWidget,

C# private void OnComponentChanged( object sender, ComponentChangedEventArgs e) { if

(e.Component is IMarqueeWidget) { this.Control.Refresh(); } }

Visual Studio 80

Adicionando verbos criador ao seu designer personalizado

Um verbo Designer é um comando de menu vinculado a um manipulador de eventos. Verbos Designer são adicionadas ao menu de atalho é um componente em tempo de criação. Para obter mais informações, consulte DesignerVerb.

Você adicionará dois verbos Designer a seu designers: Run Test e Stop Test. Esses verbos permitirá que você para exibir o comportamento em tempo de execução do em tempo de criação. o MarqueeControl Esses verbos será adicionado ao MarqueeControlRootDesigner.

O manipulador de eventos verbo quando Run Test é chamado, irá chamar o StartMarquee método no MarqueeControl. O manipulador de eventos verbo quando Stop Test é chamado, irá chamar o StopMarquee método no MarqueeControl. A implementação do e StopMarquee métodos chamar esses métodos em controles que implementam IMarqueeWidget, contidos para os controles contidos IMarqueeWidget também participará do teste. o StartMarquee

Para adicionar verbos designer ao seu designers personalizados 1. Na MarqueeControlRootDesigner Classe, adicione manipuladores de evento

chamado OnVerbRunTest e OnVerbStopTest.

C# private void OnVerbRunTest(object sender, EventArgs e) { MarqueeControl c = this.Control as

MarqueeControl; c.Start(); } private void OnVerbStopTest(object sender, EventArgs e) {

MarqueeControl c = this.Control as MarqueeControl; c.Stop(); }

2. Se conectar esses manipuladores de eventos a seus verbos Designer correspondente. Herda MarqueeControlRootDesigner da sua classe base. um DesignerVerbCollection Você irá criar dois objetos novos DesignerVerb e adicioná-los a essa coleção no método Initialize.

C# this.Verbs.Add( new DesignerVerb("Run Test", new EventHandler(OnVerbRunTest)) );

this.Verbs.Add( new DesignerVerb("Stop Test", new EventHandler(OnVerbStopTest)) );

Criando um UITypeEditor personalizada

Quando você criar uma experiência Design-time personalizados para usuários, geralmente é desejável para criar uma interação com a janela Propriedades Personalizadas. Você pode fazer isso criando um UITypeEditor. Para obter mais informações, consulte Como criar um editor tipo UI:.

O MarqueeBorder controle expõe várias propriedades na janela Propriedades. Duas dessas propriedades, MarqueeSpinDirection e MarqueeLightShape são representadas por enumerações. Para ilustrar o uso de um editor tipo UI, a MarqueeLightShape propriedade terá uma classe Associado UITypeEditor.

Para criar um tipo personalizado UI Editor 1. Abrir o MarqueeBorder arquivo de origem no Code Editor.

2. Na definição da classe MarqueeBorder, declare uma classe denominada LightShapeEditor que deriva de UITypeEditor.

C# // This class demonstrates the use of a custom UITypeEditor. // It allows the MarqueeBorder

control's LightShape property // to be changed at design time using a customized UI element //

Visual Studio 81

that is invoked by the Properties window. The UI is provided // by the LightShapeSelectionControl

class. internal class LightShapeEditor : UITypeEditor {

3. Declarar uma IWindowsFormsEditorService variável chamada editorService instância.

C# private IWindowsFormsEditorService editorService = null;

4. Substituir o GetEditStyle método. Essa implementação retorna DropDown, que informa o ambiente de design como serão exibidas a LightShapeEditor.

C# public override UITypeEditorEditStyle GetEditStyle(

System.ComponentModel.ITypeDescriptorContext context) { return

UITypeEditorEditStyle.DropDown; }

5. Substituir o EditValue método. Essa implementação consulta o ambiente de design para um IWindowsFormsEditorService objeto. Se tiver êxito, ele criará um LightShapeSelectionControl. O DropDownControl método é chamado para iniciar o LightShapeEditor. O valor de retorno desta chamada é retornado para o ambiente de design.

C# public override object EditValue( ITypeDescriptorContext context, IServiceProvider provider,

object value) { if (provider != null) { editorService = provider.GetService(

typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; } if (editorService !=

null) { LightShapeSelectionControl selectionControl = new LightShapeSelectionControl(

(MarqueeLightShape)value, editorService); editorService.DropDownControl(selectionControl);

value = selectionControl.LightShape; } return value; }

Criando um controle de exibição para seu UITypeEditor personalizada

1. A MarqueeLightShape propriedade oferece suporte dois tipos de formas luz: Square e Circle. Você criará um controle personalizado usado somente para o propósito de graficamente exibindo esses valores na janela Propriedades. Este controle personalizado será usado pelo para interagir com a janela Propriedades. seu UITypeEditor

Para criar um controle de exibição para seu UI personalizado Editor tipo 1. Adicionar um novo UserControl item para o MarqueeControlLibrary

projeto. Dar o novo arquivo de origem uma nome de base de " LightShapeSelectionControl ".

2. Arraste dois Panel controles da Toolbox. até a LightShapeSelectionControl Nome-los squarePanel e circlePanel. Organizá-los lado a lado. Definir a Size propriedade de ambos os Panel controles para (60, 60). Defina a Location propriedade do controle squarePanel para (8, 10). Defina a Location propriedade do controle circlePanel para (80, 10). Finalmente, defina a Size propriedade do (150, 80). para o LightShapeSelectionControl

3. Abrir o LightShapeSelectionControl arquivo de origem no Code Editor.

4. Implementar Click manipuladores de eventos para e circlePanel controles. o squarePanel Esses métodos chamar CloseDropDown para encerrar a sessão de edição personalizada UITypeEditor.

Visual Studio 82

C# private void squarePanel_Click(object sender, EventArgs e) { this.lightShapeValue =

MarqueeLightShape.Square; this.Invalidate( false ); this.editorService.CloseDropDown(); } private

void circlePanel_Click(object sender, EventArgs e) { this.lightShapeValue =

MarqueeLightShape.Circle; this.Invalidate( false ); this.editorService.CloseDropDown(); }

5. Declarar uma MarqueeLightShape variável chamada lightShapeValue instância.

C# private MarqueeLightShape lightShapeValue = MarqueeLightShape.Square;

6. No Construtor LightShapeSelectionControl, anexar os Click manipuladores de eventos para e circlePanel eventos controles ' Click. o squarePanel Além disso, atribuir o MarqueeLightShape Valor do ambiente de design para o lightShapeValue campo.

C# // This constructor takes a MarqueeLightShape value from the // design-time environment, which

will be used to display // the initial state. public LightShapeSelectionControl( MarqueeLightShape

lightShape, IWindowsFormsEditorService editorService ) { // This call is required by the designer.

InitializeComponent(); // Cache the light shape value provided by the // design-time environment.

this.lightShapeValue = lightShape; // Cache the reference to the editor service. this.editorService =

editorService; // Handle the Click event for the two panels. this.squarePanel.Click += new

EventHandler(squarePanel_Click); this.circlePanel.Click += new

EventHandler(circlePanel_Click); }

7. No método Dispose, desanexar os Click manipuladores de eventos.

C# protected override void Dispose( bool disposing ) { if( disposing ) { // Be sure to unhook event

handlers // to prevent "lapsed listener" leaks. this.squarePanel.Click -= new

EventHandler(squarePanel_Click); this.circlePanel.Click -= new

EventHandler(circlePanel_Click); if(components != null) { components.Dispose(); } }

base.Dispose( disposing ); }

8. Implementar a LightShape propriedade.

C# // LightShape is the property for which this control provides // a custom user interface in the

Properties window. public MarqueeLightShape LightShape { get { return this.lightShapeValue; }

set { if( this.lightShapeValue != value ) { this.lightShapeValue = value; } } }

9. Substituir o OnPaint método. Essa implementação será desenhar um quadrado sólido e círculo. Ele também realçará o valor selecionado desenhando uma borda ao redor de uma forma ou o outro.

C# protected override void OnPaint(PaintEventArgs e) { base.OnPaint (e); using( Graphics gSquare =

this.squarePanel.CreateGraphics(), gCircle = this.circlePanel.CreateGraphics() ) { // Draw a filled

square in the client area of // the squarePanel control. gSquare.FillRectangle( Brushes.Red, 0, 0,

this.squarePanel.Width, this.squarePanel.Height ); // If the Square option has been selected, draw

a // border inside the squarePanel. if( this.lightShapeValue == MarqueeLightShape.Square ) {

Visual Studio 83

gSquare.DrawRectangle( Pens.Black, 0, 0, this.squarePanel.Width-1, this.squarePanel.Height-1); }

// Draw a filled circle in the client area of // the circlePanel control. gCircle.Clear(

this.circlePanel.BackColor ); gCircle.FillEllipse( Brushes.Blue, 0, 0, this.circlePanel.Width,

this.circlePanel.Height ); // If the Circle option has been selected, draw a // border inside the

circlePanel. if( this.lightShapeValue == MarqueeLightShape.Circle ) { gCircle.DrawRectangle(

Pens.Black, 0, 0, this.circlePanel.Width-1, this.circlePanel.Height-1); } } }

Testando o controle personalizado no criador

Neste ponto, você pode criar o MarqueeControlLibrary projeto. Você pode criar um controle que herda da classe MarqueeControl e utilizá-la em um formulário.

Para criar uma implementação MarqueeControl personalizado 1. Aberto DemoMarqueeControl no modo de design. Isso irá criar uma instância do

tipo DemoMarqueeControl e exibi-lo em uma instância do tipo MarqueeControlRootDesigner.

2. Na Toolbox, abrir a MarqueeControlLibrary Components guia. Você verá e MarqueeText Controles disponíveis para seleção. o MarqueeBorder

3. Arraste uma instância do controle MarqueeBorder para a DemoMarqueeControl superfície de design. Ancorar esse MarqueeBorder controle para o controle pai.

4. Arraste uma instância do controle MarqueeText para a DemoMarqueeControl superfície de design.


6. Selecione e clique em seu glifo Marca Inteligente. o DemoMarqueeControl Selecione a Run Test opção para iniciar a animação. Clique Stop Test para parar a animação.

7. Aberto Form1 no modo estrutura.

8. Colocar dois Button controles no formulário. Nome-los startButton e stopButton. e alterar os Text valores de propriedade para " Iniciar " e " parar ", respectivamente

9. Implementar Click manipuladores de eventos para ambos os Button controles.

10. Na Toolbox, abrir a MarqueeControlTest Components guia. Você verá disponíveis para seleção. o DemoMarqueeControl

11. Arraste uma instância de DemoMarqueeControl até a Form1 superfície de design.

12. Nos Click manipuladores de eventos, chamar a Start. e Stop métodos na DemoMarqueeControl Visual Basic Private Sub startButton_Click(sender As Object, e As System.EventArgs)

Me.demoMarqueeControl1.Start() End Sub 'startButton_Click Private Sub

stopButton_Click(sender As Object, e As System.EventArgs) Me.demoMarqueeControl1.Stop()

End Sub 'stopButton_Click private void startButton_Click(object sender, System.EventArgs e) {

this.demoMarqueeControl1.Start(); } private void stopButton_Click(object sender,

System.EventArgs e) { this.demoMarqueeControl1.Stop(); }

13. Definir o MarqueeControlTest projeto como o projeto de inicialização e executá-lo. Você verá o formulário exibindo seu DemoMarqueeControl. Clique no

Visual Studio 84

botão Iniciar para iniciar a animação. Você verá o texto piscando e as luzes mover-se a borda.

Próximas etapas

O MarqueeControlLibrary demonstra uma implementação de controles personalizados e designers associado simples. Você pode fazer esse exemplo mais sofisticados de várias maneiras:

• Alterar os valores de propriedade no criador. o DemoMarqueeControl Adicionar mais MarqueBorder controles e ancorado-los em suas instâncias pai para criar um efeito aninhadas. Faça suas experiências com configurações diferentes para as UpdatePeriod propriedades relacionadas luz-e o.

• Criar suas próprias implementações de IMarqueeWidget. Por exemplo, você pode, criar " Um sinal néon flashing " ou um sinal animado com várias imagens.

• Personalizar a experiência Design-time. Você pode tentar sombreamento mais propriedades que Enabled e Visible. e você pode adicionar novas propriedades Adicionar novos verbos Designer para simplificar tarefas comuns como encaixe controles filho.

• A MarqueeControl Licença. Para obter mais informações, consulte Como: Licenciar componentes e controles.

• Controlar como os controles são serializados e como código for gerado para eles. Para obter mais informações, consulte Geração e compilação de código fonte dinâmico .

Um controle composto com Visual C# Walkthrough: criação Controles Composite fornecem um meio pelo qual personalizado interfaces gráfica podem ser criadas e reutilizado. Um controle composto é essencialmente um componente com uma representação visual. Como tal, ele pode consistir de um ou mais Windows Forms controles, componentes, ou blocos de código que pode estender funcionalidade, validar a entrada do usuário, modificar propriedades de vídeo, ou executar outras tarefas necessárias para o autor. Composição em controles podem ser colocados no Windows Forms em da mesma maneira que outros controles. Na primeira parte dessa explicação passo a passo, você criar um controle composto simples chamado ctlClock. Na segunda parte da explicação passo a passo, você estender a funcionalidade de ctlClock através de herança.

Observação


Criando o projeto

Quando você cria um novo projeto, você especificar seu nome para definir o raiz, nome conjunto, e nome do projeto, e garantir que o componente padrão será no espaço para nome correto.

Para criar a biblioteca controle ctlClockLib e o controle ctlClock 1. No menu File, aponte para New, e clique Project para abrir a New Project

caixa de diálogo.

Visual Studio 85

2. A partir da lista de Visual C# projetos, selecione o Windows Control Library modelo de projeto, digite ctlClockLib na caixa Name, e, em seguida clique em OK

O projeto nome, ctlClockLib, também é atribuída para a raiz por padrão. A raiz é usado para qualificar os nomes dos componentes no conjunto. Por exemplo, se dois conjuntos de módulos (assemblies) fornecer componentes nomeado ctlClock, você pode especificar seu ctlClock componente usando ctlClockLib.ctlClock.

3. No Solution Explorer, clique com o botão direito do mouse UserControl1.cs e clique em Rename.Alterar o nome do arquivo para ctlClock.cs. Clique no Yes botão quando lhe for perguntado se você desejar renomear todas as referências para o elemento de código " UserControl1 ".

Observação

Por padrão, um controle composto herda da classe UserControl fornecida pelo sistema. A UserControl classe fornece funcionalidade exigido pelo composto todos os controles, e implementa os métodos padrão e as propriedades.

4. No menu File, clique Save All para salvar o projeto.

Adicionando Windows controles e componentes para o controle composto

Uma interface visual é uma parte essencial de seu controle composto. Esta interface visual é implementado pela adição de um ou mais controles do Windows para a superfície de designer. Na demonstração a seguir, você irá incorporar Windows controles em seu controle composto e escrever código para implementar funcionalidade.

Para adicionar um rótulo e um timer a seu controle composto 1. No Solution Explorer, clique com o botão direito do mouse ctlClock.cs e

clique em View Designer.

2. Em expanda o Common Controls nó, e clique duas vezes Label. o Toolbox

Um Label controle denominado label1 é adicionado a seu controle na superfície de designer.

3. No designer, clique em label1. Na janela Propriedades, defina as propriedades a seguir.

Propriedade Alterar para

Name lblDisplay

Text (espaço em branco)

TextAlign MiddleCenter

Font.Size 14

4. Em expanda o Components nó, e clique duas vezes Timer. o Toolbox

Porque ele tem sem representação visual em tempo de execução. é um componente, um Timer Portanto, ele não é exibido com os controles na superfície Designer, mas sim em (uma bandeja na parte inferior da superfície designer). o Component Designer

5. Na ‘ Component Designer, clique timer1, e defina a Interval propriedade 1000 e a Enabled propriedade true.

Visual Studio 86

A Interval propriedade controla a freqüência com a qual o Timer Componente Ticks. Cada ticks tempo timer1, ele executa o código no evento timer1_Tick. O intervalo representa o número de milissegundos entre tiques.

6. Na Component Designer, clique duas vezes timer1 Para ir para o timer1_Tick evento para ctlClock.

7. Modificar o código para que ele parecido com o exemplo de código a seguir. Certifique-se de alterar o modificador de private acesso para protected.

[C#] protected void timer1_Tick(object sender, System.EventArgs e) { // Causes the label to display the

current time. lblDisplay.Text = DateTime.Now.ToLongTimeString(); }

Este código fará com que a hora atual a ser mostrado no lblDisplay. Porque o intervalo de timer1 estava definido para 1000, esse evento ocorrerá cada milissegundos de milhar, assim atualizando o horário atual a cada segundo.

8. Modificar o método para ser assessor pela palavra-chave virtual. Para obter mais informações, consulte a seção " Inheriting de um controle Usuário " abaixo. protected virtual void timer1_Tick(object sender, System.EventArgs e)


Adicionar propriedades ao controle composto

O controle relógio agora encapsula um Label controle e um Timer componente, cada um com seu próprio conjunto de propriedades herdadas. Enquanto a propriedades individuais desses controles não irá ser acessíveis aos usuários subseqüentes do seu controle, você pode criar e Expor propriedades personalizadas Escrevendo os blocos de código apropriada. No procedimento a seguir, você adicionará as propriedades para o controle que permitem ao usuário para alterar a cor do plano de fundo e texto.

Para adicionar uma propriedade para o controle composto 1. No Solution Explorer, clique com o botão direito do mouse ctlClock.cs e

clique em View Code.

O Code Editor para o controle abre.

2. Localize a public partial class ctlClock instrução. Sob o Brace abertura ({)., digite o seguinte código

[C#] private Color colFColor; private Color colBColor;

Essas instruções criar as variáveis particulares que você vai usar para armazenar os valores para as propriedades você está prestes a criar.

3. Digite o seguinte código abaixo as declarações de variável da etapa 2.

[C#] // Declares the name and type of the property. public Color ClockBackColor { // Retrieves the

value of the private variable colBColor. get { return colBColor; } // Stores the selected value in the

private variable colBColor, and // updates the background color of the label control lblDisplay. set

{ colBColor = value; lblDisplay.BackColor = colBColor; } } // Provides a similar set of instructions

for the foreground color. public Color ClockForeColor { get { return colFColor; } set { colFColor =

value; lblDisplay.ForeColor = colFColor; } }

Visual Studio 87

O código antecedente torna duas propriedades personalizadas, ClockForeColor e ClockBackColor, Usuários disponíveis para subseqüentes deste controle. O get e set fornecer instruções para armazenamento e recuperação de valor da propriedade,, bem como código para implementar funcionalidade apropriado para a propriedade.


Teste o controle

Controles são aplicativos não autônoma; eles deve ser hospedado em um contêiner. Testar comportamento em tempo de execução do seu controle e exercer suas propriedades com o UserControl Test Container. Para obter mais informações, consulte HOW TO: testar o comportamento de um UserControl Run-Time.

Para testar o controle 1. Pressione F5 para criar o projeto e executar o controle no UserControl Test

Container.

2. Na grade, o Contêiner de Teste na propriedade a ClockBackColor propriedade, localize e selecione a propriedade para exibir a paleta de cores.

3. Escolha uma cor para selecioná-lo.

A cor plano de fundo de seu controle alterada para a cor selecionada.

4. Use uma seqüência de eventos semelhante para verificar se a ClockForeColor propriedade está funcionando como esperado.

Nesta seção e as seções anteriores, você já viu como componentes e Windows controles podem ser combinados com código e embalagem para fornecer funcionalidade na forma de um controle de composição personalizado. Você aprendeu para expor as propriedades em seu controle composto, e como testar o controle depois que ele for concluída. Na próxima seção você aprenderá como construir um controle composto herdadas usando ctlClock como base.

Herdar a partir de um controle composto

Nas seções anteriores, você aprendeu como combinar Windows controles, componentes, e código em reutilizáveis controles composto. O controle composto agora pode ser usado como uma base no qual outros controles pode ser construído. O processo de derivar uma classe de uma classe base é chamado Herança. No nesta seção, você criará um controle denominado ctlAlarmClock composto. Será esse controle ser derivadas de seu controle pai, ctlClock. Você aprenderá a estender a funcionalidade de ctlClock, substituindo métodos pai e adicionando novos métodos e propriedades.

A primeira etapa para criar um controle herdado é para derivar-lo de seu pai. Esta ação cria um novo controle que possui todas as propriedades, métodos, e gráfica características do controle pai, mas também pode atuar como uma base para a adição de novo ou modificado funcionalidade.

Para criar o controle herdado 1. No Solution Explorer, clique com o botão direito do mouse ctlClockLib,

aponte para Add, e clique em User Control

A Add New Item caixa de diálogo é aberta.

2. Selecione o Inherited User Control modelo.

Visual Studio 88

3. Na caixa Name, digite ctlAlarmClock.cs, e clique em Add.

A Inheritance Picker caixa de diálogo será exibida.

4. Em Component Name, clique duas vezes ctlClock.

5. No Solution Explorer, pesquise os projetos atual.

Observação

Um arquivo chamado ctlAlarmClock.cs tiver sido adicionado ao projeto atual. Adicionando as propriedades alarme

Propriedades são adicionadas a um controle herdadas da mesma maneira adicionados a um controle composto. Você agora usará a sintaxe declaração da propriedade para adicionar duas propriedades ao seu controle: AlarmTime, que será armazenar o valor da data e hora o alarme é para ir desativado, e AlarmSet, que indicará se o alarme está definido..

Para adicionar propriedades a seu controle composto 1. No Solution Explorer, clique com o botão direito do mouse ctlAlarmClock e

clique em View Code.

2. Localize a public class instrução. Observe que o controle herdado ctlClockLib.ctlClock. Sob o Brace abertura digite o seguinte código. ({) instrução,

[C#] private DateTime dteAlarmTime; private bool blnAlarmSet; // These properties will be declared as

public to allow future // developers to access them. public DateTime AlarmTime { get { return

dteAlarmTime; } set { dteAlarmTime = value; } } public bool AlarmSet { get { return blnAlarmSet;

} set { blnAlarmSet = value; } }

Adicionando a interface gráfica do controle O controle herdado tem uma interface visual que é idêntica ao controle ela herda da. Ele possui os mesmos controles constituintes como seu controle pai, mas não as propriedades dos controles constituintes estará disponível a menos que eles foram especificamente expostos. Você pode adicionar para a interface gráfica de um controle composto herdadas da mesma maneira ao deseja incluir em qualquer controle composto. Para continuar adicionando ao alarme o relógio na interface visual, você adicionará um controle rótulo que será memória flash quando o alarme é sounding.

Para adicionar o controle rótulo 1. No Solution Explorer, clique com o botão direito do mouse ctlAlarmClock e

clique em View Designer.

O designer para ctlAlarmClock abre na janela principal.

2. Clique na parte de exibição do controle, e exibir a janela Propriedades.

Observação

Enquanto todas as propriedades são exibida, eles são esmaecidos. Isso indica que essas propriedades são nativo para lblDisplay e não pode ser modificado ou acessado na janela Propriedades. Por padrão, controles contido em um controle composto são private, e suas propriedades não estão acessíveis por qualquer meio.

Observação

Se você quiser que os subseqüentes usuários de seu controle composto para ter acesso a seus controles

Visual Studio 89

interno, declare-los como public ou protected.. ou protected Isso permitirá que você possa definir e modificar propriedades de controles contido em seu controle composto usando o código apropriado.

3. Adicionar um Label controle para o controle composto.

4. Usando o mouse, arraste o Label controle imediatamente abaixo da caixa Exibir. Na janela Propriedades, defina as propriedades a seguir.

Propriedade Configuração

Name lblAlarm

Text Alarme!

TextAlign MiddleCenter

Visible false Adicionar a funcionalidade alarme

Nos procedimentos anteriores, você adicionar propriedades e um controle que permitirá funcionalidade alarme no seu controle composto. Neste procedimento, você será adicione código para comparar a hora atual para a hora alarme e, se eles são os mesmos, para memória flash um alarme. Você, substituindo o timer1_Tick método do ctlClock e adicionando código adicional a ela, se estenderá a capacidade de ctlAlarmClock Mantendo todos os inerente a funcionalidade do ctlClock.

Para substituir o método timer1_Tick do ctlClock 1. Em Localizar a private bool blnAlarmSet; Instrução. o Code Editor

Imediatamente abaixo dele, adicione a instrução a seguir.

[C#] private bool blnColorTicker;

2. Em (}). localizar o chave de fechamento no final da classe o Code Editor Imediatamente antes do Brace, adicione o seguinte código.

[C#] protected override void timer1_Tick(object sender, System.EventArgs e) { // Calls the

Timer1_Tick method of ctlClock. base.timer1_Tick(sender, e); // Checks to see if the alarm is set.

if (AlarmSet == false) return; else // If the date, hour, and minute of the alarm time are the same

as // the current time, flash an alarm. { if (AlarmTime.Date == DateTime.Now.Date &&

AlarmTime.Hour == DateTime.Now.Hour && AlarmTime.Minute == DateTime.Now.Minute) { //

Sets lblAlarmVisible to true, and changes the background color based on // the value of

blnColorTicker. The background color of the label // will flash once per tick of the clock.

lblAlarm.Visible = true; if (blnColorTicker == false) { lblAlarm.BackColor = Color.Red;

blnColorTicker = true; } else { lblAlarm.BackColor = Color.Blue; blnColorTicker = false; } } else {

// Once the alarm has sounded for a minute, the label is made // invisible again. lblAlarm.Visible

= false; } } }

A adição deste código realiza diversas tarefas. A override instrução devolve o controle para usar esse método em vez do método que foi herdada do controle base. Quando esse método for chamado, ele chama o método substitui invocando a base.timer1_Tick instrução, garantindo que todos os a funcionalidade incorporada ao controle original é reproduzida neste controle. Em seguida, ele executa código adicional para incorporar a funcionalidade alarme. Um controle rótulo flashing será exibido quando o alarme ocorre.

Visual Studio 90

O controle relógio alarme está quase completo. A única coisa que permanece deve implementar uma maneira para desativá-lo. Para fazer isso, você adicionará código para o lblAlarm_Click método.

Para implementar o método shutoff 1. No Solution Explorer, clique com o botão direito do mouse ctlAlarmClock.cs

e clique em View Designer.

O designer abre.

2. Adicionar um botão para o controle. Defina as propriedades do botão da seguinte maneira.

Propriedade Value (Valor)

Name btnAlarmOff

Text Desativar alarme

3. No designer, clique duas vezes btnAlarmOff.

A Code Editor abre para a private void btnAlarmOff_Click linha.

4. Modificar esse método para que ele parecido com o código a seguir.

[C#] private void btnAlarmOff_Click(object sender, System.EventArgs e) { // Turns off the alarm.

AlarmSet = false; // Hides the flashing label. lblAlarm.Visible = false; }


Usar o controle Inherited em um formulário Você pode testar o controle herdadas da mesma maneira você testou o controle classe base, ctlClock:. Pressione F5 para criar o projeto e executar o controle no UserControl Test Container Para obter mais informações, consulte HOW TO: testar o comportamento de um UserControl Run-Time.

Para colocar o controle a ser usado, será necessário para hospedar-lo em um formulário. Como com um controle composto padrão, um controle composto herdadas não pode autônoma sozinho e deve ser hospedado em um formulário ou outros contêiner. Since ctlAlarmClock tem uma maior intensidade de funcionalidade, código adicional é necessário para testá-lo. Neste procedimento, você irá escrever um programa simples para testar a funcionalidade do ctlAlarmClock. Você irá gravar código para definir e exibir a AlarmTime propriedade de ctlAlarmClock, e será testar suas funções inerente.

Para criar e adicionar o controle a um formulário de teste 1. No Solution Explorer, clique com o botão direito do mouse ctlClockLib e

clique em Build.

2. Adicione um novo Windows Application projeto para a solução, e denomine-Test.

3. Clique com botão direito no Solution Explorer, mouse no References nó para o projeto de teste. Clique Add Reference para exibir a Add Reference caixa de diálogo. Clique na guia rotuladas Projects. O ctlClockLib projeto será listado em Project Name. Clique duas vezes o projeto para adicionar a referência para o projeto de teste.

Visual Studio 91

4. No Solution Explorer, clique com o botão direito do mouse Test e clique em Build.

5. Em expanda o ctlClockLib Components Nó. o Toolbox

6. Clique duas vezes ctlAlarmClock para adicionar uma cópia do ctlAlarmClock ao seu formulário.

7. Em Localizar e clique duas vezes DateTimePicker Para adicionar um DateTimePicker controle ao seu formulário, e adicione um Label controle clicando duas vezes Label. o Toolbox

8. Usar o mouse para posicionar os controles em um local conveniente no formulário.

9. Definir as propriedades desses controles da seguinte maneira.

Controle Propriedade Value (Valor)

label1 Text (espaço em branco)

Name lblTest

dateTimePicker1 Name dtpTest

Format Time

10. No designer, clique duas vezes dtpTest.

A Code Editor abre para private void dtpTest_ValueChanged.

11. Modificar o código para que ele parecido com o seguinte.

[C#] private void dtpTest_ValueChanged(object sender, System.EventArgs e) {

ctlAlarmClock1.AlarmTime = dtpTest.Value; ctlAlarmClock1.AlarmSet = true; lblTest.Text =

"Alarm Time is " + ctlAlarmClock1.AlarmTime.ToShortTimeString(); }

12. No Solution Explorer, clique com o botão direito do mouse Test e clique em Set as StartUp Project.

13. No menu Debug, clique em Start Debugging.

Inicia o programa de Teste. Observe que a hora atual é atualizado no controle ctlAlarmClock, e que o hora de início é mostrado no controle DateTimePicker

14. Clique o DateTimePicker onde os minutos da hora são exibidos.

15. Usando o teclado, definir um valor em minutos que seja maior que a hora atual mostrada por ctlAlarmClock um minuto.

O tempo para a Configuração de alarme é mostrado na lblTest. Esperar que o tempo exibido para atingir o tempo configuração alarme. Quando o tempo exibido atingir o tempo ao qual o alarme é definido, o lblAlarm será memória flash.

16. Desativar o alarme clicando btnAlarmOff. Agora você pode redefinir o alarme.

Essa explicação passo a passo tem abordadas um número de principais conceitos. Você aprendeu para criar um controle composto pela combinação controles e componentes em um contêiner controle composto. Você aprendeu para adicionar propriedades para o controle, e para escrever código para implementar funcionalidade personalizada. Na última seção, você aprendeu para estender a funcionalidade de um determinado controle composto a

Visual Studio 92

herança, e para alterar a funcionalidade de métodos host por substituir esses métodos.

Um componente Multithreaded Simple com Visual C# Walkthrough: criação

O BackgroundWorker Componente substitui e adiciona funcionalidade ao espaço para nome System.Threading; No entanto, espaço para nome System.Threading foi mantida para compatibilidade com versões anteriores e uso futuro, se você escolher. Para obter mais informações, consulte Component BackgroundWorker Overview.

Você pode escrever aplicativos que estão capaz de executar várias tarefas simultaneamente. Essa capacidade, chamado multithreading, ou Liberar segmentação é uma maneira eficiente de componentes de design que são muito processor-e exigem entrada do usuário. Um exemplo de um componente que pode alterar usar de multithreading. seria um componente que calcula informações de folha de pagamento O componente pôde processar dados inseridos em um banco de dados por um usuário em um segmento enquanto cálculos folha pagamento muito processor-foram executados em outro. Ao executar esses processos em segmentos separados, os usuários precisam aguardar o computador para concluir cálculos antes de inserir dados adicionais. Nessa explicação passo a passo, você criará um componente multissegmentado simples que executa vários cálculos complexos simultaneamente.

Criando o projeto

O aplicativo consiste em um único formulário e um componente. O usuário será entrada valores e sinal para o componente para iniciar cálculos. O formulário irá receber valores de seu componente e exibirá-los em controles de rótulo. O componente executará os cálculos muito processor-e sinalizar o formulário quando concluído. Você irá criar variáveis públicas no seu componente para armazenar valores recebidos da interface do usuário. Você também irá implementar métodos no seu componente para executar os cálculos com base nos valores dessas variáveis.

Observação

Embora geralmente seja uma função de um método preferível que calcule um valor, argumentos não podem ser passados entre segmentos, nem valores podem ser retornados. Existem muitas maneiras simples para fornecer valores para segmentos e para receber valores a partir deles. Nesta demonstração, você irá retornar valores para a interface de usuário, atualizando públicas variáveis, e eventos serão usados para notificar o programa principal quando um segmento de execução foi concluída. As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Para criar o formulário 1. Criar um novo Windows Application projeto.

2. Nome do aplicativo Calculations e renomeie Form1.cs como frmCalculations.cs. Quando Visual Studio solicita que você para renomear o Form1 elemento de código, clique em Yes.

Este formulário servirá como a interface do usuário principal para seu aplicativo.

Visual Studio 93

3. Adicionar cinco Label controles, quatro Button controles, e um TextBox controle a seu formulário.

4. Definir propriedades para esses controles da seguinte maneira:

Controle Name (Nome) Texto

label1 lblFactorial1 (vazio)

label2 lblFactorial2 (vazio)

label3 lblAddTwo (vazio)

label4 lblRunLoops (vazio)

label5 lblTotalCalculations (vazio)

button1 btnFactorial1 Fatorial

button2 btnFactorial2 Fatorial - 1

button3 btnAddTwo Adicionar dois

button4 btnRunLoops Executar um loop

textBox1 txtValue (vazio) Para criar o componente Calculadora

1. No menu Project, selecione Add Component.

2. Nome do componente Calculator.

Para adicionar variáveis públicas ao componente Calculadora 1. Do Code Editor aberto para Calculator.

2. Adicione instruções para criar variáveis públicas que será usado para passar valores frmCalculations para cada segmento.

A variável varTotalCalculations manterá uma execução total do número total de cálculos executada pelo componente, e as outras variáveis vai receber valores do formulário. public int varAddTwo; public int varFact1; public int varFact2; public int varLoopValue; public

double varTotalCalculations = 0;

Para adicionar métodos e eventos ao componente Calculadora 1. Declare Os delegados para os eventos que o componente será usado para

comunicar valores para o formulário.

Observação

Embora será você ser declarar quatro eventos, você só precisará criar três representantes porque dois eventos terá a mesma assinatura.

2. Imediatamente abaixo as declarações de variável inseridas na etapa anterior, a digite o seguinte código:

3. // This delegate will be invoked with two of your events. public delegate void

FactorialCompleteHandler(double Factorial, double TotalCalculations); public delegate void

AddTwoCompleteHandler(int Result, double TotalCalculations); public delegate void

LoopCompleteHandler(double TotalCalculations, int Counter);

Visual Studio 94

4. Declarar os eventos que o componente será usado para se comunicar com seu aplicativo. Fazer isso, adicionando o seguinte código imediatamente abaixo o código digitado na etapa anterior. public event FactorialCompleteHandler FactorialComplete; public event

FactorialCompleteHandler FactorialMinusOneComplete; public event AddTwoCompleteHandler

AddTwoComplete; public event LoopCompleteHandler LoopComplete;

5. Imediatamente abaixo o código que você digitou na etapa anterior, digite o seguinte código: // This method will calculate the value of a number minus 1 factorial // (varFact2-1!). public void

FactorialMinusOne() { double varTotalAsOfNow = 0; double varResult = 1; // Performs a factorial

calculation on varFact2 - 1. for (int varX = 1; varX <= varFact2 - 1; varX++) { varResult *= varX; //

Increments varTotalCalculations and keeps track of the current // total as of this instant.

varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations; } // Signals that the method

has completed, and communicates the // result and a value of total calculations performed up to

this // point. FactorialMinusOneComplete(varResult, varTotalAsOfNow); } // This method will

calculate the value of a number factorial. // (varFact1!) public void Factorial() { double varResult =

1; double varTotalAsOfNow = 0; for (int varX = 1; varX <= varFact1; varX++) { varResult *= varX;

varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations; }

FactorialComplete(varResult, varTotalAsOfNow); } // This method will add two to a number

(varAddTwo+2). public void AddTwo() { double varTotalAsOfNow = 0; int varResult = varAddTwo

+ 2; varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations;

AddTwoComplete(varResult, varTotalAsOfNow); } // This method will run a loop with a nested

loop varLoopValue times. public void RunALoop() { int varX; double varTotalAsOfNow = 0; for

(varX = 1; varX <= varLoopValue; varX++) { // This nested loop is added solely for the purpose of

slowing down // the program and creating a processor-intensive application. for (int varY = 1; varY

<= 500; varY++) { varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations; } }

LoopComplete(varTotalAsOfNow, varLoopValue); }

Transferindo Entrada de usuário para o componente

A próxima etapa é para adicionar código para frmCalculations para receber entrada do usuário e para transferir e receber valores de e para o Calculator Componente.

Para implementar front-end funcionalidade para frmCalculations 1. Aberto frmCalculations no Code Editor.

2. Localize a public partial class frmCalculations instrução. Imediatamente abaixo do { tipo: Calculator Calculator1;

3. Localize o construtor. Imediatamente antes adicione a seguinte linha: o }, // Creates a new instance of Calculator. Calculator1 = new Calculator();

4. No designer, clique cada botão para gerar o contorno de código para manipuladores de eventos de cada controle Click e adicione código para criar os manipuladores.

Se parecer Quando concluída, seu Click manipuladores de eventos devem com o seguinte:

Visual Studio 95

// Passes the value typed in the txtValue to Calculator.varFact1. private void

btnFactorial1_Click(object sender, System.EventArgs e) { Calculator1.varFact1 =

int.Parse(txtValue.Text); // Disables the btnFactorial1 until this calculation is complete.

btnFactorial1.Enabled = false; Calculator1.Factorial(); } private void btnFactorial2_Click(object

sender, System.EventArgs e) { Calculator1.varFact2 = int.Parse(txtValue.Text);

btnFactorial2.Enabled = false; Calculator1.FactorialMinusOne(); } private void

btnAddTwo_Click(object sender, System.EventArgs e) { Calculator1.varAddTwo =

int.Parse(txtValue.Text); btnAddTwo.Enabled = false; Calculator1.AddTwo(); } private void

btnRunLoops_Click(object sender, System.EventArgs e) { Calculator1.varLoopValue =

int.Parse(txtValue.Text); btnRunLoops.Enabled = false; // Lets the user know that a loop is

running lblRunLoops.Text = "Looping"; Calculator1.RunALoop(); }

5. Após o código adicionado na etapa anterior, digite o seguinte para manipular os eventos receberá do Calculator1 seu formulário: private void FactorialHandler(double Value, double Calculations) // Displays the returned value in

the appropriate label. { lblFactorial1.Text = Value.ToString(); // Re-enables the button so it can be

used again. btnFactorial1.Enabled = true; // Updates the label that displays the total calculations

performed lblTotalCalculations.Text = "TotalCalculations are " + Calculations.ToString(); } private

void FactorialMinusHandler(double Value, double Calculations) { lblFactorial2.Text =

Value.ToString(); btnFactorial2.Enabled = true; lblTotalCalculations.Text = "TotalCalculations are

" + Calculations.ToString(); } private void AddTwoHandler(int Value, double Calculations) {

lblAddTwo.Text = Value.ToString(); btnAddTwo.Enabled = true; lblTotalCalculations.Text =

"TotalCalculations are " + Calculations.ToString(); } private void LoopDoneHandler(double

Calculations, int Count) { btnRunLoops.Enabled = true; lblRunLoops.Text = Count.ToString();

lblTotalCalculations.Text = "TotalCalculations are " + Calculations.ToString(); }

6. Do } no construtor de frmCalculations, adicione o seguinte código imediatamente antes para manipular os eventos personalizados seu formulário receberá do Calculator1. Calculator1.FactorialComplete += new

Calculator.FactorialCompleteHandler(this.FactorialHandler);

Calculator1.FactorialMinusOneComplete += new

Calculator.FactorialCompleteHandler(this.FactorialMinusHandler); Calculator1.AddTwoComplete

+= new Calculator.AddTwoCompleteHandler(this.AddTwoHandler); Calculator1.LoopComplete

+= new Calculator.LoopCompleteHandler(this.LoopDoneHandler);

Teste seus aplicativos

Agora você tenha criado um projeto que incorpora um formulário e um componente capaz de realizar vários cálculos complexos. Embora você não tiver implementado capacidade multithreading ainda, você testará o projeto para verificar sua funcionalidade antes de prosseguir.

Para testar seu projeto 1. Partir do Debug menu, escolha Start Debugging.

O aplicativo começa e frmCalculations aparece.

2. Na caixa de texto, tipo 4, clique no botão rotulado Add Two.

O número " 6 " deve ser exibido no rótulo abaixo dele, e devem ser exibidos em lblTotalCalculations " cálculos total são 1 ".

Visual Studio 96

3. Agora clique no botão rotulado Factorial - 1.

O número " 6 " deve ser exibido sob o botão, e lblTotalCalculations agora leituras " cálculos total são 4. "

4. Em alterar o valor na caixa de texto para 20, seguida, clique no botão rotulado Factorial.

O número " 2.43290200817664E + 18 " é exibido abaixo dele, e lblTotalCalculations agora lê " cálculos total são 24. "

5. Altere o valor na caixa de texto para 50000, e, em seguida clique o botão rotulado Run A Loop.

Observe que há um intervalo pequeno mas notável antes este botão seja reativada. O rótulo sob este botão deve ler " 50000 " e os cálculos total exibidos são " 25000024 ".

6. Alterar o valor na caixa de texto para 5000000 e clique no botão rotulado Run A Loop, e clique imediatamente no botão rotulado Add Two. Clique nela novamente.

O botão não responder, nem qualquer controle no formulário irá responder até que os loops tenha sido concluídos.

Se seu programa é executado somente um único segmento de execução, cálculos muito processor-como o exemplo acima terá a tendência unir o programa Backup até que os cálculos tenha sido concluídos. Na próxima seção, você adicionará capacidade multithreading ao seu aplicativo para que vários segmentos podem ser executados uma vez.

Adicionando recurso Multithreading

O exemplo anterior demonstrado as limitações de aplicativos executados somente um único segmento de execução. Na próxima seção você usará a Thread classe para adicionar vários segmentos de execução ao seu componente.

Para adicionar a subrotina segmentos 1. Aberto Calculator.cs no Code Editor.

2. Na parte superior do código, localize a declaração de classe, e imediatamente abaixo, o { tipo o seguinte: // Declares the variables you will use to hold your thread objects. public System.Threading.Thread

FactorialThread; public System.Threading.Thread FactorialMinusOneThread; public

System.Threading.Thread AddTwoThread; public System.Threading.Thread LoopThread;

3. Imediatamente antes do fim da declaração de classe na parte inferior do código, adicione o método a seguir: public void ChooseThreads(int threadNumber) { // Determines which thread to start based on the

value it receives. switch(threadNumber) { case 1: // Sets the thread using the AddressOf the

subroutine where // the thread will start. FactorialThread = new System.Threading.Thread(new

System.Threading.ThreadStart(this.Factorial)); // Starts the thread. FactorialThread.Start();

break; case 2: FactorialMinusOneThread = new System.Threading.Thread(new

System.Threading.ThreadStart(this.FactorialMinusOne)); FactorialMinusOneThread.Start();

break; case 3: AddTwoThread = new System.Threading.Thread(new

System.Threading.ThreadStart(this.AddTwo)); AddTwoThread.Start(); break; case 4: LoopThread

= new System.Threading.Thread(new System.Threading.ThreadStart(this.RunALoop));

LoopThread.Start(); break; } }

Visual Studio 97

Quando instanciado, ele requer um argumento na forma de. é um Thread um ThreadStart O ThreadStart é um representante que aponta para o endereço do método onde o segmento é para começar. A ThreadStart não pode receber parâmetros ou valores secreta, e portanto somente pode indicar um void método. O ChooseThreads método você apenas implementado receber um valor a partir do programa chamá lo e usa esse valor para determinar o segmento apropriado para iniciar.

Para adicionar o código apropriado a frmCalculations 1. Abre o frmCalculations.cs arquivo no localize private void btnFactorial1_Click. o

Code Editor,

1. Comentário fora da linha que chama o Calculator1.Factorial1 método diretamente como mostrado: // Calculator1.Factorial()

2. Adicione a seguinte linha para chamar o Calculator1.ChooseThreads método: // Passes the value 1 to Calculator1, thus directing it to start the // correct thread.

Calculator1.ChooseThreads(1);

2. Fazer modificações semelhantes para os outros button_click métodos.

Observação

Certifique-se incluir o valor apropriado para o Threads argumento.

3. Quando você tiver terminado, seu código deverá ter semelhante à seguinte: private void btnFactorial1_Click(object sender, System.EventArgs e) // Passes the value typed in the

txtValue to Calculator.varFact1 { Calculator1.varFact1 = int.Parse(txtValue.Text); // Disables the

btnFactorial1 until this calculation is complete btnFactorial1.Enabled = false; //

Calculator1.Factorial(); Calculator1.ChooseThreads(1); } private void btnFactorial2_Click(object

sender, System.EventArgs e) { Calculator1.varFact2 = int.Parse(txtValue.Text); btnFactorial2.Enabled

= false; // Calculator1.FactorialMinusOne(); Calculator1.ChooseThreads(2); } private void

btnAddTwo_Click(object sender, System.EventArgs e) { Calculator1.varAddTwo =

int.Parse(txtValue.Text); btnAddTwo.Enabled = false; // Calculator1.AddTwo();

Calculator1.ChooseThreads(3); } private void btnRunLoops_Click(object sender, System.EventArgs e)

{ Calculator1.varLoopValue = int.Parse(txtValue.Text); btnRunLoops.Enabled = false; // Lets the user

know that a loop is running lblRunLoops.Text = "Looping"; // Calculator1.RunALoop();

Calculator1.ChooseThreads(4); }

Empacotamento chamadas para controles

Agora você irá facilitam atualizando a exibição no formulário. Como controles são sempre pertence ao segmento principal de execução, qualquer chamada para um controle de um segmento subordinada requer uma empacotamento chamada. Empacotamento é o ato de mover uma chamada entre limites do segmento, e é muito dispendioso em termos de recursos. Para minimizar a quantidade de empacotamento que precisa a ocorrer, e certifique-se que as chamadas serão tratadas de forma isenta de segmentos, você usará o System.Windows.Forms.Control.BeginInvoke(System.Delegate) método para chamar métodos no segmento principal de execução, a quantidade de entre segmentos Boundary-empacotamento que deve ocorrer assim Minimizing. Esse tipo

Visual Studio 98

de chamada é necessário ao chamar métodos que manipulam controles. Para obter detalhes, consulte HOW TO: Manipulate controles de segmentos.

Para criar os procedimentos invoking controle- 1. Abrir o Editor de frmCalculations código. Na seção Declarações, adicione o

seguinte código: public delegate void FHandler(double Value, double Calculations); public delegate void

A2Handler(int Value, double Calculations); public delegate void LDHandler(double Calculations,

int Count);

e InvokeBeginInvoke exigem um representante para o método apropriado como um argumento. Essas linhas declarar o representante assinaturas que serão usadas por BeginInvoke para chamar os métodos apropriados.

2. Adicionar os seguintes métodos vazios a seu código. public void FactHandler(double Value, double Calculations) { } public void Fact1Handler(double

Value, double Calculations) { } public void Add2Handler(int Value, double Calculations) { } public

void LDoneHandler(double Calculations, int Count) { }

3. No menu Edit, uso Cut e Paste Para Recortar todo o código do método FactorialHandler e colá-lo em FactHandler.

4. Repita a etapa anterior para FactorialMinusHandler e Fact1Handler, AddTwoHandler. e Add2Handler, e LoopDoneHandler e LDoneHandler

Quando terminar, não deve haver nenhum código restantes em FactorialHandler, Factorial1Handler, AddTwoHandler, e LoopDoneHandler. e todo o código usado para conter esses devem ter sido movidos para novos métodos apropriados

5. Chame o BeginInvoke método para chamar os métodos de forma assíncrona. Você pode chamar BeginInvoke de seu formulário (this.) ou qualquer um dos controles no formulário

Quando concluída, seu código deverá ter semelhante à seguinte: protected void FactorialHandler(double Value, double Calculations) { // BeginInvoke causes

asynchronous execution to begin at the address // specified by the delegate. Simply put, it

transfers execution of // this method back to the main thread. Any parameters required by // the

method contained at the delegate are wrapped in an object and // passed. this.BeginInvoke(new

FHandler(FactHandler), new Object[] {Value, Calculations}); } protected void

FactorialMinusHandler(double Value, double Calculations) { this.BeginInvoke(new

FHandler(Fact1Handler), new Object [] {Value, Calculations}); } protected void

AddTwoHandler(int Value, double Calculations) { this.BeginInvoke(new

A2Handler(Add2Handler), new Object[] {Value, Calculations}); } protected void

LoopDoneHandler(double Calculations, int Count) { this.BeginInvoke(new

LDHandler(LDoneHandler), new Object[] {Calculations, Count}); }

Pode parecer que o manipulador de eventos simplesmente está fazendo uma chamada para o método próxima. O manipulador de eventos realmente está causando um método para ser chamado no segmento principal da operação. Essa abordagem salva em chamadas entre limites do segmento e permite que o aplicativos multisegmentados para executar com eficiência e sem medo de causar lockup. Para obter detalhes sobre como trabalhar com controles em

Visual Studio 99

um ambiente com vários segmentos, consulte HOW TO: Manipulate controles de segmentos.

6. Salve seu trabalho.

7. Teste sua solução, escolhendo Start Debugging no menu Debug.

1. Digite 10000000 na caixa de texto e clique em Run A Loop.

" loop " é exibido no rótulo abaixo neste botão. Esse loop deve tomar uma quantidade significativa de tempo para executar. Se conclui muito cedo, ajustar o tamanho do número de acordo.

2. Na sucessão rápida, clique em Todos os três botões que ainda estão ativados. Você encontrará que todos os botões responder a uma entrada. O rótulo abaixo Add Two deve ser o primeiro para exibir um resultado. Resultados posteriormente serão exibidos nos rótulos abaixo os botões factorial. Esses resultados avaliada como infinito, como o número retornado por uma FATORIAL 10,000,000 é muito grande para uma variável de precisão dupla para conter. Finalmente, após um atraso adicional, resultados são retornados no Run A Loop botão abaixo.

Como você apenas observado, quatro conjuntos separados de cálculos foram executados simultaneamente em quatro segmentos separados. A interface do usuário permaneceu responde às solicitações, e eles foram retornados após cada segmento concluído.

Coordenar seus segmentos

Um usuário experiente de aplicativos multisegmentados pode Perceive uma falha sutis com o código como digitado. Recuperar as linhas de código de cada método desempenho cálculo-em Calculator: varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations;

Estas duas linhas de código incrementar a variável varTotalCalculations Pública e defina a variável varTotalAsOfNow local com esse valor. Esse valor é retornado ao frmCalculations e exibido em um controle rótulo. Mas é o valor correto sendo retornado? Se apenas um único segmento de execução estiver sendo executado, a resposta é claramente Sim. Mas se vários segmentos em execução, a resposta será mais certeza. Cada segmento tem a capacidade para incrementar a variável varTotalCalculations. É possível que após um segmento incrementa essa variável, mas antes ele copia o valor a varTotalAsOfNow, outro segmento pode alterar o valor desta variável por incrementando-. Isso leva à possibilidade que cada segmento na verdade, está, relatando resultados imprecisos. do Declaração lock (Referência do C#) fornece Visual C# para permitir sincronização de segmentos para garantir que cada segmento sempre retorna um resultado preciso. A sintaxe para lock é a seguinte: lock(AnObject) { // Insert code that affects the object. // Insert more code that affects the object. // Insert

more code that affects the object. // Release the lock. }

Quando o lock Bloco for digitado, execução na expressão especificada será bloqueada até que o segmento especificado tem um bloqueio exclusivo no objeto em questão. No exemplo mostrado acima, a execução está bloqueada no AnObject. Deve lock ser usado com um objeto que retorna uma referência em vez de um valor. A execução pode prossiga como um bloco sem interferência de outros segmentos. Um conjunto de instruções que execute como uma unidade são disse para ser atômicas. Quando encontrado, a expressão é liberada e os segmentos são permitidos para continuar normalmente. é o }

Visual Studio 100

Para adicionar a instrução de bloqueio ao seu aplicativo 1. Aberto Calculator.cs no Code Editor.

2. Localizar cada ocorrência do código a seguir: varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations;

Deve haver quatro instâncias desse código, um em cada método de cálculo.

3. Modifique este código para que ele lê da seguinte maneira: lock(this) { varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations; }

4. Salve seu trabalho e testá-lo como no exemplo anterior.

Você pode perceber um pequeno impacto no desempenho do seu programa. Isso ocorre porque a execução de segmentos pára quando um bloqueio exclusivo é obtido no seu componente. Embora ele garante a precisão, essa abordagem impedes alguns dos benefícios de desempenho de vários segmentos. Você deve cuidadosamente considerar a necessidade de segmentos, bloqueio e implementá-las somente quando absolutamente necessário.

Walkthrough: Inheriting a partir de um controle do Windows Forms com Visual C#

Com Visual C# 2005, você pode criar poderosos controles personalizados através Herança. A herança é capaz de criar controles que mantenham toda da funcionalidade inerente do Windows Forms controles padrão mas também incorporar funcionalidade personalizada. Nessa explicação passo a passo, você criará um controle herdado simples chamado ValueButton. Esse botão herdarão funcionalidade do controle Windows Forms Button padrão, e será expor uma propriedade personalizada chamada ButtonValue.

Observação


Criando o projeto

Quando você cria um novo projeto, você especificar seu nome, para definir o raiz, nome conjunto, e nome do projeto, e para garantir que o componente padrão será no espaço para nome correto.

Para criar a biblioteca controle ValueButtonLib e o controle ValueButton 1. No menu File, aponte para New e clique Project para abrir a New Project

caixa de diálogo.

2. Selecione o Windows Control Library modelo de projeto a partir da lista de Visual C# projetos e tipo ValueButtonLib na caixa Name.

O projeto nome, ValueButtonLib, também é atribuída para a raiz por padrão. A raiz é usado para qualificar os nomes dos componentes no conjunto. Por exemplo, se dois conjuntos de módulos (assemblies) fornecer componentes nomeado ValueButton, você pode especificar seu ValueButton componente usando

Visual Studio 101

ValueButtonLib.ValueButton Para obter mais informações, consulte Namespaces (Guia de programação C#).

3. Em Solution Explorer, clique com o botão direito do mouse UserControl1.cs e depois escolha Rename No menu de atalho. Alterar o nome do arquivo para ValueButton.cs. Clique no Yes botão quando lhe for perguntado se você deseja renomear todas as referências para o elemento de código ' UserControl1 '.

4. No Solution Explorer, clique com o botão direito do mouse ValueButton.cs e selecione View Code.

5. Localize a class linha public partial class ValueButton Instrução,. e alterar o tipo do qual esse controle herdado UserControl para Button Isso permite que o controle herdadas para herdar todas as funções do controle Button.

6. No Solution Explorer, abra o ValueButton.cs nó para exibir o arquivo código gerado pelo designer-, ValueButton.Designer.cs. Abrir este arquivo no Code Editor.

7. Localize o InitializeComponent método e remover a linha que atribui a AutoScaleMode propriedade. Essa propriedade não existe no controle Button.


Observação

Um criador visual está não mais disponível. Porque o Button controle faz sua própria pintura, você não consegue para modificar sua aparência no designer. Sua representação visual será ser exatamente a mesma que a classe ela herda da) (ou seja, Button a menos que modificado no código de. Ainda assim você pode adicionar componentes, que têm nenhum elemento UI, para a superfície de design.

Adicionar uma propriedade ao seu controle Inherited

Um uso possíveis de herdadas controles Windows Forms é a criação de controles que são idênticos no aspecto e estilo de padrão controles Windows Forms, mas expõe propriedades personalizadas. No nesta seção, você adicionará uma propriedade chamada ButtonValue para o controle.

Para adicionar a propriedade Value 1. Na Solution Explorer, clique com o botão direito do mouse

ValueButton.cs e, em seguida clique na View Code partir do menu de atalho.

2. Localize a class instrução. Imediatamente após o { tipo o código a seguir:

[C#] // Creates the private variable that will store the value of your // property. private int varValue; //

Declares the property. public int ButtonValue { // Sets the method for retrieving the value of your

property. get { return varValue; } // Sets the method for setting the value of your property. set {

varValue = value; } }

Este código define os métodos pelo qual a ButtonValue propriedade está armazenados e recuperados. A get instrução define o valor retornado para o valor que é armazenado na variável varValue particular, e a set instrução define o valor da variável particular pelo uso da palavra-chave value.


Teste O controle

Visual Studio 102

Controles são projetos não autônoma; eles deve ser hospedado em um contêiner. A fim de testar o controle, você deve fornecer um projeto de teste para que ele seja executado. Você também deve tornar o controle acessíveis para o projeto teste criando (compilação)-lo. No nesta seção, será criar o controle e testá-lo em um formulário do Windows.

Para criar o controle • No menu Build, clique em Build Solution.

A compilação deve ser bem-sucedida sem nenhum erros do compilador ou avisos.

Para criar um projeto de teste 1. No menu File, aponte para Add e clique New Project para abrir a Add New

Project caixa de diálogo.

2. Selecione o Windows nó, sob o Visual C# nó, e clique em Windows Application.

3. Na caixa Name, digite Test.

4. No Solution Explorer, clique com o botão direito do mouse no References nó do seu projeto de teste, em seguida, selecione Add Reference a partir do menu de atalho para exibir a Add Reference caixa de diálogo.

5. Clique na guia rotuladas Projects. O ValueButtonLib projeto será listado em Project Name. Clique duas vezes o projeto para adicionar a referência para o projeto de teste.

6. Clique com botão direito no Solution Explorer, mouse Test e selecione Build.

Para adicionar o controle ao formulário 1. No Solution Explorer, clique com o botão direito do mouse Form1.cs e

escolha View Designer a partir do menu de atalho.

2. Na ‘ Toolbox, clique ValueButtonLib Components. Clique duas vezes ValueButton.

A ValueButton aparece no formulário.

3. Clique com o botão direito do mouse e selecione Properties a partir do menu de atalho. o ValueButton

4. Na janela Properties, examine as propriedades deste controle. Observe que eles são idêntico às propriedades expostos por um botão padrão, exceto que não há uma propriedade adicionais, ButtonValue.

5. Defina a ButtonValue propriedade como 5.

6. Na guia All Windows Forms da Toolbox, clique duas vezes Label Para adicionar um Label controle ao seu formulário.

7. Realoque o rótulo para o centralizar do formulário.

8. Clique duas vezes valueButton1.

A Code Editor abre para o valueButton1_Click evento.

9. Inserir a linha de código a seguir.

[C#] label1.Text = valueButton1.ButtonValue.ToString();

Visual Studio 103

10. No Solution Explorer, clique com o botão direito do mouse Test e escolha Set as Startup Project No menu de atalho.

11. No menu Debug, selecione Start Debugging.

Aparece Form1.

12. Clique em valueButton1.

O número ' 5 ' é exibida no label1, demonstrando que a ButtonValue propriedade do seu controle herdado foi passado para label1 através do valueButton1_Click método. Assim o ValueButton controle herda todas as funções do botão Windows Forms padrão, mas expõe uma propriedade adicionais e personalizados.

Visual Studio 104

Explicações passo-a-passo do Visual Studio

Essas orientações introduzir as áreas importantes do produto Visual Studio. Explicação passo a passo cada discute o desenvolvimento de um tipo aplicativo específico ou recurso de aplicativo principal usando uma série de instruções passo a passo. Na maioria dos casos, explicação passo a passo cada incorpora métodos ou recursos de partes diferentes do Visual Studio. Isso fornece uma introdução prática para os vários recursos principais do Visual Studio de uma maneira clara e ordenada.

Walkthroughs de aplicativos cliente Rich O aplicativo rich client típica é um executável autônomo com uma interface gráfica composta de vários controles para o usuário. As orientações seguir descrevem o processo de Criando aplicativo com base em formulários usando vários tipos controle diferente, conexão com um banco de dados existente, e depois exibir os dados no formulário.

Observação

O objetivo principal dessas orientações é para demonstrar os vários recursos do Visual Studio disponíveis para o desenvolvedor do cliente Rich. Portanto, o aplicativo rich client típico contém um subconjunto dos recursos apresentados.

Nesta seção Criando um aplicativo cliente Rich com MFC

Demonstra como criar uma interface cliente rico-usando a biblioteca) classe MFC (Microsoft Foundation, uma biblioteca de classes Well-tested que compatível diversos amplo de recursos comuns a todos os aplicativos Windows, e Consumir um serviço XML da Web criado com Visual Basic ou Visual C#.

Seções relacionadas Criar um formulário simples do Windows

Usando um exemplo simples mas completa, ilustra as etapas fundamentais necessárias para criar Windows Forms no Visual Basic e Visual C#.

Demonstrar herança Visual

Descreve como criar um formulário Windows base e compilá-lo em uma biblioteca de classes. Você irá importar esta biblioteca de classes para outro projeto, e criar um novo formulário herdeira do formulário básico.

Criar um aplicativo distribuídos

Explica como criar um aplicativo de várias camadas, distribuídos que tem um cliente Windows Rich e uma interface do navegador.

Walkthroughs do Windows Forms

Lista orientações adicionais que podem ser executados para familiarizar-se com recursos do Visual Studio.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/6asz720a(VS.80).aspx

Visual Studio 105

Walkthrough: Criando um aplicativo cliente Rich com MFC Explicação passo a passo o seguir descreve um procedimento para criar um aplicativo rich client MFC-Based e vários outros recursos do Visual Studio .NET.


• Criar uma solução-com base MFC que exibe dados de um banco de dados existente e exibe os seguintes recursos usando várias caixas de diálogo:

o Hospedando um controle ActiveX sem janelas o Usando dinâmico caixas de diálogo HTML (DHTML) o Validando o usuário do aplicativo usando um serviço XML da Web

existente.

Para concluir o explicação passo a passo, deve fornecer um banco de dados existente e pelo menos uma tabela pesquisável.

Observação

Essa explicação passo a passo usa o pubs banco de dados e authors tabela como um banco de dados exemplo e tabela.

Criar o aplicativo cliente Rich MFC

Para criar o aplicativo MFC

1. No menu File, clique em New, e clique em Project

A New Project caixa de diálogo será exibida.

2. No painel tipos Project, clique em Visual C++ Projects, e em Painel Modelos, clique no MFC Application ícone.

3. Na caixa Name, digite MyProject.

4. Clique OK para fechar a caixa de diálogo e abrir o MFC Application Wizard.

Usando o MFC Application Wizard, você modificará seu projeto para oferecer suporte o acesso a bancos de dados e exibir recursos do aplicativo rich client.

Observação

Essa explicação passo a passo presume que o servidor está sendo acessado é um servidor SQL e o pubs banco de dados que existe no servidor.

Para implementar suporte a banco de dados

1. No MFC Application Wizard, selecione Database Support.

2. Selecione a Database View with File Support opção.

3. Clique no Data Source botão.

4. Na caixa OLE DB Provider(s) de listagem, clique no Microsoft OLE DB Provider for SQL Server item e clique em Next.

5. Digite ou selecione um nome de servidor existente.

6. Selecione Use Windows NT Integrated Security.

Visual Studio 106

7. Selecione o pubs banco de dados.

8. Clique no OK botão para estabelecer a conexão.

9. Na caixa Select Database Object de diálogo, selecione a authors tabela.

10. Selecione OK para fechar a caixa de diálogo.

11. Clique Finish para criar o aplicativo estrutura.

12. Após a criação do projeto, será necessário remover a #error linha de MyProjectSet.h.

Depois que o aplicativo estrutura for criado, principais recursos podem ser adicionados.

Acessar e exibir dados de um banco de dados existente

Nesta seção, você usará um formulário simples e controle para demonstrar o acesso e exibição dos dados da tabela authors. Porque este é apenas uma demonstração, consulta e exibição são simples. Os resultados da consulta (todos os autores na tabela) são exibidos em uma caixa de listagem.

O MyProject aplicativo já contém um objeto de formulário (chamado IDD_MYPROJECT_FORM) localizado sob o nó diálogo no modo de exibição de recurso,. Você irá modificar este formulário para exibir uma lista simples de autores da tabela authors.

Para modificar o formulário

1. No modo de exibição de recursos, expanda o Projeto, expanda o Dialog nó, e clique duas vezes no objeto de formulário padrão). (IDD_MYPROJECT_FORM

2. Arraste um List Box controle para o formulário padrão.

3. Clique com o botão direito do mouse no List Box controle e, no menu de atalho, clique em Add Variable.

O Add Member Variable Wizard aparece.

4. Na caixa Variable name, digite m_DataList e clique em Finish.

5. Arraste um Button controle para o formulário padrão. Na janela Propriedades, alterar a Caption caixa para Control Host.

6. Arraste um Button controle para o formulário padrão. Na janela Propriedades, alterar a Caption caixa para DHTML Dialog.

Observação

Esses dois controles serão usados posteriormente no explicação passo a passo o para acessar outros recursos do aplicativo.

Para exibir os resultados da consulta

1. No modo classe, expanda o nó de projeto e clique duas vezes no OnInitialUpdate método da classe CMyProjectView.

2. Adicione o seguinte código após qualquer código existente na função: HRESULT hr = S_OK; TCHAR szAuthor[80]; CMyProjectSet &dbset = GetDocument()-

>m_MyProjectSet; [db_command(name="cmd", source_name="dbset", hresult=hr) { SELECT

au_lname ([bindto]szAuthor) FROM AUTHORS }]; while(cmd.MoveNext() == S_OK)

m_DataList.InsertString(-1, szAuthor);

Visual Studio 107

Esse código usa o db_command atributo ao inicializar o conjunto de dados de objeto do documento (m_MyProjectSet.) com os nomes de todos os autores atuais na tabela última

3. No menu Build, clique em Build Solution.

4. No menu Debug, clique em Start Without Debugging.

Os resultados da consulta serão exibidos na caixa de listagem do formulário modo filho.

Criando e hospedando um controle ActiveX sem janelas

A modificação próxima para o aplicativo rich client é uma caixa de diálogo que hospeda um controle personalizado simples sem janelas. A primeira etapa é para criar um controle ActiveX personalizado com um evento simples. Em seguida um objeto Caixa de diálogo é criado que contém o controle e manipular o evento de controle.

Para criar o controle personalizado

1. No Explorer Solution, clique com o botão direito do mouse a MyProject Solução.

2. No menu de atalho, clique em Add, e clique em New Project


3. No painel tipos Project, selecione Visual C++ Projects, e no painel Modelos, clique no ATL Project ícone

4. Digite CustomCtl para o nome do novo projeto e clique em OK.

O ATL Project Wizard aparece.

5. Clique Finish para aceitar as configurações padrão e criar o projeto.

6. Clique com o CustomCtl projeto.

7. No menu de atalho, clique em Add, e clique em Add Class

A Add Class caixa de diálogo será exibida.

8. Clique duas vezes no ATL Control item.

O ATL Control Wizard aparece.

9. Na ATL Control Wizard, insira MyCtl na caixa Short name.

10. Na página Options, escolha Connection points.

11. Clique Finish para criar o objeto controle personalizado.

Depois que o controle for criado, você adicionará um evento simples chamado Click. Este evento é acionado pelo controle sempre que o mouse é clicado na área de controle.

Para criar o evento Click

1. No modo de classe, expanda o CustomCtl nó.

2. Clique com o botão direito do mouse o interface de eventos para o controle personalizado (_IMyCtlEvents).

3. No menu de atalho, clique em Add, e clique em Add Method

4. Insira os seguintes valores usando o Adicionar Assistente método: o Return typevoid

Visual Studio 108

o Method nameClick

5. Clique Finish para criar o Click evento.

6. No modo de classe, selecione a classe de controle (CMyCtl).

7. Na janela Propriedades, clique no Messages botão e adicionar um OnLButtonDown manipulador para a WM_LBUTTONDOWN mensagem.

8. Adicione o seguinte código para o corpo do manipulador: Click(); return 0;


Depois que a solução cria com êxito, uma caixa de diálogo simples pode hospedar o controle.

Para hospedar o controle

1. No modo de exibição do recurso, clique com o botão direito do mouse a MyProject Solução.

2. No menu de atalho, clique em Add, e clique em Add Resource

3. Clique no Dialog item e clique em New.

4. Clique com botão direito mouse na IDD_DIALOG1 caixa de diálogo e clique Add Class no menu de atalho.

O assistente classe MFC aparece.

5. No Assistente para classe MFC, insira os seguintes valores: o Class nameCMyCtlDlg o Base classCDialog


7. Clique com o botão direito do mouse na IDD_DIALOG1 caixa de diálogo e selecione Insert ActiveX Control no menu de atalho.

8. Na caixa de diálogo, selecione CMyCtl Object e Insert ActiveX Control clique OK para adicionar o controle.

9. Selecione o controle ActiveX em um modelo de diálogo.

10. Na janela Propriedades, clique o Control Events botão e adicione um ClickMyctl1 manipulador para o Click evento.

11. Adicione o seguinte código para o corpo do manipulador de eventos: AfxMessageBox("Click event fired");

A etapa final envolve conectando a caixa de diálogo para o aplicativo rich client. Isso é feito com código no manipulador para o botão Controlar host você criou anteriormente, no tópico Accessing and Displaying Data from an Existing Database.

Para exibir a caixa de diálogo de controle host 1. Do IDD_MYPROJECT_FORM no modo de exibição de recursos, exibir o

formulário principal clicando duas vezes (localizada sob o Dialog nó do arquivo de recurso para a MyProject Solução).

2. Clique duas vezes no Control Host botão, adicionada anteriormente.

3. Adicione o seguinte código para a função do manipulador:

Visual Studio 109

CMyCtlDlg dlg; dlg.DoModal( );

4. Adicione o código a seguir após a última #include Instrução no arquivo de origem atual: #include "MyCtlDlg.h"

Isso inclui o arquivo.h da classe implementar a caixa de diálogo Controle host.



Você pode chamar a caixa de diálogo host controle pressionando o Control Host botão. Acionam o evento personalizado Click clicando no botão esquerdo do mouse dentro do controle.

Implementar uma caixa de diálogo DHTML

Outro recurso dos aplicativos cliente Rich é o uso de caixas de diálogo que utilizam HTML para a interface do usuário em vez de recursos diálogo tradicional. Para fins dessa explicação passo a passo, uma caixa de diálogo DHTML simples será implementada, contendo um controle de imagem que exibe um bitmap simples.

Para implementar a caixa diálogo DHTML

1. Clique no modo de exibição de recursos, com o MyProject projeto.


3. Clique no Dialog item e clique New para criar uma nova caixa de diálogo.

4. Remover esses são implementados em HTML nas etapas subseqüentes. e Cancel Botões do modelo de diálogo; o OK

5. Clique com o botão direito do mouse o IDD_DIALOG2 formulário Caixa de diálogo e selecione Add Class

6. Insira os seguintes valores: o Class nameCMyDhtmlDlg o Base classCDHtmlDialog


8. No modo de exibição de recursos, sob o nó HTML, clique duas vezes no IDR_HTML_MYDHTMLDLG item e clique na guia HTML no painel do projeto para editar o arquivo HTML associado.

9. Substituir o texto existente (que deve ser semelhante TODO: Place controls here). com This is the text content of my DHTML dialog box

Como com o diálogo Host de controle implementado anteriormente, esta caixa de diálogo será exibida quando o usuário pressiona um botão (DHTML Dialog.) no formulário principal do aplicativo

Para exibir a caixa de diálogo DHTML

1. Do IDD_MYPROJECT_FORM no modo de exibição de recursos, exibir o formulário principal clicando duas vezes (localizada sob o nó de diálogo do arquivo de recurso para a MyProject Solução).

2. Clique duas vezes no DHTML Dialog botão, adicionada anteriormente.

3. Adicione o seguinte código para a função do manipulador:

Visual Studio 110

CMyDhtmlDlg dlg; dlg.DoModal( );

4. Adicione o código a seguir após a última #include Instrução no arquivo de origem atual: #include "MyDhtmlDlg.h"

Isso inclui o arquivo.h da classe implementação caixa de diálogo DHTML.



Quando for exibida, caixa de diálogo Abrir a caixa de diálogo DHTML pressionando o DHTML Dialog botão.

Para obter mais informações sobre caixas de diálogo DHTML e um exemplo mais completo, consulte a CDHtmlDialog classe e a DHtmlExplore amostra.

Criando e Consuming um serviço da Web XML existente

Ocasionalmente, um aplicativo rich client interage com um serviço XML da Web externo, fornecendo um Rich front-end para um banco de dados existente ou bancos de dados. O usuário é então possam interagir com os dados de uma maneira familiarizado ou gráfica.

Nesta etapa, você irá criar um serviço da Web XML simples projetado para ser executado em um servidor Web usando o Microsoft Internet Information Services (IIS).

Para criar o serviço da Web XML

1. No menu File, clique em New, e clique em Project


2. No painel tipos Project, clique em uma Visual Basic Projects ou Visual C# Projects,. e no painel Modelos, clique no ASP.NET Web Service ícone

3. Na caixa Location, digite http://localhost/MyService.

4. Clique OK para fechar a caixa de diálogo e criar a solução.

Uma parte da serviços XML da Web comum consiste em verificar cada usuário do aplicativo. Após criar a solução, você pode implementar um método simples de validação. Essa rotina de validação é deliberadamente simples para ilustrar o conceito claramente.

Depois que a solução foi criada, adicionar um método de validação ao Service1.asmx arquivo de origem. Para fazer isso, clique com o botão direito do mouse a Service1.asmx.cs superfície de design e selecione View Code Substituir o HelloWorld método da Web no final do arquivo com o código a seguir: ' Visual Basic <WebMethod()> Function Validate(ByVal s1 As String, ByVal s2 As String) As Boolean

Return s1 = s2 End Function // C# [WebMethod] public bool Validate(string s1, string s2) { return s1 ==

s2; }

Depois você modificou o arquivo de origem, Criar a solução.

Depois que o serviço da Web XML existir, você pode adicionar e configurar uma referência da Web com caixa Add Web Reference de diálogo.

Para adicionar uma referência da Web para o aplicativo do cliente

1. Abra a MyProject Solução.

Visual Studio 111

2. No Solution Explorer, clique com o MyProject projeto e selecione Add Web Reference.

A Add Web Reference caixa de diálogo será exibida.

3. Em Browse to, selecione Web services on the local machine. A máquina local será exibido; selecione aquele que você acabou de criar uma lista de serviços XML da Web existente no (Service1). Se o serviço da Web for encontrado, um descrição do serviço será exibida no painel esquerdo e botão Add Reference será ativado. O URL do arquivo.asmx para o serviço da Web também deve aparecer na caixa URL da; ele deve aspecto como este: http://localhost/MyService/Service1.asmx

4. Clique no Add Reference botão.

Assim que a referência da Web for adicionada, você adicionará uma caixa de diálogo de validação para demonstrar a interação entre o aplicativo e o serviço da Web XML.

Para adicionar uma caixa de diálogo de validação

1. Clique no modo de exibição de recursos, com o MyProject projeto.


3. Clique duas vezes no Dialog item.

4. Clique duas vezes no IDD_DIALOG3 formulário Caixa de diálogo.

O assistente classe MFC aparece.

5. Insira os seguintes valores: o Class nameCMyValidateDlg o Base classCDialog


Agora que a caixa diálogo foi criada, adicionar controles para fornecer um serviço de validação para o usuário.

Para validar o usuário

1. Arraste dois Edit control controles para o IDD_DIALOG3 formulário Caixa de diálogo.

2. Clique com o botão direito do mouse na primeira Edit control.

3. No menu de atalho, selecione Add Variable.

4. Na caixa Variable Name, digite m_Name.

5. No menu Category drop-down, selecione Value.


7. Clique com o botão direito do mouse no segundo Edit control Controle.

8. Adicionar outra variável (chamada m_Password de categoria Value).

9. Clique duas vezes no OK botão no formulário Caixa de diálogo.

10. Adicione o seguinte código para a função do manipulador: Service1::CService1 *s = new Service1::CService1(); UpdateData(TRUE); bool result = false; s-

>Validate(CComBSTR(m_Name), CComBSTR(m_Password), &result); if (result)

CDialog::OnOK();

Visual Studio 112

11. Adicione o código a seguir após a última #include Instrução no arquivo de origem atual: #include "WebService.h"

Isso inclui o arquivo.h do serviço da Web usado por caixa de diálogo de validação.

Para a rotina de validação para ser eficiente, caixa de diálogo de validação deve ser o primeiro objeto Interface de usuário seja exibido. Se o usuário inserir o nome correto e a senha a aplicativo rich client serão exibidos. Será se um nome incorreto ou senha for inserida, o usuário atual ser impedido de acessar o aplicativo rich client.

Para implementar esse comportamento, modifique a InitInstance função da classe do aplicativo principal para chamar esta caixa de diálogo primeiro. O aplicativo continua somente quando a caixa diálogo corretamente sai.

Para exibir a caixa de diálogo de validação inicialmente

1. No modo de classe, expanda o CMyProjectApp nó.

2. Clique duas vezes a InitInstance função para editar o corpo função.

3. Adicione o seguinte código antes que a chamada para a ShowWindow função do objeto pMainFrame: // Display the validation dialog box first CMyValidateDlg dlg; if (dlg.DoModal() != IDOK) return

FALSE;

4. Adicione o código a seguir após a última #include Instrução no arquivo de origem atual: #include "MyValidateDlg.h"

Isso inclui o arquivo.h da caixa de diálogo de validação.

5. Compilar uma solução. No menu Build, clique em Build Solution.

6. No menu Debug, clique em Start Without Debugging. Na caixa de diálogo de verificação, inserir o mesmo texto nas caixas de edição Nome e senha, e clique em OK. O aplicativo rich client será executada, exibindo sua caixa de diálogo principal.

Criar um projeto de instalação

A etapa final ao desenvolver seu aplicativo Visual C++ está criando um projeto de instalação.

Para criar um projeto de instalação

1. No Explorer Solution, clique com o botão direito do mouse a MyProject Solução.

2. No menu de atalho, clique em Add, e clique em New Project


3. No painel tipos Project, selecione Setup and Deployment Projects, e no painel Modelos, clique no Setup Wizard ícone

4. Digite MySetup o nome do projeto de instalação para e clique em OK.

O Assistente para Instalação será exibido.

5. Clique em Next duas vezes.

Visual Studio 113

6. Selecione os seguintes grupos de saída: o Saída de MyProject principal o Saída de CustomCtl principal

7. Clique em Next duas vezes.

8. Clique em Finish

9. No menu Build, clique em Build MySetup.

O arquivo resultante (MySetup) pode ser copiado para uma máquina de destino para instalação do aplicativo rich client. Para obter mais informações sobre projetos de implantação e o Assistente para instalação, consulte Implantar aplicativos, Projetos de implantação. e Walkthroughs de implantação

Visual Studio 114

Walkthroughs Application de formulários da Web

O objetivo dessas orientações é para mostrar como criar um site da Web usando páginas da Web e controles ASP.NET. A tabela a seguir lista uma seleção de orientações que fornecerá uma visão geral dos recursos ASP.NET. Por trabalhar com essas orientações, você aprenderá sobre a criação de sites, criar e editar páginas da Web, conectando a fontes de dados, criando um objeto comercial da camada intermediária, e usar outros recursos ASP.NET para personalizar os sites e páginas.

Walkthrough Descrição

Passo-a-passo: Criando uma página da Web básica no Visual Web Developer

Uma introdução ao criar páginas da Web ASP.NET no Visual Studio.

Passo-a-passo: Acesso a dados básico em páginas da Web

Uma introdução ao exibir dados em uma página da Web usando os controles da fonte de dados e o GridView controle.

Passo a passo: Ligação de dados em um objeto corporativo personalizado

Uma introdução ao criar um componente de camada intermediária que torna dados disponível para páginas da Web.

Passo-a-passo: Depuração de Páginas da Web no Visual Web Developer

Uma introdução ao usar o depurador Visual Studio com páginas da Web.

Passo-a-passo: Criando e Usando Páginas Mestras do ASP.NET no Visual Web Developer

Uma introdução ao usar páginas mestras ASP.NET para definir um layout geral para páginas da Web.

Passo-a-passo: Personalizando um site usando temas no Visual Studio

Uma introdução ao definir um aparência consistente para suas páginas da Web.

Passo-a-passo: Criando uma página do Web Parts no Visual Web Developer

Uma introdução ao criar uma página da Web que usa Partes da Web para permitir que o usuário para personalizar o conteúdo e layout de uma página.

Passo a passo: Criando um site com associação e logon de usuário (Visual Studio)

Uma introdução a adicionar segurança logon em um site da Web.

Passo a passo: Criando e usando um serviço da Web do ASP.NET no Visual Web Developer

Uma introdução ao criar um serviço da Web ASP.NET e consumindo-lo de uma página da Web.

Visual Studio 115

Explicação Passo a Passo: Criando uma Página Web Básica no Visual Web

Developer Esta explicação passo a passo fornece uma introdução ao Microsoft Visual Web Developer. Ela orienta você através da criação de uma página simples usando o Visual Web Developer, ilustrando as técnicas básicas de criação de uma nova página, adicionando controles e escrevendo código.

As tarefas ilustradas nesta explicação passo a passo incluem:

• Criar um site Web do sistema de arquivos.

• Familiarizando-se com o Visual Web Developer.

• Criando uma página ASP.NET Single-File no Visual Web Developer.

• Adicionar controles.

• Adicionar manipuladores de eventos.

• Executar páginas com o Servidores Web em Visual Web Developer.

Pré-requisitos

Para concluir esta explicação passo a passo, será necessário:

• Visual Web Developer

• O .NET Framework

Criando um Site e Página Web

Nesta parte da explicação passo a passo, você criará um site Web e adicionará uma nova página a ele. Você também adicionará um texto HTML e executará a página no seu navegador Web.

Para esta explicação passo a passo, você criará um site Web do sistema de arquivos que não requer que você trabalhe com o Internet Information Services (IIS) da Microsoft. Em vez disso, você criará e executará sua página no sistema de arquivos local.

Um sistema de arquivos do site Web é um sistema que armazena páginas e outros arquivos em uma pasta que você escolhe em algum lugar em seu computador local. Outras opções de site Web incluem um site Web do IIS local, que armazena seus arquivos em uma subpasta da raiz do IIS local (normalmente, \Inetpub\Wwwroot\). Um site FTP armazena arquivos em um servidor remoto que você acessa através da Internet, usando o File Transfer Protocol (FTP). Um site remoto armazena arquivos em um servidor remoto que você pode acessar através de uma rede local. Para mais informações, consulte Explicação Passo a Passo: Editando Sites Web com FTP no Visual Web Developer. Além disso, os arquivos do site Web podem ser armazenados em um sistema de controle de origem como o Visual SourceSafe. Para mais informações, consulte Introdução ao Controle de Origem.

Para criar um site Web do sistema de arquivos

1. Abra o Visual Web Developer.

2. No menu File, aponte para New, e em seguida, clique em Web site

A caixa de diálogo New Web Site aparece como mostrado na screen shot a seguir.

Visual Studio 116

Caixa de diálogo New Web Site

3. No Visual Studio installed templates, clique em ASP.NET Web Site.

Quando você cria um site Web, você especifica um modelo. Cada modelo cria um aplicativo Web que contém arquivos e pastas diferentes. Nesta explicação passo a passo, você está criando um site Web baseado no modelo ASP.NET Web Site, que cria algumas pastas e alguns arquivos padrão.

4. Na caixa Location, selecione a caixa File System e seguida, digite o nome da pasta onde você deseja manter as páginas do seu site Web.

Por exemplo, digite o nome da pasta C:\BasicWebSite.

5. Na lista Language, clique em Visual Basic ou Visual C#.

A linguagem de programação que você escolher será o padrão para seu site Web. Entretanto, você pode usar vários idiomas no mesmo aplicativo Web, criando páginas e componentes em linguagens de programação diferentes

6. Clique em OK.

O Visual Web Developer cria a pasta e uma nova página chamada Default.aspx. Quando uma nova página é criada, por padrão, o Visual Web Developer exibe a página no modo Source, onde você pode ver os elementos HTML da página. O screen shot a seguir mostra o modo Source de uma página Web padrão.

Modo Source de uma página padrão

Um Tour do Visual Web Developer Antes de você prosseguir trabalhando na página, é útil você se familiarizar com o ambiente de desenvolvimento do Visual Web Developer. A ilustração a seguir mostra as janelas e ferramentas que estão disponíveis no Visual Web Developer.

Diagrama do ambiente Visual Web Developer

Para se familiarizar com o designer da Web em Visual Web Developer • Examinar a ilustração anterior e corresponder o texto para a lista a seguir,

que descreve as janelas e ferramentas mais comumente usadas. (Nem todas as janelas e ferramentas que você vê são listadas aqui, somente as marcadas na ilustração anterior.)

o Barras de ferramentas. Fornecem comandos de formatação de texto, localização de texto, e assim por diante. Algumas barras de ferramentas ficão disponíveis somente quando você está trabalhando em modo Design.

o Solution Explorer. Exibe os arquivos e pastas em seu site Web. o Janela de Documento. Exibem os documentos com os quais você está

trabalhando em janelas com guias. Você pode alternar entre documentos clicando nas guias.

o Janela de Propriedades. Permite que você altere as configurações da página, dos elementos HTML, dos controles e de outros objetos.

Visual Studio 117

o Guias de Exibição. Mostra diferentes modos de exibição do mesmo documento. Modo Design é uma superfície de edição próxima ao WYSIWYG. Modo Source é o editor HTML para a página. Você trabalhará com esses modos posteriormente nesta explicação passo a passo. Se você preferir abrir as páginas Web em modo Design, no menu Tools, clique em Options, selecione o nó HTML Designer e altere a opção Start Pages In.

o Caixa de Ferramentas. Fornece controles e elementos HTML que você pode arrastar para a sua página. Os elementos da caixa de ferramentas são agrupados por função em comum.

o Server Explorer/Database Explorer. Exibe conexões de banco de dados. Se o Server Explorer não estiver visível no Visual Web Developer, no menu View, clique em Other Windows, e clique em Server Explorer.

Observação

Você pode reorganizar e redimensionar as janelas para atender suas preferências. O menu View permite exibir janelas adicionais.

Criando uma Nova Página Web Forms

Quando você cria um novo site Web, o Visual Web Developer adiciona uma página do ASP.NET (página Web Forms) chamada Default.aspx. Você pode usar a página Default.aspx como a home page para o seu site Web. Entretanto, para esta explicação passo a passo, você irá criar e trabalhar com uma nova página.

Para adicionar uma página ao site Web

1. Feche a página Default.aspx. Para fazer isso, clique com o botão direito do mouse na guia que contém o nome de arquivo e selecione Close.

2. Na Solution Explorer, clique com o botão direito do mouse o site Web (por exemplo, C:\BasicWebSite), e clique em Add New Item.

3. No Visual Studio installed templates, clique em Web Form.

4. Na caixa Name, digite FirstWebPage.

5. Na lista Language, escolha a linguagem de programação que você prefere usar (Visual Basic, C#, ou J#).

Quando você cria o site Web, você especifica uma linguagem padrão. Entretanto, sempre que você cria um nova página ou um componente para o seu site Web, você pode alterar a linguagem. Você pode usar linguagens de programação diferentes no mesmo site Web.

6. Desmarque a caixa de seleção Place code in separate file. A screen shot a seguir mostra a caixa de diálogo Add New Item.

Caixa de Diálogo Add New Item

Nesta explicação passo a passo, você está criando uma página single-file com o código e HTML na mesma página. O código para páginas do ASP.NET pode ser localizado na página ou em um arquivo de classe separado. Para saber mais sobre como manter o código em um arquivo separado, consulte Explicação Passo a Passo: Criando uma Página Web Básica com Separação de Código no Visual Web Developer.

Visual Studio 118

7. Clique em Add.

O Visual Web Developer cria a nova página e a abre no modo Source.

Adicionando HTML à página

Nesta parte da explicação passo a passo, você irá adicionar algum texto estático para a página.

Para adicionar texto para a página

1. Na parte inferior da janela de documento, clique na guia Design para alternar para o modo Design.

O modo Design exibe a página com a qual você está trabalhando de uma maneira WYSIWYG. Nesse ponto, você não tem qualquer texto ou controles na página; então, a página está em branco.

2. Na página, digite Bem-vindo ao Visual Web Developer.

A screen shot a seguir mostra o texto que você digitou no modo Design.

O texto de boas vindas como visto no modo Design

3. Alterne para modo Source.

Você pode ver o HTML que você criou, digitando no modo Design, como mostrado na seguinte screen shot.

O texto de boas vindas como visto no modo Source

Executando a Página

Antes de prosseguir com a adição de controles para a página, você pode tentar executá-la. Para executar uma página, é necessário um servidor Web. Em um site Web de produção, você usa o IIS como seu servidor Web. Entretanto, para testar uma página, você pode usar o Servidor de Desenvolvimento do ASP.NET, que é executado localmente e não requer o IIS. Para os sites Web do sistema de arquivos, o servidor Web padrão no Visual Web Developer é o Servidor de Desenvolvimento do ASP.NET.

Para executar a página

1. Pressione CTRL+F5 para executar a página.

O Visual Web Developer inicia o Servidor de Desenvolvimento do ASP.NET. Um ícone aparece na barra de ferramentas para indicar que o servidor Web Visual Web Developer está sendo executado, como mostrado na seguinte screen shot.

Ícone do Servidor Visual Web Developer

A página é exibida no navegador. Embora a página que você criou tenha uma extensão .aspx, ela atualmente executa como qualquer página HTML.

Observação

Visual Studio 119

Se o navegador exibe um erro 502 ou um erro indicando que a página não pode ser exibida, você deve configurar seu navegador para ignorar os servidores proxy para solicitações locais. Para obter detalhes, consulte COMO: Ignorar um Servidor proxy para Solicitações Web Locais.

2. Feche o navegador.

Adicionando e Programação Controles

Nesta parte da explicação, você irá adicionar os controles Button, TextBox e Label para a página e gravar o código para manipular o evento Click para o controle Button.

Agora você irá adicionar os controles do servidor na página. Os controles do servidor, que incluem botões, rótulos, caixas de texto e outros controles familiares, fornecem capacidades típicas para processamento de formulários para suas páginas Web do ASP.NET. Entretanto, você pode programar os controles com código que é executado no servidor, não no cliente.

Para adicionar controles para a página

1. Clique na guia Design para alternar para modo Design.

2. Pressione SHIFT+ENTER algumas vezes para criar um pouco de espaço.

3. No TextBox, a partir do grupo Standard, arraste três controles para a página: um controle Label, um controle Toolbox e um controle Label.

4. Coloque o ponto de inserção acima do controle TextBox e em seguida, digite Entre com o seu nome:.

Esse texto HTML estático é a legenda do controle TextBox. Você pode misturar HTML estático e controles de servidor na mesma página. O screen shot a seguir mostra como os três controles aparecem no modo Design.

Controles no Modo de Exibição Design

Definindo as Propriedades do Controle

O Visual Web Developer oferece várias maneiras para definir as propriedades dos controles na página. Nesta parte da explicação passo a passo, você irá definir as propriedades em modo Design e em modo Source.

Para definir as propriedades de controle

1. Selecione o controle Button e na janela Properties, defina Text para Display Name, conforme mostrado na screen shot a seguir.

Texto do Controle Button Alterado


O modo de exibição Source exibe o HTML para a página, incluindo os elementos que o Visual Web Developer criou para os controles do servidor. Os controles são declarados usando sintaxe do tipo HTML, exceto as marcas que usam o prefixo asp: e incluem o atributo runat="server".

As propriedades do controle são declaradas como atributos. Por exemplo, quando você define a propriedade Text para o controle Button, na etapa 1, você realmente definiu o atributo Text na marcação do controle.

Visual Studio 120

Observe que todos os controles estão dentro de um elemento <form> que também tem o atributo runat="server". O atributo runat="server" e o prefixo asp: para controle de marcas marcam os controles para que eles sejam processados pelo ASP.NET no lado do servidor quando a página é executada. Código fora dos elementos <form runat="server"> e <script runat="server"> é interpretado pelo navegador como código do cliente.

3. Coloque o ponto de inserção em um espaço dentro da guia <asp:label>, e pressione SPACEBAR.

Uma lista suspensa aparece para mostrar a lista de propriedades que você pode definir para o controle Label. Esse recurso, conhecido como IntelliSense, ajuda você no modo Source com a sintaxe dos controles de servidor, elementos HTML e outros itens na página. A screen shot a seguir mostra a lista suspensa do IntelliSense para o controle Label.

O IntelliSense para o controle Label

4. Selecione ForeColor e digite um sinal de igualdade (=). O IntelliSense exibe uma lista de cores.

Observação

Você pode exibir uma lista suspensa do IntelliSense a qualquer momento, pressionando CTRL+J.

5. Selecione uma cor para o texto do controle Label.

O atributo ForeColor é concluído com a cor que você selecionou.

Programando o Controle Button

Para esta explicação passo a passo, você irá escrever um código que lê o nome que o usuário insere na caixa de texto e exibe o nome no controle Label.

Para adicionar um manipulador de eventos padrão para o controle button

1. Alternar para o modo Design.

2. Clique duas vezes no controle Button.

O Visual Web Developer alterna para o modo Source e cria um esqueleto de manipulador de eventos para o evento padrão do controle Button, o evento Click.

Observação

Clicar duas vezes em um controle em modo Design é apenas uma das várias maneiras para você poder criar os manipuladores de eventos.

3. Dentro do manipulador, digite o seguinte:

Label1.

O Visual Web Developer exibirá uma lista dos membros disponíveis para o controle Label, conforme mostrado a screen shot a seguir.

Membros disponíveis do controle Label

Visual Studio 121

4. Concluir o manipulador de evento Click para o botão para que ele apareça como mostrado no exemplo de código a seguir.

C# protected void Button1_Click(object sender, System.EventArgs e) { Label1.Text = TextBox1.Text +

", welcome to Visual Web Developer!"; }

5. Role para baixo até o elemento <asp:Button>. Observe que o elemento <asp:Button> agora tem o atributo OnClick="Button1_Click". Este atributo vincula o evento Click do botão para o método do manipulador que você codificou na etapa 4.

Os métodos do manipulador de eventos podem ter qualquer nome; o nome que você vê é o nome padrão criado pelo Visual Web Developer. O ponto importante é que o nome usado para o atributo OnClick deve corresponder ao nome de um método na página.

Observação

Se você estiver usando o Visual Basic com separação de código, o Visual Web Developer não adiciona um atributo OnClick explícito. Em vez disso, o evento é acoplado ao método do manipulador usando uma palavra-chave Handles na própria declaração do manipulador.


Agora você pode testar os controles do servidor na página.


1. Pressione CTRL+F5 para executar a página no navegador.

A página novamente executa usando o Servidor de Desenvolvimento do ASP.NET.

2. Digite um nome para a caixa de texto e clique o botão.

O nome que você inseriu é exibido no controle Label. Observe que quando você clica no botão, a página é remetida para o servidor Web. O ASP.NET recria a página, executa o seu código (neste caso, executa o manipulador de eventos Click do controle Button), e em seguida, envia a nova página para o navegador. Se você observar a barra de status do navegador, você pode ver que a página está fazendo uma chamadapara o servidor Web sempre que você clicar no botão.

3. No navegador, exiba o fonte da página que você estiver executando.

No código fonte da página, você vê somente HTML comum; você não vê os elementos <asp:> com os quais você estava trabalhando no modo Source. Quando a página é executada, o ASP.NET processa os controles do servidor e processa os elementos HTML da página que executa as funções que representam o controle. Por exemplo, o controle <asp:Button> é processado como o elemento HTML <input type="submit">.


Trabalhando com Controles Adicionais

Visual Studio 122

Nesta parte da explicação , você trabalhará com o controle Calendar, que exibe as datas de um mês ao mesmo tempo. O controle Calendar é um controle mais complexo que o botão, a caixa de texto e o rótulo com os quais você tem trabalhado e ilustra alguns recursos adicionais dos controles do servidor.

Nesta seção, você adicionará um controle Calendar na página e o formatará.

Para adicionar um controle Calendar 1. Em Visual Web Developer, alterne para modo Design.

2. A partir da seção Standard do Toolbox, arraste um controle Calendar para a página:

O painel de marca inteligente do calendário é exibido. O painel exibe comandos que facilitam a execução das tarefas mais comuns para o controle selecionado. A screen shot a seguir mostra o controle Calendar como processado no modo Design.

Controle Calender no modo Design

3. No painel de marca inteligente, escolha Auto Format.

A caixa de diálogo Auto Format é exibida, permitindo que você selecione um esquema de formatação para o calendário. A screen shot a seguir mostra a caixa de diálogo Auto Format para o controle Calendar.

Caixa de Diálogo Auto Format para o controle Calendar

4. Na lista Select a scheme, selecione Simple e em seguida, clique em OK


Você pode ver o elemento <asp:Calendar>. Este elemento é muito maior que os elementos para os controles simples que você criou anteriormente. Ele também inclui subelementos, como <WeekEndDayStyle>, que representam várias configurações de formatação. A screen shot a seguir mostra o controle Calendar no modo Source.

Controle Calendar em modo Source

Programando o Controle Calendar Nesta seção, você programará o controle Calendar para exibir a data selecionada atualmente.

Para programar o controle Calendar 1. A partir da lista suspensa da esquerda no topo do modo Source, selecione

Calendar1.

A lista suspensa exibe uma lista de todos os objetos para os quais você pode escrever código.

2. A partir da lista suspensa da direita, selecione SelectionChanged.

O Visual Web Developer cria um esqueleto de manipulador de eventos para o evento SelectionChanged do controle Calendar.

Visual Studio 123

Agora você já viu duas maneiras para criar um manipulador de eventos para controles. O primeiro foi clicar duas vezes o controle no modo Design. O segundo é usar as listas suspensas em modo Source para selecionar um objeto e o evento para o qual escrever o código.

3. Concluir o manipulador de evento SelectionChanged com o seguinte código destacado.

C# protected void Calendar1_SelectionChanged(object sender, System.EventArgs e) { Label1.Text =

Calendar1.SelectedDate.ToString(); }


Agora você pode testar o calendário.


1. Pressione CTRL+F5 para executar a página no navegador.

2. Clique em uma data no calendário.

A data que você clicou é exibida no controle Label.

3. No navegador, exibir o código fonte para a página.

Observe que o controle Calendar tem sido processado para a página como uma tabela, com cada dia como um elemento <td> contendo um elemento <a>.


Próximas Etapas

Esta explicação ilustra os recursos básicos do designer da página do Visual Web Developer. Agora que você entende como criar e editar uma página Web no Visual Web Developer, você pode querer explorar outros recursos. Por exemplo, você pode querer:

• Aprender mais sobre como editar HTML no Visual Web Developer. Para obter detalhes, consulte Explicação Passo a Passo: Edição de HTML Básica no Visual Web Developer.

• Adicionar acesso de dados para as páginas Web. Para obter detalhes, consulte Explicação Passo a Passo: Acesso de Dados Básicos em Páginas Web.

• Aprenda sobre o depurador para páginas da Web. Para obter detalhes, consulte Explicação Passo a Passo: depuração de páginas Web no Visual Web Developer.

• Criar páginas Web que são especificamente projetadas para telefones celulares e outros dispositivos. Para obter detalhes, consulte Explicação Passo a Passo: Criando Páginas Web para Dispositivos Móveis.

• Criar um layout de site consistente usando páginas mestra. Para obter detalhes, consulte Explicação Passo a Passo: Criando e Usando Páginas Mestra do ASP.NET em Visual Web Developer.

• Adicionar navegação ao seu site para que os usuários possam facilmente se mover entre as páginas. Para obter detalhes, consulte Explicação Passo a Passo: Adicionando Navegação de Site para um Site Web.

Visual Studio 124

Passo-a-passo: Acesso a Dados Básico em Páginas da Web

Este passo-a-passo mostra como como criar uma página simples com dados vinculados usando controles que são especialmente criados para acesso a dados.

Durante este passo-a-passo, você aprenderá a fazer o seguinte:

• Conectar-se a um banco de dados do Microsoft SQL Server na ferramenta de desenvolvimento da web, o Microsoft Visual Web Developer.

• Usar edição arrastar-e-soltar para criar elementos de acesso a dados que podem ser usados na página sem código.

• Usar o controle SqlDataSource para gerenciar o acesso a dados e vinculação.

• Exibir dados com o controle GridView.

• Configurar o controle GridView para permitir a classificação e paginação.

• Criar uma consulta filtrada que exibe somente registros selecionados.

Pré-requisitos

Para concluir este passo-a-passo, será necessário o seguinte:

• Acesso ao o banco de dados SQL Server Northwind.

• Se o banco de dados Northwind não estiver no mesmo computador do servidor web, você deve ter um nome de usuário e senha para uma conta de usuário do SQL Server que tenha acesso ao banco de dados Northwind

Observação

Se você precisar de informações sobre como efetuar login no SQL Server, contate o administrador do servidor.

• Microsoft Data Access Components (MDAC) versão 2.7 ou posterior.

Se você estiver usando o Microsoft Windows XP ou Windows Server 2003, você já tem MDAC 2.7. Entretanto, se você estiver usando o Microsoft Windows 2000, você pode atualizar o MDAC que já está instalado no o computador. Para fazer o download da versão atual do MDAC, consulte Centro de Desenvolvimento de Acesso e Armazenamento de Dados.

Criando o site da web

Se você já criou um site no Visual Web Developer completando o Passo-a-passo: Criando uma Página da Web Básica no Visual Web Developer, você pode usar esse site e ir para a próxima seção. Caso contrário, crie um novo site e página seguindo estas etapas.

Para criar um site do sistema de arquivos


2. No menu File, clique em New Web Site.

A caixa de diálogo New Web Site aparece.

3. Em Visual Studio installed templates, clique em ASP.NET Web Site.

Visual Studio 125

4. Na caixa Location mais a direita, insira o nome da pasta onde você deseja manter as páginas do site

Por exemplo, digite o nome de pasta C:\WebSites.

5. Na lista Language, clique na linguagem de programação que preferir trabalhar.

6. Clique em OK.

O Visual Web Developer cria a pasta e uma nova página chamada Default.aspx.

Adicionando um Controle GridView para Exibir Dados

Para exibir dados em um página da web do ASP.NET, é necessário o seguinte:

• Uma conexão com uma fonte de dados (como um banco de dados).

No procedimento a seguir, você criará uma conexão com o banco de dados SQL Server Northwind.

• Um controle da fonte de dados na página, que executa consultas e gerencia os resultados de consultas.

• Um controle na página para exibir os dados realmente.

No seguinte procedimento, você irá exibir dados em um controle GridView. O controle GridView receberá seus dados a partir do controle SqlDataSource.

Você pode adicionar esses elementos para o site separadamente. No entanto, é mais fácil começar a visualizando a exibição de dados usando o controleGridView, e usando assistentes para criar a conexão e o controle da fonte de dados. O procedimento a seguir explica como criar todos os três elementos que você deve ter para exibir dados na página.

Para adicionar e configurar um controle GridView para exibir dados

1. No Visual Web Developer, alterne para o modo de exibição Design.

2. Da pasta Data em Toolbox, arraste um controle GridView para a página.

3. Se o o menu de atalho GridView Tasks não for exibido, clique com o botão direito do mouse no controle GridView e clique em Show Smart Tag.

4. No menu GridView Tasks, em Choose Data Source list, clique em <New data source>.

A caixa de diálogo Data Source Configuration aparece.

Visual Studio 126

5. Clique em Database.

Isso especifica que você deseja obter dados de um banco de dados que suporte instruções SQL. Isso inclui o SQL Server e outros OLE-DB – bancos de dados compatíveis.

Na caixa Specify an ID for the data source, um nome controle da fonte de dados padrão aparece (SqlDataSource1). Você pode deixar esse nome.

6. Clique em OK.

O Wizard Configure Data Source aparecerá, exibindo uma página na qual você pode escolher uma conexão.

Visual Studio 127

7. Clique em New Connection.

8. Na caixa de diálogo Choose Data Source, em Data source, clique em Microsoft SQL Server e clique emContinue.

A caixa de diálogo Add Connection aparece.

9. Na caixa Server name , digite o nome do SQL Server que você deseja usar.

Visual Studio 128

10. Para as credenciais de login, selecione a opção que seja apropriada para acessar o banco de dados do SQL Server (segurança integrada ou ID específico e senha) e se for necessário, digite um nome de usuário e senha.

11. Clique em Select or enter a database name, e digite Northwind.

12. Clique em Test connection e, quando você tiver certeza que ele funciona, clique em OK.

O assistente Configure Data Source - <DataSourceName> aparece e as informações de conexão são preenchido.

13. Clique em Next.

O assistente aparecerá, exibindo uma página onde você pode escolher armazenar a seqüência de conexão no arquivo de configuração. Armazenar a seqüência de conexão no arquivo de configuração tem duas vantagens:

1. É mais seguro do que armazenar a seqüência de conexão na página.

2. Você pode reutilizar a mesma seqüência de conexão em várias páginas.

14. Certifique-se de que a caixa de seleção Yes, save this connection as esteja selecionada, e clique em Next. (Você pode deixar o nome de seqüência de conexão padrão NorthwindConnectionString.)

Visual Studio 129

O assistente aparecerá, exibindo uma página na qual você pode especificar os dados que você deseja buscar do banco de dados.

15. Em Specify columns from a table or view, na lista Name, clique em Customers.

16. Em Columns, selecione o CustomerID, CompanyName e City check boxes.

O assistente aparecerá, exibindo a Instrução SQL que você está criando em uma caixa na parte inferior da página.

Observação

O assistente permite que você especifique critérios de seleção (uma cláusula WHERE) e outras opções de consulta SQL. Para esta parte do passo-a-passo, você vai criar uma declaração simples sem seleção ou opções de classificação.

17. Clique em Next.

18. Clique em Test Query para certificar-se que está buscando os dados que você deseja.


O assitente fecha e você retornado para a página. Executar o assistente realizou duas tarefas:

o O assistente criou e configurou um controle SqlDataSource (chamado SqlDataSource1), que incorpora as informações de conexão e consulta que você especificou.

Visual Studio 130

o O assistente acoplou o controle GridView para o SqlDataSource. Portanto, o controle GridView exibirá dados que são retornados pelo controle SqlDataSource.

Se você exibir as propriedades para o controle SqlDataSource, você verá que o assistente criou valores para as propriedades ConnectionString e SelectQuery.

Observação

Você pode facilmente alterar o aspecto do controle GridView. No modo de exibição Design, clique com o botão direito do mouse no controle GridView e clique emShow Smart Tag. No menu GridView Tasks, clique em Auto Format e aplique um esquema.

Testando a página

Agora você pode executar a página.

Para testar a página


A página aparece no navegador. O controle GridView exibe todas as linhas de dados da tabela Customers.


Adicionando Classificação e Paginação

Você pode adicionar classificação e paginação no controle GridView sem escrever nenhum código.

Para adicionar classificação e paginação

1. No modo de exibição Design, clique com o botão direito do mouse no controle GridView e clique em Show Smart Tag.

2. No menu de atalho GridView Tasks, selecione Enable Sorting check box.

Os títulos de colunas no controle GridView alteram para vínculos.

3. No menu GridView Tasks, selecione Enable Paging check box.

Um rodapé é adicionado ao controle GridView com links de número página.

4. Opcionalmente, use Properties para alterar o valor da propriedade PageSize de 10 para um tamanho de página menor.


Será possível clicar em uma coluna título para classificar pelos conteúdos dessa coluna. Se há mais registros na fonte de dados do que o tamanho da página, do controle GridView, você poderá usar os links de navegação de página na parte inferior do controle GridView para mover entre páginas.


Adicionando filtragem

Com freqüência você deseja exibir somente dados selecionados na página. Nesta parte do passo-a-passo, você modificará a consulta para o controle SqlDataSource para que os usuários possam selecionar registros de clientes para uma cidade específica.

Visual Studio 131

Primeiro, você usará um controle TextBox para criar um caixa de texto na qual os usuários poderão digitar o nome de uma cidade. Em seguida, alterará a consulta para incluir um filtro parametrizado (cláusula WHERE). Como parte desse processo, você criará um elemento de parâmetro para o controle SqlDataSource. O elemento de parâmetro estabelece como o controle SqlDataSource obterá o valor para sua consulta com parametrizada — nomeada, da caixa de texto.

Quando você tiver terminado com essa parte do passo-a-passo, a página será semelhante a este procedimento no modo de exibição Design.

Para adicionar a caixa de texto para especificar uma cidade

1. A partir do grupo Standard em Toolbox, arraste um controle TextBox e um controle Button para a página.

O controle Button é usado somente para enviar a página para o servidor. Você não precisará escrever qualquer código para ele.

2. Em Propriedades, para o controle TextBox, definida ID como textCity.

3. Se você desejar, digite City ou texto semelhante antes da caixa de texto atuar como uma legenda.

4. Em Properties para o controle Button, definida Text como Submit.

Agora você pode modificar a consulta para incluir um filtro.

Para modificar a consulta com um filtro parametrizados

1. Clique com o botão direito do mouse no controle SqlDataSource e clique em Show Smart Tag.

2. No menu SqlDataSource Tasks, clique em Configure Data Source.

O assistente Configure Data Source - <Datasourcename> aparece.

3. Clique em Next.

O assistente exibe o comando SQL que está atualmente configurado para o controle SqlDataSource.

Visual Studio 132

4. Clique em WHERE.

Aparecerá a página Add WHERE Clause.

5. Na lista Column, clique em City.

6. Na lista Operator, clique em =.

7. Na lista Source, clique em Control.

8. Em Parameter properties, na lista Control ID, clique em textCity.

As cinco etapas anteriores especificam que a consulta obterá o valor de pesquisa para City a partir do controle TextBox adicionado mo procedimento anterior.

9. Clique em Add.

A cláusula WHERE que você criou aparecerá em uma caixa na parte inferior da página.

10. Clique em OK para fechar a página Add WHERE Clause.

11. No assistente Configure Data Source - <DataSourceName>, clique em Next.

12. Na página Test Query, clique em Test Query.

O assistente aparecerá, exibindo a página Parameter Values Editor, que solicita a você um valor para usar na cláusula WHERE.

13. Na caixa Value, digite London e clique em OK.

Os registros de clientes de London aparecem.

14. Clique em Finish para fechar o assistente.

Agora você pode testar a filtragem.

Visual Studio 133

Para testar a filtragem


2. Na o caixa de texto, digite London, e clique em Submit.

Uma lista de clientes da City of London aparecerá no controle GridView.

3. Tente outras cidades, como Buenos Aires e Berlin.

Próximas etapas

Acesso a dados é uma parte importante em vários aplicativos da web, este passo-a-passo forneceu somente uma amostra do que você pode fazer com dados em páginas da web. Você pode testar outros recursos adicionais do acesso a dados. Por exemplo, convém fazer o seguinte:

• Trabalhar com o Microsoft Access em vez do SQL Server (Você não pode usar dependência de cache SQL com o Access).

Para obter informações detalhadas, consulte Passo-a-passo: Criando uma Página da Web para Exibir Dados de Banco de Dados do Access.

• Editar e inserir registros.

Para obter informações detalhadas, consulte Passo-a-passo: Editando e Inserindo Dados em Páginas da Web com o Controle DetailsView Web Server..

• Trabalhar com registros que tenham um relacionamento master-detail.

Para obter informações detalhadas, consulte Passo-a-passo: Criando Páginas da Web Master/Detail no Visual Studio.

• Criar um componente middle-tier (comercial) que executa acesso a dados, e o usa como fonte de dados em uma página.

Para obter informações detalhadas, consulte Passo-a-passo: Vinculação de Dados para um Objeto Business Personalizado.

Visual Studio 134

Passo-a-passo: Ligação de dados para um objeto corporativo personalizado

Muitos aplicativos da Web são criados usando várias camadas, com um ou mais componentes contidos na camada no meio para fornecer acesso a dados. O Microsoft Visual Web Developer inclui um assistente que ajuda você a criar um componente de dados que você pode usar como um objeto de dados de camada do meio, conforme descrito em Passo-a-passo: Ligação de dados de páginas da Web com um componente de dados do Visual Studio.

Entretanto, você também pode desejar criar um objeto corporativo personalizado, em vez contar com o componente de dados criado pelo o assistente. Criar um objeto corporativo personalizado permite que você implemente suas próprias lógicas corporativa. Esta explicação passo a passo ilustra como criar um objeto corporativo básico que você pode usar como uma fonte de dados para páginas da Web do ASP.NET.

Durante esta explicação passo a passo, você aprenderá como:

• Criar um componente que pode retornar dados para um página da Web. O componente usa um arquivo XML para seus dados.

• Fazer referência a objeto corporativo como uma fonte de dados em uma página da Web.

• Acoplar um controle para os dados retornados pelo objeto corporativo.

• Ler e gravar dados, usando o objeto corporativo.

Pré-requisitos


• Visual Web Developer (Visual Studio).

• O .NET Framework.

Esta explicação passo a passo presume que você tenha uma compreensão geral de como usar o Visual Web Developer.

Criando o site da Web

Se já tiver criado um site no Visual Web Developer (por exemplo, seguindo as etapas no Passo-a-passo: Criando uma página da Web básica em Visual Web Developer), você pode usar esse site e vá para a próxima seção, "Criando um arquivo XML para dados Corporativos." Caso contrário, crie um novo site e página seguindo estas etapas.






4. Na caixa Location, insira o nome da pasta onde você deseja manter as páginas do seu site.

Por exemplo, digite o C:\WebSites nome da pasta.

Visual Studio 135

5. Na lista Language, clique na linguagem de programação que você preferir trabalhar.

6. Clique em OK.


Criando um arquivo XML para dados corporativos

No procedimento a seguir, você criará um arquivo XML simples para os dados de componentes Business.

Para criar o arquivo XML

1. No Solution Explorer, clique com o botão direito do mouse App_Data, e então clique em Add New Item.

Observação

Certifique-se de que você criou o arquivo XML na pasta App_Data. A pasta App_Data tem as permissões definidas sobre ela que permitirá que a página da Web leia e grave dados para o arquivo XML.

2. Em Visual Studio installed templates, clique em XML file.

3. Na caixa Name, digite Authors.xml.

4. Clique em Add.

Um novo arquivo XML é criado que contém somente a diretiva XML.

5. Copie os seguintes dados XML, e cole-o para o arquivo, sobrescrevendo o que já estiver no arquivo.

O arquivo XML inclui informações de esquema que identifica a estrutura do banco de dados dos dados, incluindo uma restrição de chave primária para a chave.

Observação

Componentes Business podem trabalhar com dados em qualquer forma que seja adequada para seu aplicativo. Esta explicação passo a passo usa um arquivo XML.

<?xml version="1.0" standalone="yes"?> <dsPubs xmlns="http://www.tempuri.org/dsPubs.xsd">

<xs:schema id="dsPubs" targetNamespace="http://www.tempuri.org/dsPubs.xsd"

xmlns:mstns="http://www.tempuri.org/dsPubs.xsd"

xmlns="http://www.tempuri.org/dsPubs.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema"

xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" attributeFormDefault="qualified"

elementFormDefault="qualified"> <xs:element name="dsPubs" msdata:IsDataSet="true">

<xs:complexType> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element

name="authors"> <xs:complexType> <xs:sequence> <xs:element name="au_id" type="xs:string"

/> <xs:element name="au_lname" type="xs:string" /> <xs:element name="au_fname"

type="xs:string" /> <xs:element name="au_phone" type="xs:string" /> </xs:sequence>

</xs:complexType> </xs:element> </xs:choice> </xs:complexType> <xs:unique

name="Constraint1" msdata:PrimaryKey="true"> <xs:selector xpath=".//mstns:authors" />

<xs:field xpath="mstns:au_id" /> </xs:unique> </xs:element> </xs:schema> <authors>

Visual Studio 136

<au_id>172-32-1176</au_id> <au_lname>West</au_lname> <au_fname>Paul</au_fname>

<au_phone>408 555-0123</au_phone> </authors> <authors> <au_id>213-46-8915</au_id>

<au_lname>Gray</au_lname> <au_fname>Chris</au_fname> <au_phone>415 555-

0120</au_phone> </authors> </dsPubs>

6. Salve o arquivo Authors.xml, e feche-o.

Criando um componente

A próxima etapa é para criar uma classe para atuar como o seu componente de negócios. Você irá manter o componente na pasta App_Code do site da Web. Em um aplicativo real, você pode manter o componente em qualquer armazenamento conveniente, incluindo o cache global de assemblies. Se seu site não tiver uma pasta chamada App_Code, você deve criar uma.

Para criar uma pasta App_Code • No Solution Explorer, clique com o botão direito do mouse no nome de seu

site, clique Add ASP.NET Folder, e em seguida, clique em App_Code.

Observação

A pasta deve ser nomeada App_Code.

Agora você poderá adicionar o componente ao seu site.

Para criar o componente Business

1. Na Solution Explorer, clique com o botão direito do mouse, na pasta App_Code e clique Add New Item.

Observação

Certifique-se de criar o novo item na pasta App_Code.

2. A caixa de diálogo Add New Item aparece.

3. Em Visual Studio installed templates, clique em Class.

4. Na caixa Language, clique na linguagem de programação que você preferir.

5. Na caixa Name, digite BusinessObject.

6. Clique em Add.

O Visual Web Developer cria o novo arquivo de classe e abre o editor de códigos.

7. Copie o seguinte código, e cole-o para o arquivo, sobrescrevendo o que já estiver no arquivo.

C# using System; using System.Web; using System.Data; namespace PubsClasses { public class

AuthorClass { private DataSet dsAuthors = new DataSet("ds1"); private String filePath =

HttpContext.Current.Server.MapPath ("~/App_Data/Authors.xml"); public AuthorClass() {

dsAuthors.ReadXml (filePath, XmlReadMode.ReadSchema); } public DataSet GetAuthors () {

return dsAuthors; } } }

Visual Studio 137

Observação

Certifique-se de que o valor da variável filePath referencia o nome do arquivo XML que você criou anteriormente.

Quando uma instância da classe é criada, ele lê o arquivo XML e converte em um DataSet. A classe do método GetAuthors retorna o DataSet.

8. Salve o arquivo. Você deve salvar o arquivo para que a próxima seção funcione corretamente.

Exibindo dados usando o componente Business

Você pode chamar o componente Business em uma página da Web e exibir seus dados. Para referenciar o componente, use um controle ObjectDataSource, que está especificamente projetado para trabalhar com objetos.

Para criar um controle ObjectDataSource que referencia o componente

1. Alterne para ou abra a página Default.aspx.

Observação

Se você não tem uma página Default.aspx, você pode usar outra página. Como alternativa, você pode adicionar uma nova página para o site. No Solution Explorer, clique com o botão direito do mouse no nome do site, clique em Add New Item, e adicione. um Web Form

2. Alterne para modo Design.

3. No Toolbox, a partir da pasta Data, arraste um controle ObjectDataSource para dentro da página.

4. Na janela Properties, definida ID como AuthorsObjectDataSource.

5. Clique com o botão direito do mouse no controle ObjectDataSource e em seguida, clique na marca inteligente para exibir o Menu ObjectDataSource Tasks.

6. No menu ObjectDataSource Tasks, clique em Configure Data Source.

O assistente Configure Data Source aparece.

7. Na lista Choose your business object, clique PubsClasses.AuthorClass.

8. Clique em Next.

9. Na guia Select, na lista Choose a method, clique em GetAuthors(), returns Dataset.

O método GetAuthors é definido na classe Business criada anteriormente. Ele retorna um DataSet contendo os dados do arquivo Authors.xml.


As informações de configuração que você inseriu especificam que para obter dados do componente, o método GetAuthors do componente deve ser chamado.

Agora você pode obter dados do componente usando o controle ObjectDataSource. Você irá exibir os dados em um controle GridView na página.

Visual Studio 138

Para exibir dados do componente

1. No Toolbox, a partir da pasta Data, arraste um controle GridView para a página.

2. Clique com o botão direito do mouse no controle GridView e clique na marca inteligente se o Menu Common GridView Tasks não estiver aparecendo.

3. No menu Common GridView Tasks, na caixa Choose Data Source, clique em AuthorsObjectDataSource.


O controle GridView é exibido com o dados XML dentro dele.

Inserindo dados usando o componente Business

Como em outros controles de fonte de dados, como o Controle SqlDataSource , o Controle ObjectDataSource suporta atualização (inserir, atualizar e excluir). Nesta seção, você modificará o componente Business com um método que insere um registro autor. Então, você irá alterar a página para que os usuários possam digitar novas informações de autor e modificar o controle ObjectDataSource para executar a inserção.

Observação

Durante esta parte da explicação passo a passo, o arquivo Authors.xml que você criou anteriormente será atualizado. É importante que o aplicativo tenha permissão para gravar no arquivo em tempo de execução ou a página da Web exibirá um erro quando você tentar atualizar o arquivo. Se você tiver criado o arquivo Authors.XML na pasta App_Data, as permissões são definidas automaticamente.

Para modificar o componente Business para permitir inserção

1. Alterne para o arquivo BusinessObject.

2. Adicione o seguinte método como o membro final do AuthorClass.

C# public void InsertAuthor (String au_id, String au_lname, String au_fname, String au_phone) {

DataRow workRow = dsAuthors.Tables[0].NewRow (); workRow.BeginEdit (); workRow[0] =

au_id; workRow[1] = au_lname; workRow[2] = au_fname; workRow[3] = au_phone;

workRow.EndEdit (); dsAuthors.Tables[0].Rows.Add (workRow); dsAuthors.WriteXml (filePath,

XmlWriteMode.WriteSchema); }

Observação

Preste atenção para os nomes das variáveis usadas para passar informações do autor para o método Close (au_id, au_lname e au_phone, au_fname ). Eles devem corresponder aos nomes de coluna definidos no esquema do arquivo XML criado anteriormente.

O novo método tem quatro valores para inserir, que você irá fornecer na página como parâmetros. O método cria uma nova linha no DataSet, e grava o DataSet atualizado de saída como um arquivo XML.

3. Salve o arquivo.

Visual Studio 139

A próxima etapa é alterar a página para que os usuários possam inserir novas informações de autor. Para o procedimento seguinte, você irá usar o controle DetailsView .

Para adicionar um controle para inserir dados



3. Em Toolbox, a partir da pasta Data, arraste um controle DetailsView para a página.

Observação

O leiaute exato da página não é importante.

4. No menu DetailsView Tasks, na caixa Choose Data Source, clique em AuthorsObjectDataSource.

Observação

Se não estiver visível, no menu DetailsView Tasks clique na marca inteligente.

5. Na janela Properties, defina AutoGenerateInsertButton como true.

Isso faz com que o controle DetailsView processe um botão New que os usuários podem clicar para colocar o controle no modo de entrada de dados.

Finalmente, você deve configurar o controle ObjectDataSource para especificar qual ação o controle deve executar para inserir dados.

Para configurar o controle da fonte de dados para inserir dados • Clique com o botão direito do mouse AuthorsObjectDataSource, clique em

Properties, e defina InsertMethod para InsertAuthor.

Este é o nome do método adicionado para o componente Business.

Agora você pode inserir novos autores no arquivo XML.

Para testar a inserção

1. Pressione CTRL+F5 para executar a página Default.aspx.

2. No controle DetailsView, clique no botão New.

O controle é reexibido com caixas de texto.

3. Insira novas informações de autor, e clique Insert.

As novas informações de autor são adicionadas ao arquivo XML. O controle GridView imediatamente reflete o novo registro.

Próximas etapas

Esta explicação passo a passo ilustra como trabalhar com um componente de dados. Você pode desejar testar recursos adicionais de navegação. Por exemplo, você pode desejar:

• Adicionar funcionalidades de atualização e exclusão . Para fazer isso, adicione métodos ao componente. Isso é semelhante a lógica usada para adicionar a inserção — você adiciona um método ao componente, configura o controle da

Visual Studio 140

fonte de dados para chamar o método componente, adiciona parâmetros apropriados, e adiciona uma linha de código para chamar os métodos Update e Delete do controle da fonte de dados. Para obter detalhes, consulte Passo-a-passo: Editando e Inserindo Dados com o controle DetailsView do servidor Web

• Alterar o componente Business para trabalhar com dados de banco de dados em vez de com um arquivo XML. Você não precisa fazer qualquer alteração aos controles na página.

• Restringir quais usuários podem fazer alterações aos dados. Um método comum é adicionar membros e funções ao seu site, e depois estabelecer regras que o componente Business pode verificar antes de permitir as alterações feitas nos dados. Para obter detalhes, consulte Passo-a-passo: Criando um site com associações e logon de usuário (Visual Studio) e Passo-a-passo: Gerenciando Usuários de Sites da Web com Papéis.

Visual Studio 141

Explicação passo a passo: depuração de páginas da Web no Visual Web Developer O Visual Web Developer fornece ferramentas para ajudar a rastrear erros em suas páginas da Web do ASP.NET. Nesta explicação passo a passo, você trabalhará com o depurador, o qual permite que você execute o código da página linha por linha e examine os valores das variáveis.

Nesta explicação passo a passo, você criará um página da Web que contém uma calculadora simples que eleva um número ao quadrado. Após criar a página (que incluirá um erro deliberadamente), você usará o depurador para examinar a página enquanto esta estiver sendo executada.

Tarefas ilustrado nesta explicação passo a passo incluem:

• Definir pontos de interrupção.

• Chamar o depurador a partir de um página Web Forms em um site no sistema de arquivos.

Pré-requisitos

Para concluir este explicação passo a passo, serão necessários:

• Visual Web Developer e o .NET Framework.

Você também deve ter uma compreensão geral de como trabalhar no Visual Web Developer. Para uma introdução ao Visual Web Developer, consulte Explicação passo a passo: Criando uma página da Web básica no Visual Web Developer.

Criar página e site da Web

Na primeira parte da explicação passo a passo, você criará uma página que você pode depurar.

Se você já criou um site no Visual Web Developer (por exemplo, por ter seguido o tópico Explicação passo a passo: Criando uma página da Web básica no Visual Web Developer), você pode usar o site criado e pular para "Adicionando controles para depuração" a seguir nesta explicação. Caso contrário, crie um novo site e página seguindo estes passos.

Para criar um site no sistema de arquivos


2. No menu File, clque em New Web Site.

A caixa de diálogo New Web Site aparecerá.


4. Na caixa Location, clique em File System e digite o nome da pasta onde você deseja manter as páginas do seu site.

Por exemplo, digite o nome da pasta C:\WebSites.

5. Na lista Language clique na linguagem de programação que você preferir para trabalhar.

O linguagem de programação que você escolher será o padrão para seu site. Entretanto, você pode usar várias linguagens no mesmo aplicativo da Web, criando páginas e componentes em linguagens de programação diferentes. Para obter informações sobre como criar componentes usando diferentes

Visual Studio 142

linguagens, consulte Compartilhada pastas código em sites da Web do ASP.NET.

6. Clique em OK.


Criando uma página para depuração

Você começará criando uma nova página. Para esta explicação passo a passo, é importante que você crie uma nova página conforme especificado no procedimento a seguir.

Para adicionar uma página ao site

1. Feche a página Default.aspx.

2. No Solution Explorer, clique com o botão direito do mouse no nome do seu site (por exemplo, C:\WebSite) e escolha Add New Item.

3. Em Visual Studio installed templates, escolha Web Form.

4. Na caixa Name, digite DebugPage.aspx.

5. A partir da lista Language, escolha a linguagem de programação que você preferir usar.

6. Certifique-se que a caixa de seleção Place code in separate file está desmarcada.

Nesta explicação passo a passo, você está criando uma página em um único arquivo com o código e HTML na mesma página. O código para páginas ASP.NET pode estar localizado na página ou em um arquivo de classe separado. Para saber mais sobre como manter o código em um arquivo separado, consulte Explicação passo a passo: Criando uma página da Web básica com separação de código no Visual Web Developer.

7. Clique em Add.

O Visual Web Developer cria a nova página e a abre no modo de fonte.

Você pode agora adicionar alguns controles à página e depois adicionar código. O código será simples, mas suficiente para permitir que você adicione pontos de interrupção posteriormente.

Para adicionar controles e código para depuração

1. Mude para o modo de exibição Design e depois da pasta Standard para a pasta Toolbox, arraste então os seguinte controles para a página:

Controle Propriedades

Label ID: CaptionLabel Text: (empty)

TextBox ID: NumberTextBox Text: (empty)

Button ID: SquareButton Text: Square

Label ID: ResultLabel Text: (empty)

Observação

Visual Studio 143

O layout da página para esta explicação passo a passo, não é importante.

2. Clique duas vezes no controle Button role para criar um manipulador Click para ele.

3. Adicione lógica ao manipulador Click para chamar uma função chamada Square para elevar o número digitado pelo usuário ao quadrado. O manipulador deve se parecer com o exemplo a seguir.

Observação

O exemplo de código deliberadamente não inclui a verificação de erros.

C# protected void SquareButton_Click(object sender, System.EventArgs e) { int number, result; number =

System.Convert.ToInt32(NumberTextBox.Text); result = Square(number); ResultLabel.Text =

NumberTextBox.Text + " squared is " + result.ToString(); }

4. Crie a função que eleve o número ao quadrado. Inclua um erro no código que adicione o número a si mesmo em vez de multiplicar. O código deve se parecer com o exemplo a seguir.

C# int Square(int number ) { int Square; Square = number + number; return Square; }

Você também pode adicionar código na página para alterar o texto do rótulo dependendo se esta for a primeira vez que a página está sendo executada.

Para alterar a legenda do controle Label 1. No modo de exibição Design, clique duas vezes na superfície de design (não

no controle) para criar um manipulador de eventos Page_Load.

2. Defina o texto do controle Caption Label como Enter a number: se esta for a primeira vez a página está em execução, ou Enter another number: caso contrário. O manipulador deve se parecer como o exemplo de código a seguir.

C# if(Page.IsPostBack == false) { CaptionLabel.Text = "Enter a number: "; } else { CaptionLabel.Text

= "Enter another number: " ; }

Teste a página

Para certificar-se que a página está funcionando, execute-a em seu estado atual.


1. Salve a página.


3. Digite um número (diferente de 2) e pressione o botão Square.

Observe que o resultado é incorreto, porque há um erro no programa.


Depurando a página

Visual Studio 144

Nesta parte da explicação passo a passo, você usará o depurador para examinar o código da página linha por linha ao ser executado, adicionar pontos de interrupção no código e executar a página no modo Debug.

Inicialmente, você definirá pontos de interrupção em seu código. Um ponto de interrupção é uma linha em seu código onde a execução pára e o depurador é chamado.

Para definir pontos de interrupção

1. Mude para o modo de visualização Source.

2. Clique com o botão direito do mouse na linha a seguir, escolha Breakpoint, e escolha Insert Breakpoint.

Observação

Você pode habilitar e desabilitar pontos de interrupção, pressionando F9.

C# if(Page.IsPostBack == false)

3. Defina outro ponto de interrupção para a linha a seguir do manipulador SquareButton_Click:

C# result = Square(number);

Observação

Você não pode definir um ponto de interrupção em uma instrução que declara uma variável.

Com pelo menos um ponto de interrupção, você estará pronto para executar o depurador.

Para executar o depurador 1. A partir do menu Debug escolha Start Debugging (ou pressione F5) para

executar a página no modo de depuração.

Se você nunca tiver executado o depurador antes, seu aplicativo provavelmente não estará configurado para oferecer suporte a depuração. Por padrão, depuração é desativada em aplicativos por questões de desempenho (páginas executam mais lentamente no depurador) e por razões de segurança. O Visual Web Developer exibe uma mensagem informando a você o que deve fazer para ativar a depuração.

A opção para ativar a depuração é armazenada como uma configuração no arquivo Web.config, que mantém várias opções de configuração específicas do site. Se o arquivo Web.config não existir, o Visual Web Developer vai tanto criar o arquivo quanto realizar a configuração apropriada do depurador.

Se o arquivo Web.config já existe mas a depuração não estiver ativada, você verá uma mensagem ligeiramente diferente informando que o Visual Web Developer irá modificar o arquivo Web.config.

2. Se você vir a mensagem informando que depuração não está ativada, clique OK para ativar a depuração.

Visual Studio 145

No Visual Web Developer, o designer altera para modo de depuração exibindo o código para a página e algumas janelas de depuração.

O depurador executa sua página linha por linha. Quando o depurador chega na linha com o ponto de interrupção, ele para e realça a linha.

Como o ponto de interrupção está no manipulador Page_Load, a página ainda não terminou de ser processada. O navegador está aberto, mas a página não será exibida ainda.

3. No menu Debug, clique em Windows, clique em Watch e em seguida, clique em Watch 1

Observação

Se você estiver usando o Visual Web Developer Express Edition, o depurador oferece apenas uma única janela Watch.

4. Isso abre uma janela Watch onde você pode especificar os valores que você deseja rastrear.

5. No editor, clique com o botão direito do mouse na parte IsPostBack da expressão Page.IsPostBack e clique Add Watch.

Isso adiciona a expressão na janela Watch e exibe o valor atual da propriedade (false) é exibida na coluna Value. Se você preferir, você pode digitar o nome de uma variável ou propriedade na coluna Name da janela Watch.

6. A partir do menu Debug, escolha Continue para continuar a execução, ou pressione F5.

O comando Continue informa o depurador para continuar até que ele chegue no próximo ponto de interrupção. O manipulador de eventos Page_Load termina o processamento e a página é exibida no navegador.

7. Insira o valor 2 na caixa de texto e clique o botão Square.

O depurador será exibido novamente, com o ponto de interrupção na linha no manipulador Page_Load. Neste momento, a janela Watch mostra que o valor de Page.IsPostBack é true.

8. Pressione F5 novamente para continuar.

O depurador processa o manipulador Page_Load e entra no manipulador SquareButton_Click, onde ele para no segundo ponto de interrupção que você definiu.

9. No menu Debug, clique em Windows e clique Locals.

Isso abre a janela Locals, que exibe os valores de todas as variáveis e objetos que estão sendo no escopo da linha sendo executada. A janela Locals fornece uma maneira alternativa para você exibir esses valores, com a vantagem de que você não precisa definir explicitamente um observador para os elementos, mas com a desvantagem de que a janela pode conter mais informações do que você deseja ver.

Na janela Locals, você vê que o valor de number é 2 e o valor de result é 0.

Observação

Visual Studio 146

Você também pode ver o valor de qualquer variável no programa, mantendo o ponteiro do mouse sobre ela.

10. Na coluna Value da janela Locals, clique com o botão direito do mouse na linha para a variável number e selecione Edit value. Edite o valor da variável number e altere-o para 5.

O valor 2 para a variável number não é um bom teste do programa, como tanto adicionar quanto elevar 2 a 2 resulta em 4. Portanto, enquanto o programa está sendo executado, você pode alterar o valor dessa variável.

11. A partir do menu Debug, escolha Step Into para entrar na função Square, ou pressione F11.

O comando Step Into faz com que o depurador execute uma linha e depois interrompa novamente.

12. Continue a depuração pressionando F11 até chegar a linha de código a seguir.

C# ResultLabel.Text = NumberTextBox.Text + " squared is " + result.ToString();

O depurador percorre seu código linha por linha. Quando o depurador executa a função Square, você pode usar a janela Locals para verificar os dados passados para a função (number) e o valor de retorno da função (Square).

13. No menu Debug, clique em Windows e Immediate.

A janela Immediate permite que você execute comandos. Você pode usar a janela para avaliar expressões (por exemplo, para obter o valor de uma propriedade).

14. Na janela Immediate, digite a expressão a seguir e pressione ENTER. ? NumberTextBox.Text

O ponto de interrogação (?) é um operador na janela Immediate que avalia a expressão que o segue. No exemplo, você está avaliando a propriedade Text do controle NumberTextBox na página. Você pode avaliar qualquer variável, propriedade de objeto ou expressão que combinem essas, usando a mesma sintaxe que você usaria em código.

15. Na janela Immediate, digite o seguinte e pressione ENTER: NumberTextBox.Text = "5"

Além de avaliar expressões, a janela Immediate permite que você altere variáveis ou propriedades

16. Pressione F5 para continuar a execução do programa.

Quando a página aparecer, ela exibe o resultado de passar 5 para a função Square. Além disso, o texto na caixa de texto foi alterado para 5.

O resultado que você vê —10— é incorreto , já que 10 não é o quadrado de 5. Você pode agora corrigir o erro.

Para corrigir o erro e testar novamente

1. Mude do navegador para o Visual Web Developer.

Visual Studio 147

Observação

Não feche o janela do navegador.

2. Na função Square, altere o operador "+" para o operador "*".

Como o código não está em execução (a página terminou de ser processada), você está em modo de edição e pode fazer alterações permanentes.

3. Pressione CTRL+S para salvar a página.

4. A partir do menu Debug, escolha Delete All Breakpoints para que a página não pare a cada vez que for executada.

Observação

Você também pode limpar os pontos de interrupção, pressionando as teclas CTRL+SHIFT+F9.

5. Mude para o janela do navegador.

6. Insera 5 na caixa de texto e clique o botão.

Desta vez, quando você executar a página e inserir um valor, ele é elevado ao quadrado corretamente. As alterações temporárias que você fez anteriormente, como alterar a propriedade Text do controle NumberTextBox, não foram persistentes, porque eles se aplicavam somente quando a página foi executada da última vez.

7. Feche o navegador para interromper o depurador.

Próximas etapas

O depurador inclui recursos adicionais para ajudá-lo a trabalhar com seu código. Além disso, talvez você queira aprender sobre técnicas para manipular condições de erro e formas em que você pode monitorar o processamento de página em tempo de execução. Por exemplo, talvez você queira explorar o rastreamento. Para obter detalhes, consulte Explicação passo a passo: Usando rastreamento no Visual Web Developer para ajudar a localizar erros em página da Web.

Visual Studio 148

Passo-a-passo: Criando e usando Páginas Mestras do ASP.NET no Visual

Web Developer Esta explicação passo-a-passo ilustra como criar uma página mestra e diversas páginas de conteúdo. Páginas mestras permitem que você crie um layout de página — uma página modelo — e então crie páginas separadas contendo o conteúdo que será mesclado com a página mestra em tempo de execução. Para obter mais informações sobre páginas mestras, consulte Visão Geral sobre Páginas Mestras no ASP.NET .

Tarefas ilustrado esta explicação passo a passo incluem:

• Criando uma página mestra no Microsoft Visual Web Developer .

• Criando uma página ASP.NET com conteúdo que você deseja exibir na página mestra.

• Executando páginas mestras para mostrar um conteúdo diferente.

• Selecionando uma página mestra em tempo de execução.

Pré-requisitos


• Visual Web Developer (Visual Studio).


• Opcionalmente, um.jpg, .gif, ou outro arquivo gráfico que você possa usar como um logotipo em sua página mestra. É recomendável que o logotipo não seja maior do que 48 pixels de largura. Entretanto, a exibição de um logotipo é opcional e o tamanho exato do gráfico não será importante para a explicação passo a passo.

Criando um site da Web

Se você já tiver criado um site no Visual Web Developer (por exemplo, seguindo as etapas do Passo-a-passo: Criando uma página básica da Web em Visual Web Developer), você pode usar esse site e vá para a próxima seção, "Criando a Página mestra.". Caso contrário, crie um novo site e página seguindo estas etapas.








5. Na lista Language, clique a linguagem de programação em que você preferir para trabalhar.

6. Clique em OK.

Visual Studio 149


Criando a página mestra

A página mestra é o modelo de como será o aspecto de suas páginas. Nesta seção, você primeiro criará um página mestra. Então, você irá usar uma tabela para formatar a página mestra com um menu, um logotipo, e um rodapé que será exibido em cada página do seu site. Você também vai trabalhar com um espaço reservado de conteúdo, que é uma região na página mestra que pode ser substituída por informações em uma página de conteúdo.

Para criar a página mestra

1. No Solution Explorer, clique com o botão direito do mouse no nome do seu site, e então clique Add New Item.

2. Em Visual Studio installed templates, clique em Master Page.

3. Na caixa Name, digite Master1.

4. Selecione a caixa de seleção Place code in separate file .

Observação

Esta explicação passo-a-passo assume que você está usando arquivos code-behind para todas as páginas. Se você estiver usando uma página ASP.NET Single-file, o código ilustrado nesta explicação passo-a-passo irá funcionar, mas aparecerá no modo de origem, não em um arquivo separado de código

5. Na lista Language, clique na linguagem de programação que você preferir e clique Add.

A nova página mestra abre no modo de origem.

Na parte superior da página está uma declaração @ Master em vez de uma declaração @ PAGE normalmente encontrada na parte superior de páginas ASP.NET. O corpo da página contém um controle <asp:contentplaceholder>, que é a área da página mestra onde os conteúdo substituíveis serão mesclados nas páginas de conteúdo em tempo de execução. Você irá trabalhar mais com o espaço reservado de conteúdo posteriormente nesta explicação passo-a-passo.

Dispondo a Página Mestra

A página mestra define como as páginas no seu site aparentam. Ela pode conter qualquer combinação de textos estáticos e controles. Uma página mestra também contém um ou mais espaços reservados de conteúdo que designam onde o conteúdo dinâmico aparecerá quando as páginas forem exibidas.

Nesta explicação passo a passo, você irá usar uma tabela para ajudar você a posicionar elementos na página. Você iniciará criando uma tabela de layout para armazenar os elementos da página mestra. Posteriormente, nesta seção, irá posicionar o controle de espaço reservado de conteúdo que já estiver na página.

Para criar uma tabela de layout para a página mestra

1. Com o arquivo Master1.Master selecionado no modo de exibição de origem, defina o esquema de destino para validação para o Microsoft Internet Explorer 6.0. Para definir esse valor, você pode usar tanto a lista suspensa na caixa de ferramentas ou selecionar Options a partir do menu Tools, e clicar em Validation.

Visual Studio 150

2. Alternar para modo Design.

3. A partir da Lista suspensa na parte superior da janela Propriedades, selecione DOCUMENT, e defina BgColor para uma cor diferente, como azul.

A cor selecionada não é importante. Posteriormente nesta explicação passo-a-passo você criará uma segunda página mestra sem uma cor para comparar com aquilo que você está selecionando aqui.

4. Clique na página onde você deseja colocar a tabela de layout.

Observação

Não coloque a tabela de layout dentro do Controle ContentPlaceHolder.

5. No menu Layout, clique em Insert Table.

6. Na caixa de diálogo Insert Table , clique em Template. Na lista cliquem em Header, footer and side, e clique OK.

O modelo define a organização de linhas e células na tabela. O modelo que você selecionou cria três linhas, e a linha central é dividida em duas células.

7. Faça as seguintes configurações: o Na linha do meio, clique na coluna mais à esquerda, e defina seu

Width como 48 na janela Properties. o Clique na primeira linha, e defina seu Height como 48 na janela

Properties. o Clique na linha inferior, e defina seu Height como 48 na janela

Properties.

Observação

Você pode definir a largura e altura arrastando as bordas de célula da tabela ou selecionando a célula e definindo valores na janela Properties.

8. Selecione todas as células na tabela e defina BgColor como uma cor diferente do que a cor do plano de fundo, e defina VAlign como top.

Após definir o layout a tabela, você pode adicionar conteúdo para a página mestra que aparecerá em todas as páginas. Você irá adicionar uma mensagem de direitos autorais como um rodapé, e adicionar um menu. Se tiver um gráfico de logotipo disponível, você poderá adiciona-lo também.

Para adicionar conteúdo estático para a página mestra

1. Clique na célula inferior e digite o texto rodapé como Copyright 2005 Contoso Inc.

2. Na Toolbox, a partir do grupo de controle Navigation, arraste um controle de Menu para a célula superior.

3. Crie um menu seguindo estas etapas:

1. Defina a propriedade do controle do Menu Orientation como Horizontal.

Visual Studio 151

2. Clique na marca inteligente no controle do Menu, e clique Edit Menu Items na caixa de diálogo Menu Tasks.

4. Em Items, clique duas vezes no ícone Add a root node para adicionar dois itens de menu :

1. Clique no primeiro nó, e defina Text como Home e NavigateUrl como Home.aspx.

2. Clique no segundo nó, e defina Text como About e NavigateUrl como About.aspx.

3. Clique OK para fechar a caixa de diálogo Menu Item Editor.

5. Se você tiver um arquivo gráfico disponível para uso como um logotipo, siga estas etapas para colocá-lo na página mestra:

1. Na Solution Explorer, clique com o botão direito do mouse no nome do site, e clique Add Existing Item.

2. Navegue para o arquivo gráfico, selecione o arquivo gráfico, e então clique Add.

3. Na Toolbox do grupo Standard, arraste um controle de Image para a coluna do esquerda no meio de tabela.

4. Definida a propriedade do controle da Imagem ImageUrl com o nome do arquivo gráfico.

Agora você pode posicionar o espaço reservado de conteúdo para especificar onde a página mestra pode exibir conteúdo em tempo de execução.

Para adicionar um espaço reservado de conteúdo

1. Arraste o controle ContentPlaceHolder para a célula à direita do meio.

A Propriedade ID do controle é ContentPlaceholder1. Você pode deixar esse nome ou alterá-lo. Se você alterar o nome, certifique-se de anotar o nome porque você precisará saber o nome mais tarde.

2. Salvar a página.

Criando Conteúdo para a Página Mestra

A página mestra fornece o modelo para o seu conteúdo. Você define o conteúdo para a página mestra, criando uma página ASP.NET que está associada com a página mestra. A página de conteúdo é uma forma especializada de uma página ASP.NET que contém somente o conteúdo a ser mesclado com a página mestra. Na página de conteúdo, você adiciona o texto e os controles que você deseja exibir quando os usuários solicitarem essa página.

Nesta explicação passo a passo, você irá adicionar duas páginas com conteúdo para a página mestra. A primeira é uma Home Page e a segunda é uma página do tipo Sobre.

Para criar a Home Page

1. No Solution Explorer, clique com o botão direito do mouse no nome do site, e clique em Add New Item.

2. Em Visual Studio installed templates, clique em Web Form.

3. Na caixa Name, digite Home.

4. Na lista Language, clique na linguagem de programação que você preferir.

5. Selecione a caixa de seleção Select master page, e clique Add.

Visual Studio 152

A caixa de diálogo Select a Master Page aparece.

6. Clique em Master1.master, e clique OK.

Um novo arquivo.aspx é criado. A página contém uma diretiva @ PAGE que conecta a página atual com a página mestra selecionada com o atributo MasterPageFile, como mostrado no seguinte exemplo de código.

C# <%@ Page Language="C#" MasterPageFile="~/Master1.master" ... %>

A página também contém um elemento <asp:Content> com que você irá trabalhar a seguir.

Uma página de conteúdo não tem os elementos usuais que compõem uma página ASP.NET, como os elementos html, body, ou form. Em vez disso, você adiciona somente o conteúdo que você deseja exibir na página mestra, substituindo as regiões do espaço reservado que você criou na página mestra.

Para adicionar conteúdo para a Home Page

1. Alterne para o modo Design.

A região que você criou como um controle ContentPlaceHolder na página mestra é exibida como um Controle de Conteúdo na nova página de conteúdo. Todo o conteúdo restante da página mestra é exibido, portanto você pode ver o layout, mas ele aparece esmaecido porque você não poderá alterá-lo ao editar uma página de conteúdo.

2. Da lista suspensa na janela Properties, clique em DOCUMENT, e defina Title para Home Page de Contoso.

Você pode definir o título de cada página de conteúdo independentemente, de forma que o título correto é exibido no navegador quando o conteúdo é mesclado com a página mestra. As informações de título são armazenadas na diretiva @ Page da página de conteúdo.

3. No Controle Content, digite Welcome to the Contoso Web Site, selecione o texto, e em seguida, formate o texto como Heading 1 selecionando o texto e então selecionando Heading 1 da lista suspensa Block Format acima da Toolbox.

4. Pressione ENTER para criar uma nova linha vazia no controle Content, e em seguida, digite Obrigada por visitar nosso site.

O texto adicionado aqui não é importante; você pode digitar qualquer texto que o ajudará a reconhecer esta página como a home page.

5. Salve a página.

Você pode criar a página Sobre da mesma forma que você criou a Home Page.

Para criar a página Sobre

1. Use as mesmas etapas que você usou para a Home Page para adicionar uma nova página de conteúdo chamada About.aspx.

Certifique-se de anexar a nova página à página Master1.Master como fez com a Home Page.

2. Altere o título da página para Página Sobre Contoso.

Visual Studio 153

3. Na região de conteúdo, digite Sobre Contoso, e em seguida, formate o texto como um Heading 1, selecionando o texto e selecionando Heading 1 do Block Format da lista suspensa acima do Toolbox.

4. Pressione ENTER para criar uma nova linha, e digite Desde 1982, Contoso provê serviços de software de alta qualidade.

5. Salve a página.

Testando as páginas

Você pode testar as páginas, executando-as como você faria com qualquer página ASP.NET.

Para testar as páginas

1. Alterne para a página Home.aspx, e pressione CTRL+F5.

O ASP.NET mescla o conteúdo da página Home.aspx com o layout na página Master1.master em uma única página e exibe a página resultante no navegador. Observe que a URL da página é Home.aspx; não há nenhuma referência no navegador para a página mestra.

2. Clique no link Sobre.

A página About.aspx é exibida. Ela também será mesclada com a página Master1.MASTER.

Referenciando Membros da Página Mestra

Código em páginas de conteúdo podem referenciar membros da página mestra, incluindo quaisquer propriedades pública ou métodos e os controles da página mestra. Nesta parte da explicação passo a passo você irá criar uma propriedade na página mestra, e em seguida, usar o valor da propriedade nas páginas de conteúdo. A premissa é que o nome da empresa do site está armazenado como uma propriedade na página mestra, e qualquer referência para o nome da empresa nas páginas de conteúdo é baseada na propriedade da página mestra.

A primeira etapa é adicionar uma propriedade para a página mestra.

Para adicionar uma propriedade à página mestra

1. Alterne para, ou abra, a página Master1.MASTER.

2. Na Solution Explorer, clique com o botão direito do mouse em Master1.master, e clique View Code Para abrir o editor de códigos.

Observação

Por padrão, o Visual Web Developer cria páginas que usam o modelo code-behind. Se você preferir, você pode criar código usando o modelo Single-File. Para mais informações, consulte Modelo de Código de Página Web do ASP.NET.

3. Dentro da definição de classe, digite o código a seguir.

C# public String CompanyName { get { return (String) ViewState["companyName"]; } set {

ViewState["companyName"] = value; } }

O código cria uma propriedade chamada CompanyName para a página mestra. O valor é armazenado no estado da exibição para que ele seja persistentes entre postbacks.

Visual Studio 154

4. Dentro da definição da classe (mas não dentro do código da propriedade), adicione o seguinte código.

C# void Page_Init(Object sender, EventArgs e) { this.CompanyName = "Contoso"; }

Para esse exemplo, você irá embutir em código o valor da propriedade CompanyName para a página.

Agora você pode modificar o página de conteúdo para usar a propriedade CompanyName da página mestra.

Para referenciar a propriedade CompanyName na página de conteúdo

1. Alterne para, ou abra, a página Home.aspx.

2. Alterne para modo de origem.

3. Na parte superior da página, sob a diretiva @ PAGE, adicione a seguinte diretiva @ MasterType : <%@ MasterType virtualpath="~/Master1.master" %>

A diretiva vincula a propriedade Master da página de conteúdo, que você irá usar logo, com a página Master1.Master.


5. No controle Content, altere o texto para Bem-vindo ao site de.

6. Na Toolbox do grupo Standard, arraste um controle Label para o controle Content, e coloque-o após o texto estático de forma que leia-se o texto:

Bem-vindo ao site de [label]

7. Defina a propriedade ID do controle do Label como CompanyName.

8. No Solution Explorer, clique com o botão direito do mouse em Home.aspx e clique View Code para abrir o editor de códigos.

9. Dentro da definição de classe, adicione o seguinte código.

C# void Page_Load(Object sender, EventArgs e) { CompanyName.Text = Master.CompanyName; }

A propriedade Master da página de conteúdo retorna uma referência para a página mestra conforme definido na diretiva @ MasterType adicionada na etapa 3.

Agora você pode testar a página de conteúdo para certificar-se de que ele está referenciando a propriedade CompanyName da página mestra corretamente.

Para testar a referência para a propriedade da página mestra

1. Alterne para, ou abra, a página Home.aspx, e pressione CTRL+F5 para executar a página.

A página é exibida no navegador, com o texto Bem-vindo ao site de Contoso


3. Alterne para, ou abra, a página code-behind Master1.MASTER.

4. Altere o manipulador Page_Init para atribuir um nome de empresa diferente para a propriedade, como no seguinte exemplo de código.

Visual Studio 155

C# void Page_Init(Object sender, EventArgs e) { this.CompanyName = "New Company Name"; }

5. Alterne para a página Home.aspx, e pressione CTRL+F5 para executá-la novamente.

Neste momento, o nome da empresa atualizado aparece na página

Anotações

Há várias outras questões que você deve estar ciente ao trabalhar com uma página mestra:

• Em um aplicativo real, provavelmente você iria armazenar informações como o nome da empresa no arquivo de configuração e lê-las diretamente nas páginas de conteúdo. No entanto, o cenário descrito aqui fornece uma ilustração simples de como fazer a referência a membros de página mestra nas páginas de conteúdo.

• Você pode acessar membros na página mestra mesmo sem incluir uma diretiva @ MasterType. Entretanto, para fazer isso, você deve fazer um cast da propriedade System.Web.UI.Page.Master para o tipo apropriado na página mestra (a propriedade Master é null se uma página não tiver nenhuma página mestra). Para mais informações, consulte Trabalhando com Páginas Mestras de ASP.NET Programaticamente.

• Você pode referenciar controles na página mestra, usando o método Master.FindControls. Para mais informações, consulte Trabalhando com Páginas Mestras de ASP.NET Programaticamente.

Alterando páginas mestras dinamicamente

Em algumas circunstâncias, convém poder alterar páginas mestras dinamicamente; ou seja, usar código para definir a página mestra para uma página de conteúdo. Por exemplo, talvez queira permitir que os usuários selecionem entre vários layouts e defina a página mestra de acordo com suas preferências.

Nesta parte da explicação passo a passo, você irá adicionar uma segunda página mestra ao site, e criar botões que permitem ao usuário alternar entre uma página mestra e outra. Porque as duas páginas mestras serão muito semelhante, você irá fazer uma cópia da primeiro página mestra e irá modificá-la para atuar como a segunda página mestra .

Para fazer uma cópia da página mestra

1. No Solution Explorer, clique com o botão direito do mouse em Master1.master, e clique Copy.

2. Clique com o botão direito do mouse no nome do site, e em seguida, clique em Paste

Uma página mestra é adicionada ao site a Web com o nome Copy of master1.master.

3. Clique com o botão direito do mouse em Copy of master1.master, clique em Rename, e denomine a nova página mestra como Master2.master.

4. Abra a Master2.Master e, na diretiva @ Master, altere Master1 para Master2.

A diretiva completa da página vai parecer com o exemplo de código a seguir.

C# <%@ Master Language="C#" CodeFile="Master2.master.cs" Inherits="Master2" %>

Visual Studio 156


6. Na janela Properties, na lista suspensa na parte superior, clique em DOCUMENT.

7. Desmarque a propriedade BgColor.

A nova página mestra terá o aspecto e funcionalidades como a Master1.master, mas não terá nenhuma cor de plano de fundo.

8. Abra o arquivo de código do Master2.Master e altere o nome da classe no arquivo code-behind da página mestra de Master1 para Master2 para corresponder ao valor do atributo Inherits na diretiva <%@ Master %> da página.

O código terá o aspecto como no exemplo a seguir.

C# public partial class Master2 : System.Web.UI.MasterPage

A próxima etapa é adicionar um botão para cada página mestra que permite ao usuário selecionar a página mestra alternativa.

Para adicionar botões para selecionar uma página mestra alternativa

1. Alterne para, ou abra, a página Master2.MASTER.

2. Na Toolbox, a partir do nó Standard, arraste um controle LinkButton para a página e coloque-o abaixo do menu na célula mais alta da tabela.

3. Defina a propriedade Text do botão como Colorful.

4. Clique duas vezes no botão para criar um manipulador para o Evento Click, e, em seguida, adicione o código realçado seguinte.

C# void LinkButton1_Click(Object sender, EventArgs e) { Session["masterpage"] = "Master1.master";

Response.Redirect(Request.Url.ToString()); }

O código carrega o nome da página mestra alternativa em uma variável de sessão persistente, e depois recarregue a página atual. (A propriedade Url retorna um objeto Uri que faz referência a página atual.) Em breve, você vai criar código na página de conteúdo que usará o nome da página mestra.

5. Alterne para, ou abra, a página Master1.Master no modo Design.

6. Adicione um controle LinkButton como você fez nas etapas 1 e 2, e defina sua propriedade Text como Plain.

7. Clique duas vezes no botão Plain para criar um manipulador para o Evento Click, e, em seguida, adicione o código realçado seguinte.

C# void LinkButton1_Click(Object sender, EventArgs e) { Session["masterpage"] = "Master2.master";

Response.Redirect(Request.Url.ToString()); }

Esse código é o mesmo que o usado para o botão na página Master2.master, exceto que ele carrega uma página mestra alternativa.

Agora você escreve o código na página de conteúdo que irá carregar dinamicamente a página mestra que o usuário tiver selecionado.

Visual Studio 157

Escrever código para selecionar a página mestra dinamicamente

1. Alterne para, ou abra, a página About.aspx.

Observação

A Home Page que você criou contém uma diretiva @ MasterType que efetivamente a vincula para uma única página mestra (Master1.MASTER). Portanto, não será possível atribuir páginas mestras dinamicamente para a Home Page e em vez disso você vai poder trabalhar com outras páginas que você tiver criado.

2. No Solution Explorer, clique com o botão direito do mouse em About.aspx e clique View Code para abrir o editor de códigos.

3. Dentro da definição da classe, adicione o seguinte código.

C# void Page_PreInit(Object sender, EventArgs e) { if(Session["masterpage"] != null) {

this.MasterPageFile = (String) Session["masterpage"]; } }

O código define o valor da propriedade MasterPageFile da página atual para o valor na variável de sessão, se houver. Este código deve executar no manipulador Page_PreInit; não pode ser executado em um manipulador que ocorre em qualquer momento posterior que o manipulador Page_PreInit (por exemplo, no manipulador Page_Init), porque a página mestra deve ser estabelecida para que a página possa criar uma instância dela antes de qualquer inicialização adicional possa ocorrer.

Agora você pode testar as páginas mestras dinâmicas.

Para testar as páginas mestras dinâmicas

1. Na página About.aspx, pressione CTRL+F5 para executar a página.

A página é exibida no navegador mesclada com sua página mestra padrão, Master1.MASTER.

2. Clique no link Plain .

A página é reexibida, neste momento mesclada com a Master2.master, que não tem nenhuma cor de plano de fundo.

3. Clique no link Colorful.

A página é exibida usando a Master1.Master novamente.

Anotações

Há várias outras questões que você deve estar ciente ao trabalhar com páginas mestras dinâmicas:

• O cenário desta seção para alterar páginas mestras é simplificada para manter a explicação passo a passo focalizada em páginas mestras. Em um aplicativo real, você provavelmente deve exibir uma escolha dos layouts, e então guardar a preferência do usuário usando perfis. Para obter detalhes, consulte Visão geral sobre Propriedades de Perfil de ASP.NET.

• Você pode configurar seu site para todas as páginas usarem a mesmo página mestra. Você pode ter algumas páginas que devem usar uma página mestra alternativa, que você pode configurar no código de uma maneira semelhante à mostrada nessa seção da explicação passo a passo. Para obter detalhes,

Visual Studio 158

consulte "Escopo de Páginas Mestres" em Visão Geral de Páginas Mestras de ASP.NET.

• Você precisa adicionar o código da página Home.aspx para cada página onde você deseja substituir a página mestra padrão.

Próximas etapas

Esta explicação passo a passo ilustra a funcionalidade básica de páginas mestras. Você pode desejar testar recursos adicionais de páginas mestras. Por exemplo, você pode desejar:

• Criar páginas mestras que têm vários espaços reservados de conteúdo. Em seguida, você pode preencher um ou mais espaços reservados com conteúdo para cada página que você exibir.

• Definir espaços reservados conteúdo conteúdo padrão. Se uma página ASP.NET não fornece conteúdo para o espaço reservado, a página mestra exibe o conteúdo padrão.

• Programaticamente acessar membros da página mestra de páginas de conteúdo. Isso permite que você dinamicamente altere o aspecto da página mestra em tempo de execução. Para obter detalhes, consulte Como: Referenciar o Conteúdo de Páginas Mestras ASP.NET.

• Usar filtragem de dispositivos com páginas mestras para criar diferentes layouts para diferentes dispositivos, como um layout para navegadores e outro para um tipo específico de telefone. Para obter detalhes, consulte Visão Geral sobre Filtragem de Dispositivo ASP.NET.

• Aprenda como você pode colocar páginas mestras em páginas mestras para criar partes em componentes. Para obter detalhes, consulte Páginas Mestras ASP.NET Aninhadas.

Visual Studio 159

Passo-a-passo: personalizando um site usando temas no Visual Studio

Esta explicação passo a passo ilustra como usar temas para aplicar uma aparência consistente a páginas e controles em seu site. Um tema pode incluir arquivos de capa que definem um aspecto comum para controles individuais, uma ou mais folhas de estilo e elementos gráficos comuns para uso dos controles, como o Controle TreeView Controle. Esta explicação passo a passo mostra como trabalhar com temas ASP.NET em sites da Web


• Aplicar temas predefinidos ASP.NET para páginas individuais e para o site como um todo.

• Criando seu próprio tema que inclui capas, que são usadas para definir o aspecto dos controles individuais.

Pré-requisitos


• Visual Web Developer Microsoft (Visual Studio).


Criando o site da Web

Se você já criou um site no Visual Web Developer (por exemplo, seguindo as etapas no Passo-a-passo: Criando uma página da Web básica em Visual Web Developer), você pode usar esse site e ir para a próxima seção. Caso contrário, crie um novo site e página seguindo estas etapas.


1. Abra Visual Web Developer.

2. No menu File, clique New Web Site.





5. Na lista Language, clique na linguagem de programação que você preferir trabalhar.

6. Clique em OK.


Para iniciar o trabalho com temas nesta explicação passo a passo, irá configurar um controle Button, um controle Calendar, e um controle Label, para que você possa ver como esses controles são afetados por temas.

Para colocar controles na página


Visual Studio 160

2. A partir do grupo Standarddo Toolbox, arraste um controle Calendar, um controleButton, e um controle Label para a página. O layout exato da página não é importante.

Observação

Não aplique qualquer formatação para qualquer um dos controles. Por exemplo, não use o comando AutoFormat para definir o aspecto do controle Calendar.


4. Certifique-se de que o elemento <head> da página tem o atributo runat="server" para que ela seja lida da seguinte maneira: <head runat="server"></head>

5. Salve a página.

Para testar a página, você desejará ver a página antes de um tema ser aplicado, e depois com diferentes temas.

Criando e aplicando um tema a uma página

O ASP.NET torna fácil aplicar um tema predefinido a uma página, ou criar um tema exclusivo. (Para obter detalhes, consulte COMO: Definir temas ASP.NET.) Nesta parte da explicação passo a passo, você irá criar um tema com algumas capas simples, que definem a aparência dos controles.

Para criar um novo tema

1. Em Visual Web Developer, clique com o botão direito do mouse no nome de seu site, clique Add ASP.Net Folder, e em seguida, clique em Theme.

A pasta chamada App_Themes e uma subpasta chamada Theme1 são criadas.

2. Renomeie a pasta Theme1sampleTheme.

O nome desta pasta será o nome do tema que você criar (aqui, sampleTheme). O nome exato é não importante, mas você tem que se lembrar dele quando você for aplicar o tema personalizado.

3. Clique com o botão direito do mouse na pasta sampleTheme, selecione Add New Item, adicione um novo arquivo de texto, e denomine-osampleTheme.skin.

4. No arquivo sampleTheme.skin, adicione definições de capa conforme mostrado no exemplo de código a seguir. <asp:Label runat="server" ForeColor="red" Font-Size="14pt" Font-Names="Verdana" />

<asp:button runat="server" Borderstyle="Solid" Borderwidth="2px" Bordercolor="Blue"

Backcolor="yellow"/>

Observação

As características exatas que você define são não importantes. Os valores da seleção anterior são sugestões que serão mais óbvias quando você testar o tema posteriormente.

As definições de capa são semelhantes à sintaxe para criação de um controle, exceto que as definições incluem apenas configurações que afetam a

Visual Studio 161

aparência do controle. Por exemplo, as definições capa não incluem uma configuração para a propriedade ID.

5. Salve o arquivo de capa, e seguida, feche-o.

Agora você pode testar a página antes de que qualquer temas seja aplicado.

Observação

Se você adicionar um arquivo de folhas de estilo em cascata (CSS) para a sua pasta sampleTheme, ele será aplicado a todas as páginas que usam o tema.

Para testar temas


Os controles são exibidos com sua aparência padrão.

2. Feche o navegador, e depois retorne ao Visual Web Developer.

3. No modo de exibição origem, adicione o atributo a seguir para a diretiva @ Page: <%@ Page Theme="sampleTheme" ... %>

Observação

Você deve indicar o nome de um tema real no valor do atributo (neste caso, o arquivo sampleTheme.skin que você definiu anteriormente).

4. Pressione CTRL+F5 para executar a página novamente.

Desta vez, os controles são processados com o esquema de cores definido no seu tema.

Os controles Label e Button serão exibidos com as configurações feitas no arquivo sampleTheme.skin. Porque você não foi criou uma entrada no arquivo sampleTheme.skin para o controle Calendar, ele será exibido com a aparência padrão.

5. Em Visual Web Developer, defina o tema com o nome de outro tema, se disponível.

6. Pressione CTRL+F5 para executar a página novamente.

Os controles alterarão sua aparência novamente.

Temas de Folhas de Estilo vs. Personalização de Temas

Após ter criado seu tema, você pode adaptar como ele é usado no seu aplicativo associando-o com a página tanto como um tema personalizado (como feito na seção anterior), ou como um tema de folhas de estilo. Um tema de folhas de estilo usa os mesmos arquivos de tema como um tema personalizado, mas sua prioridade nos controles e propriedades da página é inferior, equivalente a um arquivo CSS. No ASP.NET, a ordem de prioridade é:

• Configurações de temas, incluindo temas definidos em seu arquivo Web.config.

• Configurações de página local.

• Configurações de Temas de Folhas de Estilo.

Visual Studio 162

Quanto a isso, se você optar por usar um tema de folhas de estilo, as propriedades do seu tema serão substituídas por qualquer coisa declarada localmente na página. Da mesma forma, se você usar um tema personalizado, as propriedades do seu tema irão substituir qualquer coisa dentro a página local, e também em qualquer tema de folhas de estilo em uso.

Para usar um tema de folhas de estilo e consultar ordem de prioridade


2. Altere a declaração da página: <%@ Page theme="sampleTheme" %>

Para uma declaração de tema de folhas de estilo: <%@ Page StyleSheetTheme="sampleTheme" %>


Observe que a propriedade ForeColor do controle Label1 está vermelho.

4. Alternar para modo Design.

5. Selecione Label1 e, em Properties, defina ForeColor como blue.


A propriedade ForeColor de Label1 fica azul.


8. Altere a declaração da página para declarar um tema, em vez de um tema de folhas de estilo, alterando: <%@ Page StyleSheetTheme="sampleTheme" %>

De volta para: <%@ Page Theme="sampleTheme" %>


A propriedade ForeColor de Label1 estará vermelho novamente.

Baseando um tema personalizado em controles existente

Uma maneira fácil para criar definições de capa é usar o designer para definir as propriedades de aparência, e então copiar a definição de controle em um arquivo de capas.

Para basear um tema personalizado em controles existentes

1. No modo Design, defina a propriedades do controle Calendar para que o controle tenha um aspecto diferente. As configurações a seguir são sugestões:

o BackColor Cyan o BorderColor Red o BorderWidth 4 o CellSpacing 8 o Font-Name Arial o Font-Size Large o SelectedDayStyle-BackColor Red

Visual Studio 163

o SelectedDayStyle-ForeColor Yellow o TodayDayStyle-BackColor Pink

Observação

As características exatas que você definir não são importantes. Os valores da lista anterior são sugestões que serão mais óbvios quando você testar o tema posteriormente.

2. Alterne para o modo de origem e copie o elemento<asp:calendar> e seus atributos.

3. Alterne para ou abra o arquivo sampleTheme.skin.

4. Cole a definição do controle Calendar no arquivo sampleTheme.skin.

5. Remova a propriedade ID da definição no arquivo sampleTheme.skin.

6. Salve o arquivo sampleTheme.skin.

7. Alterne para a página Default.aspx, e arraste um segundo controle Calendar para a página. Não defina qualquer outra de suas propriedades.

8. Execute a página Default.aspx.

Ambos os controles Calendar irão aparentar o mesmo. O primeiro controle Calendar reflete as configurações que você fez nas propriedades explicitamente. O segundo controle Calendar herda suas propriedades de aparência da definição de capa que você fez no arquivo sampleTheme.skin.

Aplicando temas a um site

Você pode aplicar um tema a um site inteiro, que significa que você não precisa reaplicar o tema a páginas individuais. (Se você desejar, você pode substituir as configurações dos temas em uma página.)

Para configurar um tema para um site

1. Crie um arquivo Web.config se um não foi adicionado automaticamente ao seu site, seguindo etapas seguintes:

1. No Solution Explorer, clique com o botão direito do mouse no nome do site, e clique Add New Item.

2. Em Templates, selecione Web Configuration File, e clique Add.

Observação Você não precisa escrever um nome, porque o arquivo é denominado sempre de Web.config.

2. Adicione o elemento <pages> se ele ainda não existir. O elemento <pages> deve aparecer dentro do elemento <system.web>.

3. Adicionar o seguinte atributo ao elemento <pages>. <pages theme="sampleTheme" />

Observação

Web.config diferencia maiúsculas de minúsculas e os valores estão caixa-mista (alta e baixa). (Por exemplo: tema e styleSheetTheme).

4. Salve e feche o arquivo Web.config.

Visual Studio 164

5. Alterne para Default.aspx e alterne para o modo de origem.

6. Remova o atributo theme="themeName" da declaração de sua página.

7. Pressione CTRL+F5 para executar Default.aspx.

Agora a página é exibida com o tema que você especificou no arquivo Web.config.

Se você optar por especificar um nome de tema na declaração de sua página, ele substituirá qualquer tema especificado no seu arquivo Web.config.

Próximas etapas

O suporte ASP.NET para temas oferece uma variedade de opções para adaptar do aspecto e percepção de um aplicativo inteiro. Esta explicação passo a passo abordou algumas das noções básicas, mas você pode estar interessado em aprender mais. Por exemplo, pode desejar aprender mais sobre:

• Uso de temas em geral. Para mais informações, consulte Visão geral sobre temas e capas ASP.NET

• Criar seus próprios temas e capas. Para mais informações, consulte COMO: Definir temas ASP.NET

• Usando temas com código. Para mais informações, consulte COMO: aplicar temas ASP.NET Programaticamente

Visual Studio 165

Explicação passo a passo: Criando uma página Web Parts no Visual Web

Developer Esta explicação passo a passo é uma demonstração prática dos componentes e tarefas essenciais para criar páginas da Web que usam controles Web Parts em uma ferramenta de design visual como o Microsoft Visual Studio.

Em vários aplicativos da Web é útil ser capaz de alterar a aparência do conteúdo, bem como permitir que os usuários selecionem e organizem o conteúdo que desejam ver. O recurso Web Parts do ASP.NET consiste de um conjunto de controles para criar páginas da Web que apresentam conteúdo modular e que permitem a usuários alterar a aparência e o conteúdo para atender a suas preferências. Para obter uma introdução geral a Web Parts, consulte Visão geral sobre Web Parts do ASP.NET. Para uma visão geral dos componentes principais do conjunto de controles Web Parts, vários dos quais são usados nesta explicação passo a passo, consulte Visão geral sobre controles Web Parts.

Durante esta explicação passo a passo, você criará uma página que usa o conjunto de controles Web Parts para criar uma página da Web que o usuário pode modificar ou personalizar. As tarefas apresentadas nesta explicação passo a passo incluem:

• Adicionar controles Web Parts a uma página.

• Criar um controle de usuário personalizado e usá-lo como um controle Web Parts.

• Permitir que os usuários personalizem o leiaute dos controles Web Parts na página.

• Permitir que os usuários editem a aparência de um controle Web Parts.

• Permitir que os usuários selecionem um controle de um catálogo de controles Web Parts disponíveis.

Pré-requisitos


• Um site que possa identificar usuários individuais. Se você tiver um site já configurado com participação (membership) do ASP.NET, você pode usar esse site como um ponto de partida para esta explicação passo a passo. Caso contrário, a explicação passo a passo fornece instruções sobre como configurar seu site para identificá-lo por seu nome de conta de usuário do Windows.

• Um ambiente de design visual para criar páginas da Web. Esta explicação passo a passo usa o Visual Studio.

• Um provedor de personalização configurado e um banco de dados. Personalização de Web Parts é ativada por padrão e usa o provedor de personalização SQL (SqlPersonalizationProvider) do Microsoft SQL Server Express Edition para armazenar os dados de personalização. Esta explicação passo a passo usa o SSE e o provedor SQL padrão. Se você tiver o SSE instalado, nenhuma configuração será necessária. O SSE está disponível com o Microsoft Visual Studio 2005 como uma parte opcional da instalação ou como um download gratuito de Microsoft.com. Para usar uma das versões completas do SQL Server, você deve instalar e configurar um banco de dados de serviços de aplicativos ASP.NET e configurar o provedor de personalização SQL para se

Visual Studio 166

conectar a este banco de dados. Para obter detalhes, consulte Criar e configurar o banco de dados de serviços de aplicativos para o SQL Server.

Criar e configurar um site da Web

Esta explicação passo a passo requer que você tenha uma identidade de usuário, para que suas configurações Web Parts possam ser mapeadas para você. Se você já tiver um site configurado para usar associação (membership), é recomendável que você use esse site. Caso contrário, você pode criar um novo site e usar seu nome de usuário do Windows atual como a identidade do usuário.

Para criar um novo site • No Visual Studio, crie um novo site da Web do ASP.NET. Para obter detalhes,

consulte Explicação passo a passo: Criar um site com associação (mebership) e login de usuário (Visual Studio).

Criando uma página simples com Web Parts

Nesta parte da explicação passo a passo, você vai criar uma página que usa controles Web Parts para mostrar conteúdo estático. A primeira etapa para trabalhar com Web Parts consiste em criar uma página com dois elementos estruturais necessários. Primeiro, uma página Web Parts precisa de um controle WebPartManager para controlar e coordenar todos os controles Web Parts. Segundo, uma página Web Parts precisa de uma ou mais zonas, que são controles compostos que contêm controles WebPart ou outros controles de servidor e ocupam uma região especificada de uma página.

Observação

Você não precisa fazer nada para permitir personalização de Web Parts; esta é ativada por padrão para o conjunto de controles Web Parts. Na primeira vez que executar uma página Web Parts em um site, o ASP.NET configura um provedor de personalização padrão para armazenar as configurações de personalização do usuário. Para obter mais informações sobre personalização, consulte Visão geral sobre personalização Web Parts.

Para criar uma página para conter controles Web Parts

1. Feche a página padrão e adicione uma nova página ao site, chamada WebPartsDemo.aspx.

2. Alterne para o modo de exibição Design.

3. A partir do menu View, certifique-se de que as opções Non-Visual Controls e Details estão selecionadas para que você possa ver marcas de layout e controles que não têm uma interface de usuário

4. Coloque o ponto de inserção antes das marcas <div> na superfície de design e pressione ENTER para adicionar uma nova linha.

5. Posicione o ponto de inserção antes do caractere de nova linha. Selecione a opção Heading 1 na lista Block Format na barra de ferramentas, adicione o texto Web Parts Demonstration Page.

6. Na guia WebParts da caixa de ferramentas, arraste um controle WebPartManager para a página, posicionando-o logo após o caractere de nova linha e antes das marcas <div>.

O controle WebPartManager não gera nenhuma saída, então ele aparece como uma caixa cinza na superfície de design.

Visual Studio 167

7. Posicione o ponto de inserção nas marcas <div>.

8. No menu Layout, clique em Insert Table e crie uma nova tabela que tenha uma linha e três colunas. Clique no botão Cell Properties, selecione top da lista drop-down Vertical align, clique em OK e clique em OK novamente para criar a tabela.

9. Arraste um controle WebPartZone para a coluna esquerda da tabela. Clique com o botão direito do mouse no controle WebPartZone, escolha Properties e defina as propriedades a seguir: ID: SidebarZone HeaderText: Sidebar

10. Arraste um segundo controle WebPartZone para a coluna do meio da tabela e defina as seguintes propriedades: ID: MainZone HeaderText: Main

11. Salve o arquivo.

A página agora tem duas zonas diferentes que você pode controlar separadamente. No entanto, nenhuma das zonas tem qualquer conteúdo, então criar o conteúdo é a próxima etapa. Para esta explicação passo a passo, você trabalhará com controles Web Parts que exibem apenas conteúdo estático.

O layout de uma zona Web Parts é especificado por um elemento <zonetemplate>. Dentro do modelo da zona, você pode adicionar qualquer controle ASP.NET, quer seja um controle Web Parts personalizado, um controle de usuário ou um controle de servidor já existente. Observe que aqui você está usando o controle Label, ao qual você está simplesmente adicionando texto estático. Quando você coloca um controle de servidor em uma zona WebPartZone, o ASP.NET trata o controle como um controle Web Parts em tempo de execução, o que habilita recursos Web Parts no controle.

Para criar conteúdo para a zona principal 1. No modo de exibição Design, arraste um controle Label da guia Standard

da caixa de ferramentas para a área de conteúdo da zona cuja propriedade ID estiver definida como MainZone.

2. Alterne para o modo de visualização Source.

Observe que um elemento <zonetemplate> foi adicionado para ajustar o controle Label na MainZone.

3. Adicione um atributo chamado title ao elemento <asp:label> e defina seu valor como Content. Remova o atributo Text="Label" do elemento <asp:label>. Dentro do elemento <asp:label>, adicione algum texto como <h2>Welcome to my Home Page</h2>. Seu código deve se parecer com o a seguir. <asp:webpartzone id="MainZone" runat="server" headertext="Main"> <zonetemplate>

<asp:label id="Label1" runat="server" title="Content"> <h2>Welcome to My Home Page</h2>

</asp:label> </zonetemplate> </asp:webpartzone>

4. Salve o arquivo.

Depois, crie um controle de usuário que também pode ser adicionado à página como um controle Web Parts.

Visual Studio 168

Para criar um controle de usuário

1. Adicione um novo controle de usuário da Web ao seu site para servir como um controle de pesquisa denominado SearchUserControl.ascx, certificando-se que a opção Place source code in a separate file está desmarcada.

Observação

O controle de usuário para esta explicação passo a passo não implementa a funcionalidade de pesquisa de verdade; ele é usado somente para demonstrar os recursos Web Parts.


3. Na guia Standard da caixa de ferramentas, arraste um controle TextBox para a página.

4. Coloque o ponto de inserção após a caixa de texto que você adicionou e pressione ENTER para adicionar uma nova linha.

5. Arraste um controle Button para a página na nova linha abaixo da caixa de texto que você adicionou.

6. Alterne para o modo de exibição Source e certifique-se que o código fonte para o controle de usuário parece com o exemplo a seguir:

C# <%@ control language="C#" classname="SearchUserControl" %> <asp:textbox runat="server"

id=" TextBox1"></asp:textbox> <br /> <asp:button runat="server" id=" Button1" text="Search"

/>

7. Salve e feche o arquivo.

Observação de segurança

Esse controle tem uma caixa de texto que aceita entrada do usuário, o que é uma ameaça potencial de segurança. Dados entrados pelo usuário em uma página da Web potencialmente pode conter scripts de cliente mal intencionados. Por padrão, páginas da Web do ASP.NET validam a entrada do usuário para garantir que a entrada não contenha elementos HTML ou script. Enquanto essa validação estiver ativada, você não precisa verificar explicitamente se há elementos HTML ou scripts nos dados entrados pelo usuário. Para mais informações, consulte Visão geral sobre scripts maliciosos.

Agora você pode adicionar controles Web Parts à zona Sidebar. Você vai adicionar dois controles à zona Sidebar, um contendo uma lista de links e outro que é o controle de usuário que você criou no procedimento anterior. Os vínculos são adicionados como um controle de servidor padrão Label, semelhante ao modo com que você criou o texto estático para a zona principal. Entretanto, embora os controles de servidor individuais contidos no controle de usuário pudessem estar contidos diretamente na zona (como o controle de rótulo), nesse caso eles não estão. Em vez disso, eles fazem parte do controle de usuário que você criou no procedimento anterior. Isso demonstra uma maneira comum de empacotar controles e funcionalidade adicionais que você deseje em um controle de usuário e depois referenciar tal controle em uma zona como um controle Web Parts.

Em tempo de execução, o conjunto de controles Web Parts envolve ambos os controles com controles GenericWebPart. Quando um controle GenericWebPart envolve um controle do servidor Web, o controle da parte genérica é o controle pai

Visual Studio 169

e você pode acessar o controle de servidor através da propriedade ChildControl do controle pai. Esse uso de controles de parte genérica permite que controles de servidor da Web padrão tenham o mesmo comportamento básico e atributos que controles Web Parts que derivam da classe WebPart.

Para adicionar controles Web Parts à zona da barra lateral 1. Abra a página WebPartsDemo.aspx.


3. Arraste a página de controle de usuário que você criou, SearchUserControl.ascx, do Solution Explorer para a zona cuja propriedade ID estiver definida como SidebarZone.

4. Salve a página WebPartsDemo.aspx.

5. Alterne para o modo de visualização Source. 6. Dentro do elemento <asp:webpartzone> da SidebarZone, adicione um

elemento <asp:label> com contendo links, adicione também um atributo Title com um valor de Search à marca de controle de usuário, conforme mostrado no exemplo a seguir:

<asp:WebPartZone id="SidebarZone" runat="server" headertext="Sidebar"> <zonetemplate>

<asp:label runat="server" id="linksPart" title="My Links"> <a

href="http://www.asp.net">ASP.NET site</a> <br /> <a

href="http://www.gotdotnet.com">GotDotNet</a> <br /> <a

href="http://www.contoso.com">Contoso.com</a> <br /> </asp:label> <uc1:SearchUserControl

id="searchPart" runat="server" title="Search" /> </zonetemplate> </asp:WebPartZone>

7. Salve e feche o arquivo.

Agora você pode testar sua página.

Para testar a página

• Carregue a página em um navegador.

A página exibe as duas zonas. A tela a seguir mostra a página.

Demonstração de Web Parts com duas zonas

Na barra de título de cada controle há uma seta para baixo que fornece acesso a um menu de ações disponíveis que podem ser executadas em um controle. Clique no menu de verbos para um dos controles, clique no verbo Minimize e note que o controle é minimizado. No menu de verbos, clique em Restore e o controle retornará ao seu tamanho normal.

Habilitando usuários para editar páginas e alterar layout

Web Parts fornece a funcionalidade para usuários alterarem o layout de controles Web Parts arrastando-os de uma zona para outra. Além de permitir que os usuários movam controles WebPart de uma zona para outra, você pode permitir que usuários editem várias características dos controles, inclusive sua aparência, layout e comportamento. O conjunto de controles Web Parts fornece a funcionalidade básica para a edição de controles WebPart. Embora você não faça isso nesta explicação passo a passo, você também pode criar controles de edição personalizados que permitem que os usuários editem os recursos dos controles WebPart. Assim como alterar a localidade de um controle WebPart, editar as propriedades de um controle depende da personalização do ASP.NET para salvar as alterações feitas pelos usuários.

Visual Studio 170

Nesta parte da explicação passo a passo, você adicionará o recurso que permite aos usuários editar as

características básicas de qualquer controle WebPart em a página. Para ativar esses recursos, você

adicionará outro controle de usuário personalizado à página, juntamente com um elemento

<asp:editorzone> e dois controles de edição.

Para criar um controle de usuário que permita modificações do layout da página

1. No Visual Studio, no menu File, clique em New e então em File.

2. Na caixa de diálogo Add New Item, selecione Web User Control. Nomeie o novo arquivo

DisplayModeMenu.ascx. Desmarque a caixa de opção Place source code in separate file.

3. Clique em Add para criar o novo controle.


5. Remova todo o código existente no novo arquivo e cole neste o código a seguir. Este código de

controle de usuário usa recursos do conjunto de controles Web Parts para permitir que uma

página tenha seu modo de exibição ou visualização alterado, e também permite que você altere a

aparência física e o layout da página quando estiver em certos modos de exibição.

C#

<%@ control language="C#" classname="DisplayModeMenuCS"%> <script runat="server"> //

Use a field to reference the current WebPartManager control. WebPartManager _manager; void

Page_Init(object sender, EventArgs e) { Page.InitComplete += new EventHandler(InitComplete);

} void InitComplete(object sender, System.EventArgs e) { _manager =

WebPartManager.GetCurrentWebPartManager(Page); String browseModeName =

WebPartManager.BrowseDisplayMode.Name; // Fill the drop-down list with the names of

supported display modes. foreach (WebPartDisplayMode mode in

_manager.SupportedDisplayModes) { String modeName = mode.Name; // Make sure a mode is

enabled before adding it. if (mode.IsEnabled(_manager)) { ListItem item = new

ListItem(modeName, modeName); DisplayModeDropdown.Items.Add(item); } } // If Shared

scope is allowed for this user, display the // scope-switching UI and select the appropriate radio //

button for the current user scope. if (_manager.Personalization.CanEnterSharedScope) {

Panel2.Visible = true; if (_manager.Personalization.Scope == PersonalizationScope.User)

RadioButton1.Checked = true; else RadioButton2.Checked = true; } } // Change the page to the

selected display mode. void DisplayModeDropdown_SelectedIndexChanged(object sender,

EventArgs e) { String selectedMode = DisplayModeDropdown.SelectedValue;

WebPartDisplayMode mode = _manager.SupportedDisplayModes[selectedMode]; if (mode !=

null) _manager.DisplayMode = mode; } // Set the selected item equal to the current display mode.

void Page_PreRender(object sender, EventArgs e) { ListItemCollection items =

DisplayModeDropdown.Items; int selectedIndex =

items.IndexOf(items.FindByText(_manager.DisplayMode.Name));

DisplayModeDropdown.SelectedIndex = selectedIndex; } // Reset all of a user's personalization

data for the page. protected void LinkButton1_Click(object sender, EventArgs e) {

_manager.Personalization.ResetPersonalizationState(); } // If not in User personalization scope,

toggle into it. protected void RadioButton1_CheckedChanged(object sender, EventArgs e) { if

(_manager.Personalization.Scope == PersonalizationScope.Shared)

_manager.Personalization.ToggleScope(); } // If not in Shared scope, and if user has permission,

toggle // the scope. protected void RadioButton2_CheckedChanged(object sender, EventArgs e) {

if (_manager.Personalization.CanEnterSharedScope && _manager.Personalization.Scope ==

PersonalizationScope.User) _manager.Personalization.ToggleScope(); } </script> <div>

Visual Studio 171

<asp:Panel ID="Panel1" runat="server" Borderwidth="1" Width="230" BackColor="lightgray"

Font-Names="Verdana, Arial, Sans Serif" > <asp:Label ID="Label1" runat="server"

Text=" Display Mode" Font-Bold="true" Font-Size="8" Width="120" />

<asp:DropDownList ID="DisplayModeDropdown" runat="server" AutoPostBack="true"

Width="120" OnSelectedIndexChanged="DisplayModeDropdown_SelectedIndexChanged" />

<asp:LinkButton ID="LinkButton1" runat="server" Text="Reset User State" ToolTip="Reset the

current user's personalization data for the page." Font-Size="8" OnClick="LinkButton1_Click" />

<asp:Panel ID="Panel2" runat="server" GroupingText="Personalization Scope" Font-Bold="true"

Font-Size="8" Visible="false" > <asp:RadioButton ID="RadioButton1" runat="server"

Text="User" AutoPostBack="true" GroupName="Scope"

OnCheckedChanged="RadioButton1_CheckedChanged" /> <asp:RadioButton ID="RadioButton2"

runat="server" Text="Shared" AutoPostBack="true" GroupName="Scope"

OnCheckedChanged="RadioButton2_CheckedChanged" /> </asp:Panel> </asp:Panel> </div>

6. Salve o arquivo, clicando no ícone de gravação na barra de ferramentas, ou selecionando Save no

menu File.

Para permitir que os usuários alterem o layout

1. Abra a página WebPartsDemo.aspx.


3. Posicione o ponto de inserção imediatamente após o controle WebPartManager que você

adicionou anteriormente. Digite ENTER para criar uma linha em branco após o controle

WebPartManager.

4. Arraste o controle de usuário recém-criado (DisplayModeMenu.ascx) para a página

WebPartsDemo.aspx e solte-o na linha em branco.

5. Arraste um controle EditorZone da seção WebParts da caixa de ferramentas para a célula aberta

restante da tabela na página WebPartsDemo.aspx.

6. A partir da seção WebParts da caixa de ferramentas, arraste um controle AppearanceEditorPart

e um controle LayoutEditorPart para o controle EditorZone.


O código resultante na célula da tabela deve ter aspecto semelhante ao do código a seguir.

<td valign="top"> <asp:EditorZone ID="EditorZone1" runat="server"> <ZoneTemplate>

<asp:AppearanceEditorPart ID="AppearanceEditorPart1" runat="server" />

<asp:LayoutEditorPart ID="LayoutEditorPart1" runat="server" /> </ZoneTemplate>

</asp:EditorZone> </td>

Observação

Embora os controles AppearanceEditorPart e LayoutEditorPart sejam usados nesta explicação passo a passo, os controles PropertyGridEditorPart e BehaviorEditorPart não são, pois eles requerem configurações além do escopo desta explicação passo a passo.

8. Grave o arquivo WebPartsDemo.aspx.

Você criou um controle de usuário que permite que você altere os modos de exibição e o layout da página

e você referenciou o controle na página da Web primária.

Agora você pode testar a funcionalidade de editar páginas e alterar layout.

Visual Studio 172

Para testar alterações de layout

1. Carregue a página em um navegador.

2. No menu Display Mode, clique em Edit.

Os títulos de zona são exibidos.

3. Arraste o controle My Links pela sua barra de título a partir da zona Sidebar para a parte inferior

da zona Main.

Sua página deve ter aspecto como o da seguinte tela:

Demonstração de página Web Parts com o controle My Links movido

4. Clique em Display Mode, e depois clique em Browse.

A página será atualizada, os nomes de zona desaparecem e o controle My Links permanecerá

onde você o posicionou.

5. Para demonstrar que a personalização está funcionando, feche o navegador, e em seguida,

carregue a página novamente. As alterações feitas são salvas para sessões futuras do navegador.

6. No menu Display Mode, clique em Edit.

Agora cada controle na página é exibido com uma seta para baixo na sua barra de título, a qual

contém o menu drop-down de verbos.

7. Clique na seta para exibir o menu de verbos sobre o controle My Links, e então clique em Edit.

O controle EditorZone aparecerá, exibindo os controles EditorPart que você adicionou.

8. Na seção Appearance do controle de edição, altere o Title para My Favorites. Na lista

Chrome Type, selecione Title Only e, em seguida, clique em Apply.

A tela a seguir mostra a página no modo de edição

Demonstração de página Web Parts no modo de edição

9. Clique no menu Display Mode, depois clique em Browse para retornar para o modo de

navegação.

O controle agora tem um título atualizado e nenhuma borda, como mostrado na tela a seguir.

Demonstração de página Web Parts editada

Adicionar Web Parts em tempo de execução

Você também pode permitir que usuários adicionem controles Web Parts à suas páginas em tempo de

execução. Para fazer isso, configure a página com um catálogo Web Parts, que contém uma lista dos

controles Web Parts que você deseja tornar disponíveis para os usuários.

Observação

Nesta explicação passo a passo, você criará um modelo contendo os controles FileUpload e Calendar. Isso permitirá que você teste a funcionalidade básica do catálogo, mas os controles Web Parts resultantes não têm qualquer funcionalidade real. Se você tiver uma página da Web ou controle de usuário personalizados, você pode substituir o conteúdo estático por eles.

Para permitir que os usuários adicionem Web Parts em tempo de execução

1. Abra a página WebPartsDemo.aspx.

Visual Studio 173


3. Na guia WebParts da caixa de ferramentas, arraste um controle CatalogZone para a coluna

direita da tabela, sob o controle EditorZone.

Ambos os controles podem estar na mesma célula da tabela pois eles não serão exibidos ao mesmo

tempo.

4. No painel Properties, atribuia a seqüência Add Web Parts para a propriedade HeaderText do

controle CatalogZone.

5. A partir da seção WebParts da caixa de ferramentas, arraste um controle DeclarativeCatalogPart

para a área de conteúdo do controle CatalogZone.

6. Clique na seta no canto direito superior do controle DeclarativeCatalogPart para expor seu

menu Tasks, e selecione Edit Templates.

7. A partir da seção Standard da caixa de ferramentas, arraste um controle FileUpload e um

controle Calendar para a seção WebPartsTemplate do controle DeclarativeCatalogPart.

8. Alterne para o modo de visualização Source. Inspecione o código fonte do elemento

<asp:catalogzone>.

Observe que o controle DeclarativeCatalogPart contém um elemento <webpartstemplate>

com os dois controles de servidor incluídos que você poderá adicionar à sua página a partir do

catálogo.

Observação

Se você tiver um controle personalizado, este é o local para substituir um dos controles servidor do exemplo por ele, embora isso necessite de etapas além do escopo desta explicação passo a passo. Para obter mais detalhes, consulte o exemplo de código na documentação para a classe WebPart.

9. Adicione uma propriedade Title a cada um dos controles adicionados ao catálogo, usando o valor

de seqüência de caracteres mostrado para cada título no exemplo de código abaixo. Embora o

título não seja uma propriedade que normalmente você possa definir nesses dois controles de

servidor em tempo de design, quando um usuário adiciona esses controles a uma zona

WebPartZone a partir do catálogo em tempo de execução, eles são empacotados por um controle

GenericWebPart. Isso permite que eles atuem como controles Web Parts, portanto, eles

poderão exibir títulos.

O código para os dois controles contidos no controle DeclarativeCatalogPart devem ter aspecto

como a seguir.

<asp:DeclarativeCatalogPart ID="DeclarativeCatalogPart1" runat="server">

<WebPartsTemplate> <asp:Calendar ID="Calendar1" runat="server" title="My Calendar" />

<asp:FileUpload ID="FileUpload1" runat="server" title="Upload Files" /> </WebPartsTemplate>

</asp:DeclarativeCatalogPart>

10. Salve a página.

Agora você pode testar o catálogo.

Para testar o catálogo Web Parts

1. Carregue a página em um navegador.

2. No menu Display Mode, clique em Catalog.

O catálogo intitulado Add Web Parts é exibido.

3. Arraste o controle My Favorites da zona Main de volta para o parte superior da zona Sidebar.

Visual Studio 174

4. No catálogo Add Web Parts, selecione as duas caixas de seleção e então selecione Main na lista

de zonas disponíveis.

5. Clique em Add no catálogo.

Os controles são adicionados à zone Main. Se você desejar, você pode adicionar várias ocorrências

dos controles do catálogo à sua página. As telas a seguir mostram a página com o controle de envio

de arquivo e o calendário na zona Main:

Controles adicionados à zona Main do catálogo

6. No menu Display Mode, clique em Browse.

O catálogo desaparece e a página é atualizada.

7. Feche o navegador e carregue a página novamente.

As alterações feitas vão persistir.

Próximas etapas

Esta explicação passo a passo ilustrou os princípios básicos do uso de controles Web Parts simples em um

página da Web do ASP.NET. Você pode desejar testar recursos Web Parts adicionais, mais sofisticados.

Sugestões para explorações adicionais incluem:

• Criar controles Web Parts que ofereçam funcionalidades mais sofisticadas que as Web Parts

estáticas desta explicação passo a passo. Você pode criar controles Web Parts como controles de

usuário ou controles personalizados. Para obter detalhes, consulte a documentação para a classe

WebPart.

Visual Studio 175

Explicação Passo a Passo: Criando um Site Web com Associação e Login de

Usuário (Visual Studio) Um requisito comum para sites Web é permitir que somente alguns membros ou outros usuários autenticados vejam determinadas páginas. Nesse caso, o aplicativo deve solicitar um nome e uma senha para o usuário. O aplicativo também deve incluir uma maneira para ocultar informações de usuários anônimos (usuários que não estão autorizados). Esta explicação passo a passo mostra como usar os controles do ASP.NET e serviços de associação do ASP.NET para criar um aplicativo que executa todas essas tarefas. Para mais informações, consulte Introdução a Associação.

As tarefas ilustradas nesta explicação passa a passo incluem:

• Configurar um aplicativo para incluir os serviços de associação do ASP.NET e como definir os usuários.

• Usar os controles de login para obter credenciais de usuário e exibir informação para os usuários autorizados.

• Proteger uma ou mais páginas em seu aplicativo para que somente os usuários autorizados possam vê-las.

• Permitir que usuários novos se registrem em seu site.

• Permitir que os membros alterem e redefinam suas senhas.

Pré-requisitos

Para concluir esta explicação passo a passo, você precisará de :

• MIcrosoft Visual Web Develper.

• Microsoft Internet Information Services (IIS) instalado localmente em seu computador.

• Microsoft Data Access Components (MDAC) versão 2.7 ou posterior. Se você estiver usando o Microsoft Windows XP ou Windows Server 2003, você já tem MDAC 2.7. Entretanto, se você estiver usando o Microsoft Windows 2000, você pode precisar atualizar o MDAC já instalado no seu computador. Para obter mais informações, consulte o artigo "Instalação do Microsoft Data Access Components (MDAC)" na biblioteca MSDN.

• Acesso a um servidor de email que pode encaminhar mensagens de email. (O servidor não precisa ter capacidade para receber mensagens.) O IIS inclui o servidor virtual Default SMTP, um servidor de email que é adequado para esta explicação passo a passo. Para obter mais informações sobre configuração do servidor, consulte HOW TO: Instalar e Configurar Servidores Virtuais SMTP em IIS. Se você estiver trabalhando em uma rede local, contate o seu administrador de rede para obter informação sobre o acesso a um servidor de email.

Criando o Site Web

Se você já criou um site Web no Microsoft Visual Studio (por exemplo, trabalhando com o tópico Explicação Passo a Passo: Criando uma Página Web Básica no Visual Web Developer), você pode usar esse site Web e ir para "Configurando Associação" posteriormente nesta explicação passo a passo. Caso contrário, crie um novo site Web e uma página seguindo estas etapas.

Visual Studio 176

Para criar um site Web local no IIS

1. Abrir o Visual Studio.



3. Sob oVisual Studio installed templates, selecione o ASP.NET Web Site.

4. Na caixa de listagem Location , selecione HTTP. Clique em Browse.

A caixa de diálogo Choose Location aparece.

5. Selecione Local IIS.

6. Abra o Local Web Servers.

7. Selecione o Default Web Site.

8. Clique no ícone Create New Web Application ( ) acima da lista de sites

Web e em seguida, nomeie a associação do novo site Web.

9. Clique em Open.

A caixa de diálogo Choose Location fecha.

10. Na caixa Languages, clique a linguagem de programação com a qual você prefere trabalhar.

A linguagem de programação que você escolher será o padrão para seu site Web, mas você pode definir as linguagens de programação para cada página individualmente.

11. Clique em OK na caixa de diálogo New Web Site.

O Visual Web Developer cria o site Web e uma nova página chamada Default.aspx.

Configurando a Associação

Posteriormente nesta explicação passo a passo você colocará páginas em um subdiretório protegido. Você deve criar o subdiretório agora para que você possa configurar a segurança para ele posteriormente na explicação passo a passo.

Para adicionar uma nova pasta ao site Web

1. No Solution Explorer, clique com o botão direito do mouse no nome do seu site Web e clique em New Folder.

2. Nomear uma pasta MemberPages.

Antes de você trabalhar com a associação do ASP.NET, você deve configurar seu aplicativo para ativar a associação e configurar os usuários. Você pode usar a ferramenta Web Site Administration, que fornece uma interface do tipo assistente para realizar esta configuração.

Para esta explicação passo a passo, você definirá um único usuário.

Para criar um usuário da associação

1. No menu Website, clique em ASP.NET Configuration.

2. Selecione o guia Security, clique o link para Use the security Setup Wizard to configure security step by step, e em seguida, clique em Next

3. Vá para a etapa 2 do assistente e selecione a opção From the Internet.

Visual Studio 177

O assistente exibe uma página onde você pode selecionar o método de autenticação que seu site Web usará. Esta opção especifica que seu aplicativo usará a autenticação Forms, onde os usuários poderão efetuar o login em seu aplicativo usando uma página de login que você criará nesta explicação passo a passo posteriormente.

4. Clique em Next.

O assistente exibe uma mensagem indicando que a informação do usuário será armazenada usando o Advanced provider settings. Por padrão, a informação da associação é armazenada em um arquivo de banco de dados do Microsoft SQL Server Express na pasta App_Data do seu site Web.

5. Clique em Next.

O assistente exibe uma opção para criar funções. Mais tarde nesta explicação passo a passo você executará essa etapa separadamente. Portanto, não selecione a caixa de seleção Enable roles for this web site.

6. Clique em Next.

O assistente exibe uma página onde você pode criar novos usuários.

7. Insira a informação que define um usuário de seu aplicativo. Use os seguintes valores como diretrizes (você pode utilizar quaisquer valores, mas certifique-se de anotar as suas entradas para a explicação passo a passo posterior):

o User Name Seu nome (sem espaços) ou um nome simples. o Password Uma senha. Uma senha segura é necessária (uma que

inclua letras maiúsculas e minúsculas, pontuação e que tenha pelo menos oito caracteres).

o E-mail Seu endereço de e-mail pessoal. Posteriormente na explicação passo a passo, você enviará para si uma mensagem, portanto você precisa de um endereço de e-mail legítimo.

o Security Questione Security Answer Digite uma questão e responda o que pode ser usado mais tarde, se você precisar redefinir sua senha.

8. Clique em Create User.

O assistente exibe uma página de confirmação.

Observação

Deixe a ferramenta Web Site Administration aberta.

Anteriormente, na explicação passo a passo, você criou uma pasta chamada MemberPages. Nesta parte da explicação, você criará uma regra em que somente os usuários autorizados poderão acessar as páginas daquela pasta.

Para configurar as regras de acesso para o subdiretório MemberPages

1. No assistente, clique em Next.

O assistente exibe uma página que permite que você crie regras de acesso.

2. Na caixa Add New Access Rule, expanda o nó para o seu site Web.

3. Selecione MemberPages, a pasta que você criou anteriormente.

Visual Studio 178

4. Em Rule applies to, selecione Anonymous users.

5. Em Permission, selecione Deny.

A regra que você está criando nega acesso a usuários anônimos — ou seja, usuários que não estejam autorizados.

6. Clique em Add This Rule.

A nova regra é exibido na grade abaixo. Quando os usuários solicitam uma página do subdiretório MemberPages, as regras são verificadas para determinar se o usuário tem permissão de acesso para a página.


Agora você terminou a configuração com o assistente. Ele fecha e você retorna para a guia Security da ferramenta Web Site Administration.

Configurando o Aplicativo para E-mail

Para parte desta explicação passo a passo, o aplicativo precisa ser ativado para enviar mensagens de e-mail. Para enviar mensagens, seu aplicativo deve ter acesso a um servidor Simple Mail Transport Protocol (SMTP), que encaminha mensagens de e-mail do seu aplicativo para um destinatário de email.

O IIS inclui o servidor virtual Default SMTP como um componente opcional, que é adequado para esta explicação passo a passo. Para obter mais informações sobre como configurar este servidor, consulte HOW TO: Instalar e Configurar os Servidores Virtuais SMTP no IIS. Se você estiver trabalhando em uma rede local, contate o seu administrador de rede para obter informação sobre o acesso a um servidor de e-mail.

Depois de ter configurado ou determinado como acessar um servidor SMTP, você deve configurar seu aplicativo para rotear as mensagens de e-mail para o servidor. Você pode fazer uma entrada em seu arquivo Web.config do site Web, que contém uma série de configurações que determinam como o seu aplicativo executa.

Para configurar o aplicativo para usar um servidor SMTP específico

1. Na ferramenta Web Site Administration, clique na guia Application.

2. No SMTP Settings, clique em Configure SMTP e-mail settings.

A ferramenta exibe uma página onde você pode configurar e-mail.

3. Se você está usando o servidor virtual SMTP que está em seu computador, digite localhost como o Server Name; caso contrário, digite o nome do servidor apropriado.

Inclua informação para o número da porta e para a autenticação de acordo com os requisitos do seu servidor SMTP. Consulte o seu administrador para obter mais informações sobre como configurar estas opções.

4. Na caixa From, digite um endereço de e-mail válido.

5. Clique em Save e na a página de confirmação, clique em OK.

A ferramenta Web Site Administration cria um arquivo Web.config (se já não existir um) com as configurações que você fez.

Observação

O arquivo Web.config não aparecerá no Solution Explorer até você atualizar a exibição.

Visual Studio 179

6. Feche a ferramenta Web Site Administration.

Autorizando o Usuário

Como parte do seu aplicativo, você precisa estabelecer a identidade do usuário para que o aplicativo possa realizar ações — como mostrar ou ocultar informação — com base em quem é o usuário. Para obter a identidade do usuário,é preciso que o usuário execute o login.

Nesta explicação passo a passo, você adicionará um link na página que leva os usuários para uma página de login, e então, você criará esta página de login.

Para criar uma página com um botão de login

1. Abra ou alterne para a página Default.aspx do seu site. (Se você não tem uma página Default.aspx, você pode adicionar uma ou usar uma página diferente.)

2. Alterne para o modo Design.

3. Digite um texto estático como Welcome to our site e, na barra de ferramenteas Formatting, use a lista drop-down Block Format para formatar o texto como "Heading 1".

4. A partir do grupo Login do Toolbox, arraste um controle LoginStatus para a página.

Por padrão, o controle LoginStatus é desenhado como um link. Quando os usuários clicam neste controle, o aplicativo exibe uma página de login. Agora você pode criar a página de login.

Para criar uma página de login

1. No Solution Explorer, clique com o botão direito do mouse em seu aplicativo Web e selecione Add New Item. Adicione um Web Form chamado Login.aspx em seu site

Observação

Para esta explicação passo a passo, a página deve ter o nome de Login.aspx. Por padrão, autenticação de formulários é configurada para trabalho com uma página com este nome. Embora você não vá fazer isso nesta explicação, você pode alterar a página de login padrão — a página para a qual os usuários são redirecionados — no arquivo Web.config.

2. Na página Login.aspx, alterne para o modo Design.

3. A partir do grupo Login do Toolbox, arraste um controle Login para a página.

O controle Login é um controle único que solicita e valida as credenciais do usuário.

Exibindo os Erros de Login

O controle Login inclui validação para ajudar os usuários a inserir informações corretas. Por exemplo, se um usuário ignora a senha, um controle validator exibe um asterisco (*) ao lado da caixa Password. Você pode fornecer informações mais completas para erros de login adicionando um controle ValidationSummary para a página.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/system.web.ui.webcontrols.loginstatus(VS.80).aspx

Visual Studio 180

Para exibir erros de login detalhados

1. A partir do grupo Validation do Toolbox, arraste um controle ValidationSummary para a página.

2. Na janela Properties do controle ValidationSummary, defina a propriedade ValidationGroup para Login1, que é o padrão de identificação do controle Login que você adicionou anteriormente.

Exibindo Informações para os Usuários Autorizados

Agora você modificará a página para personalizar a exibição se o usuário estiver conectado. Os usuários anônimos verão uma mensagem genérica convidando-os a executar o login. Os usuários conectados verão uma mensagem de boas vindas com seu nome autorizado.

Para personalizar a exibição para usuários conectados


2. A partir do grupo Login do Toolbox, arraste um controle LoginView para a página.

O controle LoginView é exibido com seu modelo AnonymousTemplate aberto. Este modelo permite que você defina o conteúdo que os usuários verão antes de se conectarem.

3. Clique na área de edição do controle LoginView para ativar a edição.

4. Na área de edição do modelo Anonymous Template do controle LoginView, digite Você não está autorizado. Clique no link Login para entrar.

5. No painel LoginView Tasks, na lista Views, clique em LoggedInTemplate. Se você não conseguir ver o painel LoginView Tasks, clique com o botão direito do mouse no título do controle LoginView e selecione Show Smart Tag.

Agora você está definindo o conteúdo que será exibido aos usuários que já estão autorizados.

6. Clique na área de edição do controle LoginView para ativar a edição, e em seguida, digite Você está autorizado. Bem-vindo..

7. A partir do gupo Login do Toolbox, arraste o controle LoginName para o modelo após o texto.

Testando o Login

Agora você pode testar a funcionalidade de login do seu aplicativo.

Para testar o login

1. No Solution Explorer, clique com o botão direito do mouse em Default.aspx e clique em Set As Start Page.

Isso configura o site para que, ao executar o site Web, a página Default.aspx apareça primeiro.

2. Pressione CTRL+F5 para executar o site Web.

A ???home page??? (Default.aspx) aparece no navegador, mostrando o link Login e a mensagem genérica.

3. Clique no link Login.

A página de login que você criou é exibida.

Visual Studio 181

4. Digite o nome de login do usuário que você criou anteriormente na explicação passo a passo, e depois, clique em Log In. (Não entre ainda com uma senha.)

Um asterisco (*) é exibido ao lado da caixa Password e uma mensagem de erro é exibida no controle ValidationSummary.

5. Digite tanto um nome de usuário e uma senha, e depois clique em Log In.

Se você inseriu credenciais corretas, você retornada para a página inicial. A página agora exibe um link Logout, o seu nome de usuário, e a mensagem de boas-vindas que você definiu para o usuário autorizado.


Limitando o Acesso para Páginas Exclusivas

Uma tarefa comum em muitos sites Web é configurar páginas para que somente usuários autorizados podem visualizar. Anteriormente na explicação passo a passo, você criou o subdiretório MemberPages e criou uma regra que limita o acesso a páginas no subdiretório. Nesta seção da explicação, você adicionará uma página ao subdiretório protegido e testará a regra de acesso.

Para criar a página Exclusiva

1. No Solution Explorer, clique com o botão direito do mouse na pasta MemberPages, clique em Add New Item, e adicione uma nova Web Form chamada Members.aspx.

Observação

Certifique-se de criar a página na pasta MemberPages.

2. No modo Design, adicione um texto para a página, como Bem-vindo, membros!. O texto exato não faz diferença, contanto que você seja capaz de reconhecer esta página.

Agora você pode adicionar um link para a página exclusiva. Em um aplicativo real, você deve, provavelmente, colocar o link da página exclusiva no modelo conectado do controle LoginView. Dessa forma, os visitantes de seu site não veriam o link até eles estarem autorizados. Para esta explicação, entretanto, você tornará o link disponível para todos os usuários para que você possa ver o efeito das tentativas fracassadas de exibir uma página excluvisa.

Para adicionar um link para a página exclusiva


2. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para a página.

3. Na janela Properties para o controle HyperLink, defina a propriedade Text para o Members page e a propriedade NavigateUrl para o ~/MemberPages/Members.aspx para apontar para a página que você criou anteriormente.

Testando a Página Exclusiva

Você pode testar a página excluvisa, acessando-a como um usuário anônimo ou como um usuário conectado.

Visual Studio 182

Para testar a página Excluvisa


2. Quando a página Default.aspx aparece no navegador, não faça o login. Em vez disso, clique no link Members page.

Você é redirecionado para a página Login.aspx porque o acesso para a página para membros foi negada para usuários anônimos.

3. Na página de login, digite o nome de usuário e a senha que você utilizou anteriormente na explicação passo a passo para se conectar.

Você é redirecionado para a página Members.aspx porque o nome de usuário que você utilizaou foi autorizado para acessar a página.

4. Feche a janela do navegador.

Criando Novos Usuários

Na primeira parte da explicação passo a passo, você criou um usuário com a ferramenta Web Site Administration. Essa estratégia é útil se você estiver trabalhando com uma lista de usuários pequena; por exemplo, se você estiver criando usuários para uma equipe pequena. Entretando, em muitos sites Web, os usuários têm permissão para se registrarem. O ASP.NET inclui o controle CreateUserWizard que executa a mesma tarefa que você executou anteriormente usando a ferramenta Web Site Administration.

Nesta parte da explicação passo a passo, você adicionará um recurso que permite aos usuários se registrarem em seu site Web. Para iniciar, você criará uma página de registro.

Para criar uma página de registro

1. No Solution Explorer, clique com o botão direito do mouse no nome do seu site Web, clique em Add New Item e adicione uma nova Web Form chamada Register.aspx.

Observação

Certifique-se de criar a página na raiz do site Web e não na pasta MemberPages.

2. Na página Register.aspx, alterne para o modo Design e digite um texto estático, como Registro, para a página. Na barra de ferramentas Formatting, use a lista drop-down Block Format para formatar o texto como "Heading 1".

3. A partir do grupo Login do Toolbox, arraste um controle CreateUserWizard para a página.

4. Na janela Properties para o controle CreateUserWizard, defina a propriedade ContinueDestinationPageUrl para ~/Default.aspx.

Isso configura o controle para que a execução retorne para a home page, assim que os usuários clicarem em Continue após a criação de um usuário, .

5. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para a página. Na janela Properties para o controle HyperLink, defina a propriedade Text para Home e a propriedade NavigateUrl para ~/Default.aspx.

Visual Studio 183

Agora você pode adicionar um link para a home page que exibe a página de registro. Para esta explicação, suponha que você deseja exibir o link de registro somente para os usuários que não estão autorizados.

Para criar um link de registro na home page


2. Clique com o botão direito do mouse no controle LoginView adicionado anteriormente, e selecione Show Smart Tag. No painel LoginView Tasks, selecione AnonymousTemplate da caixa de listagem Views para ativar a edição no modelo anônimo.

3. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para um modelo anônimo. Na janela Properties para o controle HyperLink, defina a propriedade Text para Register e a propriedade NavigateUrl para Register.aspx. O link Register será exibido somente para os usuários que não estão autorizados.

Agora você pode testar o processo de registro.

Para testar o registro

1. Pressione CTRL+F5 para executar o site Web e exibir a página Default.aspx.

Por você não estar conectado, a página contendo o link Register é exibida.

2. Clique no link Register.

A página de registro é exibida.

3. Nas caixas de texto, digite um novo nome de usuário, uma senha forte, um endereço de e-mail e uma pergunta de segurança e de resposta. (Todas as cinco peças de informação são necessárias.)

4. Clique em Create User.

Um mensagem de confirmação é exibida.

5. Clique o botão Continue.

Você retorna para a home page como um usuário autorizado. Observe que o link Login foi alterado para Logout e que a informação exibida no controle Login é da propriedade LoggedInTemplate, não da propriedade AnonymousTemplate.

6. Clique no link Logout.

A página muda para exibir a informação para os usuários anônimos.


8. Insira as credenciais para o usuário que você acabou de criar.

Você está conectado como o novo usuário.


Alterando Senhas

Eventualmente os usuários podem querer alterar suas senhas e é freqüentemente impraticável executar essa tarefa de forma manual. Portanto, você pode usar um outro controle do ASP.NET para permitir que os usuários alterem suas próprias senhas. Para alterar uma senha, os usuários devem conhecer sua senha atual.

Nesta explicação passo a passo, você adicionará uma página onde os usuários conectados podem alterar suas senhas.

Visual Studio 184

Para criar uma página de alteração de senha

1. No Solution Explorer, clique com o botão direito do mouse na pasta MemberPages, clique em Add New Item e adicione uma nova Web Form chamada ChangePassword.aspx.

Observação

Certifique-se de criar a página na pasta MemberPages.

2. Você está colocando a página na pasta Members-Only porque somente os usuários autorizados podem alterar suas senhas.

3. Na página ChangePassword.aspx, alterne para o modo Design e digite um texto estático como Alterar Senha. Na barra de ferramentas Formatting, use a lista drop-down Block Format para formatar o texto como "Heading 1".

4. A partir do grupo Login do Toolbox, arraste um controle ChangePassword para a página.

5. Na janela Properties para o controle ChangePassword, defina a propriedade ContinueDestinationPageUrl para ~/Default.aspx.

6. Isso configura o controle para que, quando os usuários clicarem em Continue após alterar uma senha, o controle retorne para a home page.

Agora você pode adicionar um link para a home page que exibe a página de alteração de senha. Você disponibilizará o link apenas aos usuários que estão conectados.

Para criar um link de alteração de senha na home page


2. Clique com o botão direito do mouse no controle LoginView e depois clique em Show Smart Tag. No menu LoginView Tasks, na lista Views, clique em LoggedInTemplate.

Isso alterna o controle LoginView para o modo de edição para o conteúdo que será exibido para usuários que estão conectados.

3. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para a região de edição. Na janela Properties para o controle HyperLink, defina a propriedade Text para Change password e a propriedade NavigateUrl para ~/MemberPages/ChangePassword.aspx.

O link Change password será exibido somente aos usuários que estão conectados, sendo o oposto do link Register que você criou anteriormente.

Agora você pode testar o processo de alteração de senha.

Para testar a alteração de senha


2. Na página Default.aspx, clique no link Login e se conecte como um dos usuários que você criou.

Quando você tiver terminado, você retorna para a home page como um usuário autorizado.

3. Clique no link Change password.

Visual Studio 185

4. Na página de alteração de senha, digite a senha antiga e uma nova senha, e depois clique em Change Password.

5. Clique em Continue.

6. Na home page, clique em Logout.


8. Digite a nova senha.

Você está conectado com a nova senha.


Recuperando uma Senha

Ocasionalmente, os usuários esquecerão suas senhas. Você pode adicionar uma página de recuperação de senha ao seu site Web para que eles possam efetuar novamente a conexão para seu site. A recuperação de senha pode ter duas formas:

• Você pode enviar aos usuários a senha que eles selecionaram (ou a que você criou para eles quando você configurou o site). Esta opção requer que o site armazene a senha usando criptografia reversível.

• Você pode enviar aos usuários uma nova senha, que eles podem alterar usando a página de alteração de senha que você criou anteriormente. Essa opção é útil se o site Web armazena senhas usando um esquema de criptografia não reversível como hashing.

Observação

Retornando uma senha em texto não criptografado usando e-mail não é recomendado para sites que requerem um nível alto de segurança. Para sites de alta segurança, é recomendável que você retorne senhas usando criptografia, como o Secure Sockets Layer (SSL).

Por padrão, o sistema de associação do ASP.NET protege senhas por hashing, o que significa que as senhas não podem ser recuperadas. Portanto, para essa parte da explicação, seu site Web enviará aos usuários uma nova senha.

Observação

A recuperação de senha requer que o seu site Web possa enviar mensagens de e-mail. Se você não consegue configurar o seu site Web para enviar email (conforme explicado em "Configurando o Aplicativo para E-mail" anteriormente), não conseguirá adicionar uma recuperação de senha ao seu site.

Para adicionar recuperação de senha

1. No Solution Explorer, clique com o botão direito do mouse no nome do seu site Web, clique em Add New Item e adicione uma nova Web Form chamada RecoverPassword.aspx.

Observação

Certifique-se de criar a página na raiz do site Web, não na pasta MemberPages.

2. Na página RecoverPassword.aspx, alterne para o modo Design digite um texto estático como Redefinir minha senha para um novo valor. Na barra

Visual Studio 186

de ferramentas Formatting, use a lista drop-down Block Format para formatar o texto como "Heading 1".

3. A partir do grupo Login do Toolbox, arraste um controle PasswordRecovery para a página.

4. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para a página. Na janela Properties para o controle HyperLink, defina a propriedade Text para Home e a propriedade NavigateUrl para ~/Default.aspx.

5. Alterne para a página Default.aspx.

6. Clique com o botão direito do mouse no controle LoginView e depois clique em Show Smart Tag. No menu LoginView Tasks, na lista Views, clique em AnonymousTemplate.

Isso alterna o controle LoginView para o modo de edição para o conteúdo que aparecerá para os usuários que não estão autorizados.

7. A partir do grupo Standard do Toolbox, arraste um controle HyperLink para um modelo. Na janela Properties para o controle HyperLink, defina a propriedade Text para Forgot your password? e a propriedade NavigateUrl para ~/RecoverPassword.aspx.

Agora você pode testar a recuperação de senha.

Para testar a recuperação de senha


2. Por padrão, você não está autorizado, então você vê o modelo anônimo do controle LoginView.

3. Clique no link Forgot your password?.

A página RecoverPassword.aspx aparece.

4. Digite seu nome de usuário e clique em Submit.

A pergunta de segurança é exibida e é solicitado que você digite a resposta de segurança.

5. Digite a resposta e clique em Submit.

Se você inseriu uma resposta correta, o site Web redefine sua senha e envia para você uma mensagem de e-mail com a nova senha.

Próximas Etapas

Esta explicação passo a passo tem ilustrado um cenário simples mas completo para criar um aplicativo que solicita credenciais de usuários, exibe informação para os usuários autorizados, permite que os usuários recuperem uma senha esquecida e limita o acesso às páginas. Você pode criar páginas e aplicativos mais sofisticados usando as técnicas e controles ilustrados na explicação. Por exemplo, você pode desejar:

• Criar usuários adicionais e definir funções (grupos) como gerentes, vendas ou membros e associar membro para diferentes funções. Para obter detalhes, consulte Explicação Passo a Passo: Gerenciando Usuários de Site Web Usando Funções.

• Altere o provedor da associação de provedor Access padrão para um provedor SQL. Armazenar as informações de associação em um banco de dados Access é adequado para sites pequenos e médios, mas se o seu site passará por

Visual Studio 187

tráfego pesado, você desejará utilizar o Microsoft SQL Server para armazenas os dados de associação. Para obter mais informações, consulte Web Site Administration Tool Provider Tab e Criando Banco de Dados de Serviços do Aplicativo para SQL Server.

• Alterar a aparência dos controles de login. Os controles Login, PasswordRecovery e CreateUserWizard possuem suporte para modelos, que permiteme que você configure o texto e os botões que ele contêm, assim como a cor, a fonte e outras características de aparência.Para obter mais informações, consulte os tópicos na seção Controles de Login do ASP.NET:

• Criar regras que limitam o acesso às páginas ou pastas não apenas para usuários anônimos, mas para usuários ou funções específicos.

• Combinar a associação com as propriedades de perfil, que permitem a você armazenar configurações específicas para cada usuário. Para obter detalhes, consulte Explicação Passo a Passo: Mantendo a Informação do Usuário do Site Web com Propriedades de Perfil.

• Combinar os controles de login com as páginas mestras. As páginas mestras permitem que você defina um layout da página que pode ser usado para todas as páginas em seu aplicativo. Para obter detalhes, consulte Explicação Passo a Passo: Criando e Usando as Páginas Mestras do ASP.NET em Visual Web Developer.

• Adicionar o recurso para recuperar uma senha esquecida. Para mais informações, consulte HOW TO: Ativar a Recuperação de Senha de Usuário Usando o Controle PasswordRecovery do ASP.NET.

Visual Studio 188

Passo-a-passo: Criando e usando um serviço da Web ASP.NET no Visual Web

Developer Além de permitir que você crie páginas da Web, o Microsoft Visual Studio também deixa que você crie serviços da Web que usem ASP.NET XML. A criação de um serviço da Web no Visual Studio é semelhante a criar uma página da Web. Você também pode usar a ferramenta de desenvolvimento Web do Microsoft Visual Web Developer para referenciar e usar serviços da Web que estão em uma solução do Visual Web Developer em seu computador local ou em um diretório UDDI local ou externo. Nesta explicação passo a passo, você irá criar o serviço da Web em uma solução e usá-lo em outra.


• Criar um XML Web Service simples no Visual Web Developer.

• Criar um site em separado que usa o serviço da Web.

Pré-requisitos


• Serviços de Informações da Internet da Microsoft (IIS) instalado localmente em seu computador.

Criando um serviço da Web na raiz do IIS

Crie um novo serviço e uma página da Web seguindo estas etapas.

Observação

Você deve usar um site do IIS para esta explicação passo a passo.

Para criar um serviço da Web




3. Em Visual Studio installed templates, clique em ASP.NET Web Service.

4. Clique em Browse.

5. Clique em Local IIS.

6. Clique em Default Web Site.

7. Clique em Create New Web Application.

O Visual Web Developer cria um novo aplicativo da Web do IIS.

8. Digite o nome TemperatureWebService.

9. Clique em Open.

A caixa de diálogo New Web Site aparece com o nome do novo site no canto mais a direita da lista Location. A localidade inclui o protocolo (http://) e a localidade (localhost). Isso Indica que você está trabalhando com um site local do IIS.

Visual Studio 189

10. Na lista Language, clique na linguagem de programação com a qual você prefere trabalhar.

A linguagem de programação que você escolher será o padrão para o site. Entretanto, você pode usar mais de uma linguagem no mesmo aplicativo da Web, criando páginas e componentes em linguagens de programação diferentes. Para obter mais informações sobre como criar componentes usando diferentes linguagens, consulte Pastas de código compartilhadas em sites do ASP.NET.

11. Clique em OK.

O Visual Web Developer cria o novo serviço da Web e abre uma nova classe chamada Service, que é o serviço da Web padrão. Entretanto, no procedimento a seguir será criado um novo serviço da Web com um nome diferente e não você usará a classe Service.

12. Feche a classe Service.

Criando o serviço da Web

Você criará um serviço da Web que converte a temperatura de Fahrenheit para Celsius e vice-versa.

Para criar o serviço da Web

1. No Solution Explorer, clique com o botão direito do mouse no nome do site (http://localhost/TemperatureWebService), e clique em Add New Item.

2. Em Visual Studio installed templates, clique em Web Service, e na caixa Name, digite Convert.

3. Certifique-se de que a caixa de seleção Place code in separate file está selecionada e clique em Add.

O Visual Web Developer cria um novo serviço da Web que é composto de dois arquivos. O arquivo Convert.asmx é o arquivo que pode ser chamado para chamar os métodos do serviço da Web e ele aponta para o código do serviço da Web. O código propriamente dito está em um arquivo de classe (Convert.vb, Convert.cs, ou Convert.jsl, dependendo da linguagem de programação) na pasta App_Code. O arquivo de código contém um modelo para um serviço da Web. O arquivo de código inclui um código para um método do serviço da Web.

Você criará dois métodos no serviço da Web. O primeiro método converte temperaturas Fahrenheit para Celsius, e o segundo método converte temperaturas Celsius para Fahrenheit.

Para criar os métodos de conversão

1. Adicione o seguinte código dentro a classe, após o método HelloWorld:

C# [System.Web.Services.WebMethod()] public double FahrenheitToCelsius(double Fahrenheit) {

return ((Fahrenheit - 32) * 5) / 9; } [System.Web.Services.WebMethod()] public double

CelsiusToFahrenheit(double Celsius) { return ((Celsius * 9) / 5) + 32; }

Observe que os nomes das funções são precedidos com um atributo ([System.Web.Services.WebMethod()] ou <System.Web.Services.WebMethod()>) como parte da declaração da função

2. Depois que você inseriu as funções, salve o arquivo.

Visual Studio 190

Agora você pode testar o serviço da Web no Visual Web Developer.

Para testar o serviço da Web

1. No Solution Explorer, clique em Convert.asmx e pressione CTRL+F5.

O serviço da Web é chamado e aparece uma página no navegador que mostra os métodos que são expostos pelo serviço da Web.

2. Clique em CelsiusToFahrenheit, que chama esse método.

Aparece uma página que solicita que você entre os valores dos parâmetros para o método CelsiusToFahrenheit.

3. Na caixa Celsius, digite 100 e clique em Invoke.

Uma nova janela aparece exibindo o XML que o serviço da Web retorna quando o método CelsiusToFahrenheit é chamado. O valor 212 aparece no XML.

4. Feche o navegador que contém os resultados do método.

5. No navegador original, clique em Back para retornar para a lista de métodos.

6. Clique em FahrenheitToCelsius e teste para certificar-se de que o método está retornando os resultados que você espera.

Se você digitar 212, o método FahrenheitToCelsius retornará 100.


Você terminou de criar o serviço da Web; a próxima etapa é usá-lo.

Usando o serviço da Web

Agora que você tem um serviço da Web, você irá criar um site onde você irá referenciar e usar o serviço da Web que você criou. Para a explicação passo a passo, você irá criar um site separado que tenha uma página onde você inicia os métodos do serviço da Web recém-criado.

Para criar um site para usar o serviço da Web



3. Clique em Browse.


5. Clique em Default Web Site.

6. Clique em Create New Web Application.

O Visual Web Developer cria um novo aplicativo da Web do IIS.

7. Digite o nome TemperatureWeb.

8. Clique em Open.

9. Na lista Language, clique na linguagem de programação com a qual você prefere para trabalhar.

10. Clique em OK.

O Visual Web Developer cria um novo site local do IIS e uma nova página chamada Default.aspx.

Adicionando o serviço da Web como um componente

Visual Studio 191

O serviço da Web é um componente que você pode referenciar no seu aplicativo. Portanto, você deve criar uma referência a ele.

Para criar uma referência para o serviço da Web

1. No Solution Explorer, clique com o botão direito do mouse no nome do site e clique em Add Web Reference.

A caixa de diálogo Add Web Reference aparece, como mostrado no seguinte instantâneo:

Caixa de diálogo Add Web Reference

2. Na lista URL, digite a seguinte URL para o serviço da Web e, em seguida, clique em Go:

http://localhost/TemperatureWebService/Convert.asmx

Quando o Visual Web Developer encontra o serviço da Web, as informações sobre o serviço da Web aparecem na caixa de diálogo Add Web References.

Observação

Se você não puder adicionar uma referência para um serviço da Web, pode ser que o servidor proxy não esteja configurado corretamente. No Microsoft Internet Explorer, no menu Ferramentas, clique em Opções da Internet, clique em Conexões e clique em Configurações de LAN. Selecione a caixa de seleção Ignorar servidor de proxy para endereços locais. Além disso, defina o endereço do servidor proxy com o nome exato do servidor proxy em vez de permitir que o Internet Explorer detecte o servidor proxy. Para obter mais informações, contate o administrador de rede.

3. Clique em um dos links dos métodos.

O página de teste para o método aparece.

4. Clique em Add Reference.

O Visual Web Developer cria uma pasta App_WebReferences e lhe adiciona uma pasta para a nova referência da Web. Por padrão, são atribuídas às referências da Web um namespace correspondente ao seu nome de servidor (neste caso, localhost). Anote o nome do namespace para a referência da Web. Na pasta, o Visual Web Developer adiciona um arquivo .WSDL que referencia o serviço da Web. Ele também adiciona arquivos de suporte, como arquivos de busca (.disco e .discomap), que incluem informações sobre onde o serviço da Web está localizado.

Observação

Se o nome do servidor para o serviço da Web contiver caracteres que não podem ser usados para um nome de classe, como um hífen (-), o Visual Web Developer converte os caracteres em um caractere sublinhado (_). Portanto, o namespace no Visual Web Developer para o serviço da Web pode não corresponder exatamente ao nome do servidor.

Agora você pode usar o serviço da Web. Nesta explicação passo a passo, você irá adicionar controles ao Default.aspx, e depois programar os controles para converter uma temperatura especificada em Fahrenheit e em Celsius. Quando a página estiver sendo executada, ela parecerá com a seguinte ilustração.

Visual Studio 192

Temperature conversion page

Para chamar os métodos do serviço da Web

1. Abra a página Default.aspx e alterne para o modo Design.

2. A partir do grupo Standard na caixa de ferramentas, arraste os seguintes controles para a página e definia suas propriedades conforme o indicado:

Controle Propriedades

Textbox IDTemperatureTextbox

Text: (vazio)

Button IDConvertButton

Text: Convert

Label IDFahrenheitLabel

Text: (vazio)

Label IDCelsiusLabel

Text: (vazio)

3. Opcionalmente, adicione texto à página nas legendas.

O layout de página para esta explicação passo a passo não é importante.

4. Clique duas vezes em ConvertButton para criar um manipulador de eventos para o evento Click.

5. Verifique se o código do seu manipulador de eventos corresponde ao código de exemplo a seguir:

C# protected void ConvertButton_Click(object sender, EventArgs e) { localhost.Convert wsConvert =

new localhost.Convert(); double temperature =

System.Convert.ToDouble(TemperatureTextbox.Text); FahrenheitLabel.Text = "Fahrenheit To

Celsius = " + wsConvert.FahrenheitToCelsius(temperature).ToString(); CelsiusLabel.Text =

"Celsius To Fahrenheit = " + wsConvert.CelsiusToFahrenheit(temperature).ToString(); }


7. Na caixa de texto, digite um valor, como 100, e clique em Convert.

A página exibe o resultado da conversão do valor da temperatura em Fahrenheit e em Celsius.

Depurando o serviço da Web

Você pode depurar um serviço da Web da mesma maneira que você depura páginas da Web.

Visual Studio 193

Observação

O Visual Web Developer Express Edition e o Visual Studio Standard Edition não oferecem suporte passo a passo por dentro das chamadas em um serviço da Web de uma página que o referencia. Se você estiver usando o Visual Web Developer Express Edition ou o Visual Studio Standard Edition, ignore esta seção e as seguintes. Para obter mais informações sobre como depurar sites da Web, consulte Passo-a-passo: Depurando páginas da Web no Visual Web Developer.

Para iniciar, você deve configurar o site que contém o serviço da Web para ativar a depuração.

Para ativar a depuração no site de serviços da Web 1. No menu File, clique em Open Web Site.


3. Clique em TemperatureWebService e clique em Open.

4. No menu Website, clique em ASP.NET Configuration para abrir o Web Site Administration Tool.

Observação

Se esta for a primeira vez que você tiver executado o Web Site Administration Tool, pode demorar um pouco antes de ele aparecer.

5. Clique em Application e clique em Application Configuration.

6. Em Debugging and Tracing, clique em Configure debugging and tracing.

7. Selecione a caixa de seleção Enable debugging.

O Web Site Administration Tool cria um arquivo Web.config para o site e define uma opção de configuração para ativar a depuração.

Observação

Para consultar o arquivo Web.config no Solution Explorer, clique no nome do site e, na barra de ferramentas do Solution Explorer, clique em Refresh.

8. Feche o Web Site Administration Tool.

Agora você deve ativar a depuração para o site que usa o serviço da Web.

Para ativar a depuração do site

1. Abra o site TemperatureWeb.

2. No menu Website, clique em ASP.NET Configuration para abrir o Web Site Administration Tool.

3. Clique em Application, clique em Application Configuration em Debugging and Tracing, clique em Configure debugging and tracing e selecione a caixa de seleção Enable debugging.

4. Feche o Web Site Administration Tool.

Visual Studio 194

Observação

Para consultar o arquivo Web.config no Solution Explorer, selecione o nome do site e clique em Refresh na barra de ferramentas do Solution Explorer.

5. No Solution Explorer, clique com o botão direito do mouse em Default.aspx e clique em View Code.

O Visual Web Developer abre o arquivo de código para a página.

6. Posicione o ponteiro do mouse na seguinte linha:

C# double temperature = System.Convert.ToDouble(TemperatureTextbox.Text);

7. Pressione F9 para definir um ponto de interrupção na linha.

Testando a depuração

O site e o serviço da Web estão configurados para a depuração, para que você agora possa começar a depurar. Você irá iniciar na página Default.aspx e depurar o código até que o código chame o serviço da Web. O depurador alternará para o serviço da Web e continuará a depuração através do código.

Para depurar a página e o serviço da Web

1. Pressione F5 para executar a página Default.aspx usando depuração.

A página aparece no navegador.

2. Na caixa, digite um valor, como 100, e clique em Convert.

O Visual Web Developer começa a executar o código da página, mas pára e realça a linha com o ponto de interrupção sobre ele.

3. Pressione F11 para ir para a próxima linha.

4. Pressione F11 novamente.

Como a linha seguinte chama o serviço da Web, o depurador vai para o serviço da Web, parando na primeira linha do método FahrenheitToCelsius.

5. Continue pressionando F11.

O depurador avança através do restante do método e retorna para a página que chamou o método. Se você continuar a depuração, o depurador irá de volta para o serviço da Web e para o método CelsiusToFahrenheit.

6. Feche o navegador, que também fecha o depurador.

Próximas etapas

Esta explicação passo a passo ilustrou os princípios básicos de criação de um serviço da Web muito simples e de usá-lo em um aplicativo ASP.NET. Você pode desejar experimentar serviços da Web com recursos adicionais e mais complexos. Sugestões para explorações adicionais incluem o seguinte:

• Compreender o processamento que ocorre quando você faz uma chamada XML Web Service.

Para mais informações, consulte Anatomia do tempo de vida de um XML Web Service.

• Entender como usar XML Web Services.

Visual Studio 195

Para mais informações, consulte Cenários do XML Web Service.

• Criar XML Web Services que oferecem funcionalidades mais sofisticadas do que o serviço da Web simples desta explicação passo a passo. Você pode criar e encadear chamadas de métodos de serviços da Web assíncronas, usar transações, proteger os serviços da Web, configurar serviços da Web para autenticação do Microsoft Windows, e assim por diante.

Para mais informações, consulte XML Web Services utilizando ASP.NET .

• Aprender sobre os recursos específicos da linguagem e da tecnologia fornecidos pelo XML Web Service.

Para obter mais informações, consulte XML Web Services no Visual FoxPro, Introdução à programação de XML Web Services em código gerenciado, Serviços da Web (como faço no Visual Basic), XML Web Services criados com o servidor ATL e Explicações passo a passo sobre a criação e o acesso a XML Web Services.

Visual Studio 196

Criando e Acessando Explicações Passo a Passo de XML Web Services

XML Web Services fornecem acesso programático a lógica do aplicativo usando protocolos padrão da Web, como XML e HTTP. XML Web Services podem ser aplicativos autônomos ou subcomponentes de um aplicativo maior da Web. XML Web Services são acessíveis de praticamente qualquer outro tipo de aplicativo, incluindo outros XML Web Services, aplicativos Web, aplicativos do Windows e aplicativos console. O único requisito é de que o cliente possa enviar, receber, e processar mensagens de e para um XML Web Service. Para obter mais informações, consulte Programação na Web com XML Web Services.

Essas explicações passo a passo cobrem dois caminhos de desenvolvimento logicamente separados, criando XML Web Services e acessando XML Web Services. Embora você possa ser tanto o criador e o usuário de um XML Web Services específico, os processos são distintamente separados. É claro, você precisará criar um XML Web Services antes de poder acessá-lo.

As explicações passo a passo de criação de XML Web Services usar duas tecnologias separadas para implementar um XML Web Services. Em todos os casos, você cria a mesma funcionalidade XML Web Services; a única diferença é o método de implementação.

As explicações passo a passo de acesso a XML Web Services concentram nas etapas necessárias para acessar XML Web Services no código gerenciado e código não gerenciado. Em cada explicação passo a passo, o aplicativo cliente acessa o XML Web Services usando uma classe proxy gerada pelo Visual Studio.

Observação

Em cada explicação passo a passo você irá acessar um XML Web Services criado em uma das explicações passo a passo acima "Criando um XML Web Service...". Ou seja, não é necessário concluir pelo menos uma das explicações passo a passo "Criando um XML Web Service..." antes de tentar um das explicações passo a passo " Acessando um XML Web Service ".

Para uma demonstração de um XML Web Services que retorna um DataSet altamente tipado de SQL Server e processa atualizações de aplicativos Windows e da Web, consulte Criando um aplicativo distribuído Walkthrough:.

Visual Studio 197

Explicação Passo a Passo: Criando um XML Web Services usando Visual Basic

ou Visual C# Explicação passo a passo a seguir descreve o processo para criar um XML Web Services que converte temperaturas medidas em Fahrenheit para Celsius usando Visual Basic ou C# visual.

Você durante esta explicação passo a passo, você irá realizar as atividades a seguir:

• Criar um XML Web Services usando o modelo projeto serviço ASP.NET Web.


• Executar o XML Web Services no modo de depuração.


Para concluir o explicação passo a passo, você precisará ter acesso a uma máquina que atende aos requisitos para criar um projeto da Web. Para obter mais informações, consulte Tour guiado da criação de sites no Visual Web Developer e Passo a passo: Criando e usando um serviço da Web do ASP.NET no Visual Web Developer.


O Visual Studio fornece um modelo de projeto ASP.NET Web Service para ajudá-lo a criar XML Web Services no Visual Basic e Visual C#.

Para criar um ASP.NET Web Service Project 1. No menu File, escolha New Web Site.

2. Na caixa de diálogo New Web Site, selecione o ícone ASP.NET Web Service.

3. Digite o endereço do servidor Web no qual você irá desenvolver o XML Web Services e especifique TempConvert1 como o nome do diretório, tal como " http://MyServer/TempConvert1 ". Por padrão, o projeto usa seu computador local, " http://localhost ".

Observação

Para alguns tipos de projeto, o caixa de texto Name está disponível porque especificando a localidade define em vez disso o nome do projeto. Por exemplo, aplicativos da Web e XML Web Services estão localizados em um servidor Web e derivam seus nomes do diretório virtual especificado no servidor.

Observação

Você desenvolve XML Web Services em um servidor de desenvolvimento. Por padrão, o servidor de desenvolvimento é sua máquina local. Normalmente, voce desenvolve e constrói o projeto em um servidor de desenvolvimento, e então você o implementa em outro servidor (o servidor se implementação) que irá hospedar o XML Web service usando um projeto de implementação. Entretanto, se você estiver desenvolvendo diretamente no servidor que hospedará o XML Web Services, o servidor de desenvolvimento e o servidor de implantação são os mesmos.

Visual Studio 198


O Visual Studio automaticamente cria os arquivos necessários e inclui as referências necessárias para suportar um XML Web Services. Quando você criar um projeto XML Web Services no Visual Studio, verá o criador de componente para Service1.asmx.


A próxima etapa é escrever o código para implementar a funcionalidade do XML Web Services que os clientes irão acessar. Para XML Web Services criados no Visual Studio, um arquivo oculto code-behind associado ao arquivo.asmx do XML Web Services que o Visual Studio criou para você contém esse código. Para obter mais informações, consulte COMO: Criar um Método de Serviço da Web XML.

Para adicionar um método de XML Web Service

1. No arquivo código Service.vb, localize o código para a declaração de classe Service. Substituia o código de atributo System.Web.Services.WebService com o seguinte código antes da declaração de classe (mostrada em negrito):

Visual Basic <System.Web.Services.WebService( _ Namespace:="http://Walkthrough/XmlWebServices/", _

Description:="A temperature conversion service.")> _ Public Class Service

[System.Web.Services.WebService( Namespace="http://Walkthrough/XmlWebServices/",

Description="A temperature conversion service.")] public class Service :

System.Web.Services.WebService

Unindo o atributo WebService à classe Public se torna possível a inclusão de informação adicional sobre o XML Web Service, como um namespace para o XML Web Service e uma descrição para o XML Web Service. A propriedade description desse atributo está incluída na página de ajuda de Service. Para obter mais informações, consulte COMO: Usar o Atributo WebService.

2. Na classe Service, adicione o seguinte código para declarar a função ConvertTemperature:

Visual Basic <WebMethod(Description:="This method converts a temperature in " & _ "degrees Fahrenheit to

a temperature in degrees Celsius.")> _ Public Function ConvertTemperature(ByVal dFahrenheit

As Double) _ As Double Return ((dFahrenheit - 32) * 5) / 9 End Function

[WebMethod(Description="This method converts a temperature in " + "degrees Fahrenheit to a

temperature in degrees Celsius.")] public double ConvertTemperature(double dFahrenheit) {

return ((dFahrenheit - 32) * 5) / 9; }

Anexando o atributo WebMethod a um método Public expõe esse método como parte do XML Web Services. A propriedade description deste atributo está incluído na página ajuda de Service e na página de ajuda Service Methods. Para obter mais informações, consulte COMO: Usar o Atributo WebMethod.

3. Clique com o botão direito do mouse Service.asmx em Solution Explorer e clique Set as Start Page no menu de atalho.

4. Salvar a solução.



Visual Studio 199

• Iniciar (com depuração)

• Iniciar sem depuração

• Modo de Exibição no navegador

Como um projeto Visual Studio, este XML Web Services tem configurações separadas para as versões de lançamento e depuração. Como você criou este projeto usando o modelo de projeto do serviço da Web ASP.NET, Visual Studio automaticamente criou essas configurações e definiu as opções padrão apropriadas e outras configurações. Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Nesta explicação passo a passo, será colocado um ponto de interrupção no XML Web Services e usado o método Start (with Debugging). Para obter mais informações, consulte Como Depurar XML Web Services em Código Não Gerenciado.

Antes de depuração, verifique as configurações de depuração. Para obter mais informações, consulte Projetos Serviço da Web XML depuração preparação:.

Para usar um ponto de interrupção e iniciar o XML Web Services com depuração

1. No menu Debug, escolher New Breakpoint, então Break At Function.

Na guia Function, digite ConvertTemperature na caixa Function e clique OK para adicionar um ponto de interrupção na declaração de método ConvertTemperature.

2. No menu Debug, clique em Start, clique Ok na janela Debugging Not Enabled para iniciar depuração.

Este comando instrui o Visual Studio a executar o XML Web Services no depurador. O Visual Studio cria o projeto e o implanta para o servidor de desenvolvimento designado. Após a conclusão, o navegador padrão exibe o arquivo.asmx a partir do servidor de implantação.

Quando você abre um arquivo.asmx em um navegador, o XML Web Services retorna uma página Service auxiliar que fornece informações sobre o XML Web Services. O Service Description link leva você para um documento XML que contém a descrição serviço formal do XML Web Services. Para obter mais informações, consulte XML Web Service Description.

3. Na página de ajuda Service, clique no link ConvertTemperature.

4. Na caixa dFahrenheit, digite o número 212, e clique no botão Invoke.

Quando o processamento atingir a função ConvertTemperature, o processamento pára. O depurador Visual Studio realça a linha que contém o ponto de interrupção; enquanto ele é interrompido, você pode executar uma variedade de tarefas. Para obter mais informações, consulte Explicação detalhada sobre o depurador e Exibindo Dados no Depurador.


6. O XML Web Services responde retornando o valor convertido em um documento XML semelhante ao seguinte: <?xml version="1.0" encoding="utf-8" ?> <double


Para interromper a execução do XML Web Services e retornar ao editor de código, no menu Debug, clique em Stop Debugging.

Visual Studio 200



Para tornar seu XML Web Services disponível para outros, você deve implantá-lo em um servidor Web que seja acessível para os clientes que você queira dar suporte. Para distribuir o XML Web Services para um servidor que não seja o servidor de desenvolvimento, você pode adicionar um projeto Web Setup ou copiar os arquivos necessários para o servidor de destino. Nesta explicação passo a passo, você pode escolher como implantar este XML Web Services. Para obter mais informações, consulte COMO: Implantar Serviços da Web XML no Código Gerenciado.

Para implantar o XML Web Services usando um projeto Web Setup

1. No menu File, aponte para Add, e clique New Project.

2. Selecionar o nó Other, e o nó Setup and Deployment Projects, e clique em Web Setup Project.

3. Na caixa Name, digitar TempConvert1WebSetup, e clique OK.

Observação



5. No Solution Explorer, clique com o botão direito do mouse em TempConvert1WebSetup, aponte para Add, e clique Project Output.

6. Na caixa de diálogo Add Project Output Group, selecione Content Files. Para obter mais informações, consulte Como adicionar e remover Outputs Project no File System Editor:.

o O grupo Content Files consiste dos seguintes arquivos para o XML Web Services: Service1.asmx, GLOBAL.asax, e Web.config. Para obter mais informações, consulte COMO: Implantar Serviços da Web XML no Código Gerenciado.

7. Clique em OK.

8. No Solution Explorer, clique com o botão direito do mouse no projetoTempConvert1WebSetup, e no menu de atalho, clique Build.

Isso cria um arquivo do Windows Installer no diretório de projeto local. Executar este arquivo instala o aplicativo da Web.

Para implantar o XML Web Services, copiando o projeto

1. No Solution Explorer, selecione o projeto TempConvert1.


3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de diálogo Open Web Site. Navegue para a localidade para a qual você deseja copiar o projeto.

4. No painel Source Web Site, selecione os arquivos para copiar e movê-los para o painel Remote Web Site, clicando no ícone de seta à direita. .

Visual Studio 201

5. Clique Copy Web Site para copiar o site.



• Acessar um serviço da Web XML usando C++ Walkthrough:

• Acessar um serviço da Web XML usando C++ e o CLR Walkthrough:

Visual Studio 202

Passo-a-passo: Criando um XML Web Service usando C++ e o CLR

Os desenvolvedores podem usar a nova sintaxe C++ para expor funcionalidade escrita em C++ como um serviço XML da Web. Usando essa sintaxe, os desenvolvedores podem criar classes gerenciadas usando C++. Essas classes e seus métodos públicos então podem ser expostos como serviços XML da Web usando arquivos.asmx da mesma maneira como os Serviços XML da Web no Visual Basic e Visual C#.


• Criar um serviço XML da Web usando o ASP.NET Web Service modelo de projeto.


• Depurar o serviço da Web XML.


Para concluir o explicação passo a passo, você precisará ter acesso a uma máquina que atende aos requisitos para criar um projeto da Web. Para obter mais informações, consulte Requisitos de hardware do Visual Studio. Você também precisará de permissões suficientes para ser capaz de criar projetos XML Web Services no computador onde seu servidor Web está.


Usando o ASP.NET Web Service modelo de projeto, Visual Studio cria automaticamente um projeto do serviço XML da Web que usa C++.

Para criar um projeto Serviço da Web ASP.NET com C++

1. No menu File, aponte para New, e clique Project para abrir a New Project caixa de diálogo.

2. Selecione a Visual C++ Projects pasta, e, em seguida, clique no ASP.NET Web Service ícone.

3. Na caixa Name, digite TempConvert3 e depois clique em OK.

O modelo de projeto fornece automaticamente os arquivos necessários e referências a suporte um serviço XML da Web.

Dica

No Solution Explorer Consulte o arquivo ReadMe.txt que descreve os projetos e arquivos gerados.


A próxima etapa é para gravar o código para implementar a funcionalidade do que os clientes podem acessar o serviço da Web XML. Quando o servidor Web recebe uma solicitação para o serviço da Web XML, ele chama TempConvert3.asmx, que por sua vez chama este código.

Observação

Visual Studio 203

Para exibir o conteúdo do arquivo.asmx, no Solution Explorer, clique com o botão direito do mouse no arquivo.asmx e clique Open With no menu de atalho. Na caixa Open With de diálogo, selecione Source Code (Text) Editor e clique em OK

O arquivo.asmx Especifica a classe que é a implementação do serviço da Web XML na propriedade Class do arquivo WebService.asmx diretiva de processamento, que lembra o seguinte: <%@ WebService Class="TempConvert3.TempConvert3Class" %>

Dica

Se você optar por renomear a classe, certifique-se alterar o nome de classe no Class atributo da diretiva WebService.


1. Clique duas vezes o Component Designer na superfície do design para exibir o código para esse arquivo, TempConvert3Class.h.

2. Os métodos da classe TempConvert3Class fornecer a implementação do serviço da Web XML. Herda TempConvert3Class da classe System::Web::Services::WebService base. Localize a declaração de classe: public ref class TempConvert3Class : public System::Web::Services::WebService

Insira o seguinte código antes que declaração: [System::Web::Services::WebServiceAttribute(

Namespace="http://Walkthrough/XmlWebServices/", Description="A temperature conversion

XML Web Service.")]

Anexar o System::Web::Services::WebServiceAttribute atributo a essa classe torna possível para que você possa incluir informações adicionais sobre o serviço XML da Web, como especificar um espaço para nome e uma descrição. A propriedade description desse atributo está incluída na página de ajuda de Service. Para obter mais informações, consulte WebServiceAttribute.

3. Você irá adicionar um método público para esta classe e expor esse método como parte do serviço da Web XML. Localize o método HelloWorld de exemplo: public: [System::Web::Services::WebMethod] String ^HelloWorld(); // TODO: Add the methods

of your Web Service here

Substituir esse método com o seguinte: public: [System::Web::Services::WebMethod( Description="Converts temperatures from F to C.")]

double ConvertTemperature(double dFahrenheit);

Anexar o System::Web::Services::WebMethod atributo a este método indica que você deseja o método exposto como parte do serviço da Web XML. A propriedade description deste atributo está incluído na página ajuda de Service e na página de ajuda Service Methods. Para obter mais informações, consulte WebMethodAttribute.

Visual Studio 204

4. No Solution Explorer, localize TempConvert3Class.cpp na pasta Source Files do Projeto TempConvert3 e abrir este arquivo para edição.

5. Localizar e substituir o conteúdo do espaço para nome TempConvert3 com o seguinte: namespace TempConvert3 { double TempConvert3Class::ConvertTemperature(double

dFahrenheit) { return ((dFahrenheit - 32) * 5) / 9; } };





• Start Debugging

• Start Without Debugging

• View in Browser

Como um projeto Visual Studio, este XML Web Services tem configurações separadas para as versões de lançamento e depuração. Criadas essas configurações porque você criado este projeto usando o ASP.NET Web Service modelo de projeto, Visual Studio automaticamente e definir as opções padrão apropriado e outras configurações. Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Nessa explicação passo a passo, será colocar um ponto de interrupção no serviço XML da Web e use o Start Debugging método. Quando o serviço da Web XML estiver sendo executado, será anexar ao processo do sistema em que estiver sendo executado para depurá-la. Para obter mais informações, consulte Como Depurar XML Web Services em Código Não Gerenciado.

Antes da depuração, verifique as configurações de depuração. Para obter mais informações, consulte Preparação da Depuração: Web Services XML (C++).

Para usar um ponto de interrupção e iniciar o XML Web Services com depuração

1. No menu Debug, selecione New Breakpoint, e selecione Break at Function.

Na caixa New Breakpoint de diálogo, digite TempConvert3::TempConvert3Class::ConvertTemperature lado para Function e clique OK para colocar um ponto de interrupção na declaração ConvertTemperature de método.


Este comando instrui Visual Studio para executar o serviço XML da Web como ele faria normalmente. O Visual Studio compila o projeto e o implanta no servidor de desenvolvimento designado. Após a conclusão, o navegador padrão exibe o arquivo.asmx a partir do servidor de implantação.

Quando você abre um arquivo.asmx em um navegador, o XML Web Services retorna uma página Service auxiliar que fornece informações sobre o XML Web Services. Clicar no Service Description Link retorna um documento XML que contém o descrição do serviço formal do serviço XML Web. Para obter mais informações, consulte Descrição do XML Web Service.

Visual Studio 205

3. Na página TempConvert3Class Serviço da Web, clique no ConvertTemperature Link.

4. Na caixa dFahrenheit, digite o número 212, e clique no Invoke botão.

Quando processamento atinge a ConvertTemperature função, processamento pára. O depurador do Visual Studio realça a linha que contém o ponto de interrupção e, enquanto interrompido, você poderá executar uma variedade de tarefas. Para obter mais informações, consulte Debugger and Language Overview e Exibindo Dados no Depurador.

5. No menu Debug, clique Continue para continuar o processamento.

6. O XML Web Services responde retornando o valor convertido em um documento XML semelhante ao seguinte: <?xml version="1.0" encoding="utf-8" ?> <double


Para interromper executando o serviço XML da Web e retornar ao editor de código, no menu Debug, clique em Stop Debugging.


Para obter mais informações, consulte Passo-a-passo: Depuração de um serviço XML da Web.


Para implantar esse serviço XML da Web, você deve criar um projeto de implantação.


1. No menu File, aponte para New e clique em Project.

2. No painel Project types, expanda o Other Project Types nó e selecione Setup and Deployment. No painel Templates, clique em Web Setup Project.

3. Na caixa Name, digite TempConvert3WebSetup.

4. Na lista suspensa Solution Selecionar Add to Solution, e clique em OK

Observação


5. No painel esquerdo da guia File System (TempConvert3WebSetup), selecione Web Application Folder. Para obter mais informações, consulte Editor do sistema de arquivos.

6. No Solution Explorer, clique com o botão direito do mouse TempConvert3WebSetup, aponte para Add, e clique em Project Output.

7. Na caixa Add Project Output Group de diálogo, selecione Content Files. Para obter mais informações, consulte Como adicionar e remover resultados Project no editor do sistema de arquivos:.

o O grupo arquivos conteúdo consiste os seguintes arquivos para o serviço da Web XML: TempConvert3.asmx, Global.asax, e Web.config. Para

Visual Studio 206

obter mais informações, consulte Implantando serviços da Web XML em código gerenciado.

8. Clique em OK.

9. No painel esquerdo da guia File System (TempConvert3WebSetup), expanda Web Application Folder e localize a pasta rotulada bin.

10. Clique com o botão direito do mouse na bin pasta, aponte para Add, e clique em Project Output

11. Na caixa Add Project Output Group de diálogo, selecione Primary output e Debug Symbols. Para obter mais informações, consulte Como adicionar e remover resultados Project no editor do sistema de arquivos:.

o O grupo primário de saída consiste do projeto DLL, TempConvert3.dll, e suas dependências.

o O grupo símbolos de depuração consiste do arquivo PDB projeto, TempConvert3.pdb.

12. Clique em OK.

13. No Solution Explorer, clique com o projeto de implantação, e seguida, no menu de atalho, clique em Build.

Isso cria um arquivo do Windows Installer no diretório do projeto local. Executar este arquivo em um servidor Web para instalar este serviço da Web XML.

Para obter mais informações, consulte Implantando aplicativos e componentes.



• Passo-a-passo: Acessando um XML Web Service usando C++

• Passo-a-passo: Acessando um XML Web Service usando C++ e o CLR

Visual Studio 207

Walkthrough: Criando um serviço da Web XML usando ATL Server

Explicação passo a passo o seguir descreve o processo para criar um serviço XML da Web que converte temperaturas medidas em Fahrenheit para Celsius usando C++ e ATL Server.

ATL Server torna possível para os desenvolvedores a usar o Active Template Library para facilmente implementar serviços XML da Web como uma extensão ISAPI. Para obter mais informações, consulte Fornecer serviços XML da Web.


• Criar um serviço XML da Web usando o modelo do projeto Serviço da Web Server ATL.



Para concluir o explicação passo a passo, você precisará ter acesso a uma máquina que atende aos requisitos para criar um projeto da Web. Para obter mais informações, consulte Requisitos de hardware do Visual Studio.

Desde que os Serviços XML da Web usando ATL Server não responda a solicitações HTTP-GET ou POST HTTP-, você precisará criar um cliente que acesse este serviço da Web XML para explorar sua funcionalidade. Para obter mais informações, consulte Criando Serviços da Web XML.


O Visual Studio fornece um modelo de projeto Serviço da Web Server ATL para ajudá-lo criar serviços da Web XML usando ATL Server. Para obter mais informações, consulte Criar um Projeto ATL Server.

Para criar um projeto do serviço da Web ATL Server 1. No menu File, aponte para New, e clique Project para abrir a New Project

caixa de diálogo.

2. Selecione a Visual C++ Projects pasta, e, em seguida, clique no ATL Server Web Service ícone.

3. Na caixa Name, digite TempConvert4.

4. Clique OK Para iniciar o ATL Server Project Wizard.

5. No ATL Server Project Wizard, clique Finish para aceitar os padrões do projeto. Para obter mais informações, consulte Criar um Projeto ATL Server.

Observação

Você tem a opção de criar uma DLL combinado, que combina a funcionalidade ISAPI com o código do aplicativo. Esta opção está localizada na página Project Settings do assistente. No entanto, para essa explicação passo a passo, você irá criar DLLs separados.

6. O assistente cria uma solução, que contém dois projetos separados: um projeto do manipulador e um projeto de extensão ISAPI.

Visual Studio 208

Dica

O Assistente para Servidor ATL fornece um ReadMe.txt arquivo que descreve os projetos e arquivos gerados no Solution Explorer.

o Você irá escrever o código que fornece a funcionalidade para o serviço da Web XML no projeto do manipulador, que se torna o manipulador personalizado DLL posteriormente.

o Você pode personalizar o código usado para criar a extensão DLL ISAPI no projeto de extensão ISAPI. Neste projeto, você encontrará um arquivo ReadMe.txt mais que explica a finalidade de cada arquivo gerado. Para essa explicação passo a passo, você não necessitará personalizar a DLL ISAPI.

Você criará um projeto de implantação como a etapa final dessa explicação passo a passo. Para obter mais informações, consulte Criando Serviços da Web XML.


Você fornecer a funcionalidade do seu serviço da Web XML com o código você escrever para a classe do manipulador. Quando o servidor recebe uma solicitação para o serviço da Web XML, a extensão ISAPI chama este código.


1. No Solution Explorer, localize a Header Files Pasta do projeto TempConvert4, e seguida, clique duas vezes TempConvert4.h para abrir o arquivo para edição.

2. é ITempConvert4Service a definição de interface para o serviço da Web XML. Ele oferece suporte um método, que você irá declarar como ConvertTemperature. Localizar e substituir a definição de ITempConvert4Service interface de exemplo com o seguinte: __interface ITempConvert4Service { [id(1)] HRESULT ConvertTemperature( [in] double

dFahrenheit, [out, retval] double* pdCelsius); };

3. A CTempConvert4Service classe fornece a implementação de serviço da Web XML. Você irá adicionar um método público para esta classe e expor esse método como parte do serviço da Web XML. No mesmo arquivo, TempConvert4.h, localize e substituir a definição de classe de CTempConvert4Service exemplo com o seguinte: class CTempConvert4Service : public ITempConvert4Service { public: [ soap_method ] HRESULT

ConvertTemperature( /*[in]*/ double dFahrenheit, /*[out, retval]*/ double* pdCelsius) { if

(!pdCelsius) return E_INVALIDARG; *pdCelsius = ((dFahrenheit - 32) * 5) / 9; return S_OK; } };

// class CTempConvert4Service

Observação

Os atributos ATL Server que estão localizados entre as definições de interface e classe, request_handler e soap_handler, ajudar a simplificar a tarefa de fornecer a infra-estrutura de serviço da Web XML. Além disso, o soap_method atributo identifica qual método para expor como um serviço XML da Web. Para obter mais informações, consulte Atributos ATL Server.


Visual Studio 209



Para tornar seu XML Web Services disponível para outros, você deve implantá-lo em um servidor Web que seja acessível para os clientes que você queira dar suporte. Para implantar o serviço da Web XML em um servidor que não seja o servidor de desenvolvimento, você pode adicionar um projeto de instalação da Web ou você pode copiar os arquivos necessários para o servidor de destino manualmente.


1. No menu File, aponte para Add Project, e clique em New Project.

2. Selecione a Setup and Deployment Projects pasta, e clique em Web Setup Project.

3. Na caixa Name, digite TempConvert4WebSetup, e depois clique em OK.

Observação


4. No painel esquerdo da File System Editor, selecione Web Application Folder. Para obter mais informações, consulte Editor do sistema de arquivos.

5. No Solution Explorer, clique com o botão direito do mouse TempConvert4WebSetup, aponte para Add, e clique em Project Output

6. Na caixa Add Project Output Group de diálogo, selecione Content Files, Primary output e Debug Symbols. Para obter mais informações, consulte Como adicionar e remover resultados Project no editor do sistema de arquivos:.

o O grupo arquivos conteúdo consiste os arquivos restantes para o serviço XML da Web, tais como TempConvert4.htm e TempConvert4.disco.

o O grupo primário de saída consiste do projeto DLL, TempConvert4.dll, e suas dependências.

o O grupo símbolos de depuração consiste do arquivo PDB projeto, TempConvert4.pdb.

7. Clique em OK.

8. No Solution Explorer, clique com o botão direito do mouse TempConvert4WebSetup novamente, aponte para Add, e clique em Project Output

9. Na caixa Add Project Output Group de diálogo, alterar o projeto para TempConvert4Isapi, e selecione Primary output e Debug Symbols. Para obter mais informações, consulte Como adicionar e remover resultados Project no editor do sistema de arquivos:.

o O grupo primário de saída consiste do projeto DLL, TempConvert4Isapi.dll, e suas dependências.

o O grupo símbolos de depuração consiste do arquivo PDB projeto, TempConvert4Isapi.pdb.

10. Clique em OK.

Visual Studio 210

11. No painel esquerdo de expandir Web Application Folder, clique com o botão direito do mouse bin e, em seguida, clique em Delete. o File System Editor,

12. No Solution Explorer, clique com o TempConvert4WebSetup projeto, e no menu de atalho, clique em Build

Isso cria um arquivo do Windows Installer no diretório do projeto local. Executar este arquivo em um servidor Web para instalar este serviço da Web XML.

Para obter mais informações, consulte Implantando aplicativos e componentes.



• Passo-a-passo: Acessando um XML Web Service usando C++

• Passo-a-passo: Acessando um XML Web Service usando C++ e o CLR

Visual Studio 211

Passo-a-passo: Acessando um XML Web Service usando C++ e o CLR

Explicação passo a passo o seguir descreve o processo para acessar um serviço XML da Web de um aplicativo criado usando C++.


• Criar um aplicativo do cliente usando o CLR Console Application modelo de projeto.



• Execute o aplicativo do cliente no modo de depuração.


• Uma máquina atendendo aos requisitos encontrado no Requisitos de hardware do Visual Studio.

• Um serviço XML da Web criado de uma das orientações a seguir: o Explicação Passo a Passo: Criando um XML Web Services usando

Visual Basic ou Visual C# o Walkthrough: Criando um serviço da Web XML usando ATL Server o Passo-a-passo: Criando um XML Web Service usando C++ e o CLR


Para essa explicação passo a passo, você irá criar um aplicativo de console simples que acessa o serviço da Web XML TempConvert3, que era o nome dado para a Web XML serviço criado no Passo-a-passo: Criando um XML Web Service usando C++ e o CLR.

Observação

Para acessar uma implementação diferente do serviço da Web XML, a conversão de temperatura simplesmente substitua os nomes apropriados onde aparece o nome TempConvert3 em toda essa explicação passo a passo.

Para criar um aplicativo de console


2. Expanda o Visual C++ nó, e selecione CLR.

3. Clique no CLR Console Application ícone.

4. Alterar o nome do projeto para TempConvertClient3.



Descoberta de XML Web Services é o processo pelo qual um cliente localiza um XML Web Services e obtém sua descrição de serviço. O processo de descoberta de XML Web Services no Visual Studio envolve interrogar um site da Web seguindo um

Visual Studio 212

algoritmo predeterminado. A meta do processo é localizar a descrição de serviço, que é um documento XML que usa o WSDL (Web Services Description Language). Para obter mais informações, consulte Descoberta de XML Web Service.

A descrição de serviço descreve quais serviços estão disponíveis e como interagir com os serviços. Sem uma descrição de serviço, é impossível interagir com um XML Web Services programaticamente. Para obter mais informações, consulte Descrição do XML Web Service.

O aplicativo precisa um meio para se comunicar com o serviço da Web XML e para localizá-lo em tempo de execução. Adicionar uma referência da Web ao seu projeto para o XML Web Services faz isso por gerar uma classe proxy que interfaceia com o XML Web Services e fornece uma representação local do XML Web Services. Para obter mais informações, consulte Referências da Web e COMO: Gerar um Proxy de Serviço da Web XML.

Adicionar uma referência da Web

1. Na Solution Explorer, selecione o TempConvert3Client nó de projeto. No menu Project, clique em Add Web Reference.

2. Na caixa URL da caixa Add Web Reference de diálogo, digite a URL para obter o descrição do serviço do serviço XML Web você deseja acessar, such as http://localhost/TempConvert3WebSetup/TempConvert3.asmx. Clique no Go botão para recuperar informações sobre o serviço da Web XML.

Ou-

Se o serviço da Web XML existir na máquina local, clique no Web services on the local machine Link no painel do navegador. Clique no link para o serviço da Web XML TempConvert3 na lista fornecida para recuperar informações sobre o serviço da Web XML.

3. Na caixa Web reference name, renomear a referência da Web, a ConvertSvc Qual é o espaço para nome será usado para esta referência da Web.

4. Clique Add Reference para adicionar uma referência da Web para o destino XML Web Service. Para obter mais informações, consulte Como: Adicionar e remover referências da Web.

O Visual Studio baixa o descrição do serviço e adiciona-o ao seu projeto. Em seguida, ele gera uma classe de proxy e compila uma DLL do descrição do serviço. Finalmente, Visual Studio adiciona um novo arquivo WebService.h, de cabeçalho, ao seu projeto. Este arquivo de cabeçalho referencia espaços para nome do .NET Framework para usar os Serviços XML da Web e a DLL criado necessário. Se explorar o diretório do projeto local, você também encontrará o arquivo de fonte Visual C# para a DLL.


Depois de adicionar uma referência para o serviço da Web XML ao seu projeto, a próxima etapa é para criar uma instância de classe de proxy do serviço da Web XML. Você pode acessar os métodos do XML Web Service da mesma maneira que você acessar métodos qualquer do objeto chamando os métodos da classe de proxy. Quando o aplicativo chama esses métodos, o código gerado pelo Visual Studio trata as comunicações entre o aplicativo e o serviço da Web XML.

Acessar o XML Web Services

1. No Solution Explorer, localize TempConvertClient3.cpp na pasta Source Files e abra este arquivo para edição.

Visual Studio 213

2. Substituir o conteúdo do arquivo com o seguinte: #include "stdafx.h" #include "WebService.h" using namespace System; int main(void) { while

(true) { try { ConvertSvc::TempConvert3Class^ proxy = gcnew ConvertSvc::TempConvert3Class();

Console::Write("Temperature in degrees Fahrenheit: "); System::String^ sInput =

Console::ReadLine(); double dFahrenheit = System::Convert::ToDouble(sInput); double dCelsius

= proxy->ConvertTemperature(dFahrenheit); Console::Write("Temperature in degrees Celsius: ");

Console::WriteLine(dCelsius.ToString()); } catch (System::FormatException^ e) {

Console::WriteLine("Invalid value...exiting: {0}", e->Message); break; } } return 0; }

Observação

O nome da classe do serviço da Web XML gerado quando adicionando uma referência da Web pode diferir daquele mostrado acima como TempConvert3Class.




Quando você executar o aplicativo, ele acessa o serviço da Web XML e exibe o Celsius temperatura equivalente do Fahrenheit digitado.

Visual Studio oferece vários métodos para criar e executar um aplicativo de dentro o IDE,, como:

• Start Debugging


Como um projeto do Visual Studio, este aplicativo tem separadas configurações para versões liberação e DEBUG. Criadas essas configurações porque você criado este projeto usando o CLR Console Application modelo de projeto, Visual Studio automaticamente e definir as opções padrão apropriado e outras configurações. Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Nessa explicação passo a passo, será colocar um ponto de interrupção no aplicativo e use o Start Debugging método.

Antes da depuração, verifique as configurações de depuração. Para obter mais informações, consulte Preparação da depuração: Projetos de console.

Para utilizar um ponto de interrupção e iniciar o aplicativo com depuração

1. No Editor do código, coloque o cursor na linha de código que chama a função proxy: double dCelsius = proxy->ConvertTemperature(dFahrenheit);

2. Pressione F9 para colocar um ponto de interrupção nesta linha de código.

ou ——

Clique à esquerda dessa linha de código na margem indicador.

Para obter mais informações, consulte COMO: Depurar Código no Editor.


Este comando instrui Visual Studio para executar o aplicativo no depurador. O Visual Studio cria o projeto e inicia o aplicativo.

Visual Studio 214

4. Na janela do console, digite o número 212 e pressione ENTER.

Quando processamento atingir do ponto de interrupção, processamento pára. O depurador do Visual Studio realça a linha que contém o ponto de interrupção e, enquanto interrompido, você poderá executar uma variedade de tarefas. Para obter mais informações, consulte Explicação detalhada sobre o depurador e Exibindo Dados no Depurador.


O aplicativo cria uma mensagem de solicitação SOAP, que ele envia para o serviço XML da Web. Em retorno, o aplicativo recebe uma mensagem de resposta SOAP. O aplicativo então analisa a resposta e exibe uma mensagem indicando que 212 Fahrenheit graus é o equivalente de 100 Celsius graus.

Para parar execução do aplicativo e retornar ao editor de código, no menu Debug, clique em Stop Debugging.


Visual Studio 215

Passo-a-passo: Acessando um XML Web Service usando C++

Explicação passo a passo o seguir descreve o processo para acessar um serviço XML da Web de um aplicativo criado usando C++.


• Criar um aplicativo do cliente usando o modelo Project Win32.



• Execute o aplicativo do cliente no modo de depuração.


• Uma máquina que atenda aos requisitos encontrado no Requisitos de hardware do Visual Studio.

• Um serviço XML da Web criado de uma das orientações a seguir: o Explicação Passo a Passo: Criando um XML Web Services usando

Visual Basic ou Visual C# o Walkthrough: Criando um serviço da Web XML usando ATL Server o Passo-a-passo: Criando um XML Web Service usando C++ e o CLR


Para essa explicação passo a passo, você irá criar um aplicativo de console simples que acessa o serviço da Web XML TempConvert4, que era o nome dado para a Web XML serviço criado no Walkthrough: Criando um serviço da Web XML usando ATL Server.

Observação

Para acessar uma implementação diferente do serviço da Web XML, a conversão de temperatura simplesmente substitua os nomes apropriados onde aparece o nome TempConvert4 em toda essa explicação passo a passo.

Para criar um aplicativo do cliente do serviço XML da Web


2. Expanda a Visual C++ Projects pasta, e, em seguida, clique no Win32 Project ícone.

3. Alterar o nome do projeto para TempConvertClient4.

4. Clique OK Para iniciar o Win32 Application Wizard.

5. Na Win32 Application Wizard, execute o seguinte:

1. Na página Application Settings, clique em Console application.

2. Selecione ATL Para adicionar suporte de Biblioteca ATL.


Visual Studio 216


Descoberta de XML Web Services é o processo pelo qual um cliente localiza um XML Web Services e obtém sua descrição de serviço. O processo de descoberta de XML Web Services no Visual Studio envolve interrogar um site da Web seguindo um algoritmo predeterminado. A meta do processo é localizar a descrição de serviço, que é um documento XML que usa o WSDL (Web Services Description Language). Para obter mais informações, consulte Descoberta de XML Web Service.

O descrição do serviço ou contrato, descreve quais serviços estão disponíveis e como interagir com os serviços. Sem uma descrição de serviço, é impossível interagir com um XML Web Services programaticamente. Para obter mais informações, consulte Descrição do XML Web Service.

O aplicativo deve ter um meio para se comunicar com o serviço da Web XML e para localizá-lo. Adicionar uma referência da Web ao seu projeto para o XML Web Services faz isso por gerar uma classe proxy que interfaceia com o XML Web Services e fornece uma representação local do XML Web Services. Para obter mais informações, consulte Referências da Web.

Adicionar uma referência da Web

1. No menu Project, clique em Add Web Reference.

2. Na caixa URL da caixa Add Web Reference de diálogo, digite a URL para obter o descrição do serviço do serviço XML Web você deseja acessar, such as http://localhost/TempConvert4/TempConvert4Service.asmx. Clique no botão Go para recuperar informações sobre o XML Web Services.

Ou-

Se o XML Web Services está na máquina local, clique no link Web services on the local machine no painel do navegador. Clique no link para o serviço da Web XML TempConvert4 na lista fornecida para recuperar informações sobre o serviço da Web XML.

3. Na caixa Web reference name, renomeie a referência da Web para ConvertSvc, que é o namespace que você usará para essa referência da Web.

4. Clique Add Reference para adicionar uma referência da Web para o destino XML Web Service. Para obter mais informações, consulte Como: Adicionar e remover referências da Web.

O Visual Studio gera um novo arquivo de cabeçalho mas não adiciona-lo para o projeto. No entanto, ele não salvar o arquivo de cabeçalho gerado para a pasta do projeto. O nome do arquivo de cabeçalho depende do serviço da Web XML você optar por acessar. Este arquivo de cabeçalho é re-Generated sempre que você criar o projeto. Para obter o nome correto do arquivo de cabeçalho, examine o conteúdo da seção janela saída do log de compilação (BuildLog.htm no diretório Arquivos intermediário) ou Output Window o. O nome de arquivo correto aparece em uma linha que lembra o seguinte: /out:ConvertSvc.h. Para exibir no menu View Aponte para Other Windows e clique em Output. o Output Window,

Para obter mais informações, consulte Como: Adicionar e remover referências da Web.


Visual Studio 217

Após seu projeto tem uma referência para o serviço XML da Web, a próxima etapa é para criar uma instância da classe proxy. Para obter mais informações, consulte Criar clientes do serviço XML da Web.

Você pode acessar os métodos do XML Web Service da mesma maneira que você acessar métodos qualquer do objeto chamando os métodos da classe de proxy. Quando o aplicativo chama esses métodos, o código gerado pelo Visual Studio trata as comunicações entre o aplicativo e o serviço da Web XML. Para obter mais informações, consulte Criar clientes do serviço XML da Web.

Acessar o XML Web Services

1. No Solution Explorer, localize stdafx.h na pasta Header Files e abra este arquivo para edição.

2. Adicione o seguinte # definir instruções (em negrito) após o # existente definir instrução WIN32_LEAN_AND_MEAN: #define WIN32_LEAN_AND_MEAN // Disable client timeout for testing. Default is 10000

milliseconds. #define ATL_SOCK_TIMEOUT INFINITE // Minimum system requirements are

Windows 98, Windows NT 4.0, or later #define _WIN32_WINDOWS 0x0410

3. Add the following #include statements after the existing #include for <atlbase.h>: #include "ConvertSvc.h" #include <conio.h> #include <iostream>

Observação

O nome do arquivo de cabeçalho gerado quando adicionando uma referência da Web pode diferir daquele mostrado acima como ConvertSvc.h. Para obter o nome correto do arquivo de cabeçalho, examine o conteúdo da seção janela saída do log de compilação (BuildLog.htm no diretório Arquivos intermediário) ou Output Window o. O nome de arquivo correto aparece em uma linha que lembra o seguinte: /out:ConvertSvc.h. Para exibir no menu View Aponte para Other Windows e clique em Output. o Output Window,

4. No Solution Explorer, localize TempConvertClient4.cpp na pasta Source Files e abrir este arquivo para edição.

5. Primeiro, você criará uma instância da classe de proxy do serviço da Web XML. Em seguida, você irá levar um valor, que o console fornece, e fazer uma chamada ao método do serviço ConvertTemperature da Web XML chamando o método na classe proxy. Você irá exibir o valor retornado pelo serviço da Web XML no console. Insira o código a seguir:

Observação

O código a seguir usa uma classe denominada TempConvert4Service::CTempConvert4Service. Aponte para o arquivo de cabeçalho gerado na sua pasta do projeto para determinar o nome de classe adequado para o serviço da Web XML e substitua-onde TempConvert4Service::CTempConvert4Service. aparece o código abaixo

6. #include "stdafx.h" void AccessService(){ using namespace std; double dFahrenheit = 0.0;

double dCelsius = 0.0; TempConvert4Service::CTempConvert4Service ws; while (1){ cout <<

"Enter a temperature in degrees Fahrenheit: "; cin >> dFahrenheit; if (!cin.good()){ cout << "Not a

temperature" << endl; break; } HRESULT hr = ws.ConvertTemperature(dFahrenheit, &dCelsius);

if (SUCCEEDED(hr)) cout << dFahrenheit << " F = " << dCelsius << " C\n" << endl; else cout <<

Visual Studio 218

"An error occurred: " << hr << endl; } } int _tmain(int argc, _TCHAR* argv[]){ if

(SUCCEEDED(CoInitialize(NULL))){ AccessService(); CoUninitialize(); } return 0; }


8. No menu Build , clique em Build Solution.


Quando você executar o aplicativo, ele acessa o serviço da Web XML e exibe o Celsius temperatura equivalente do Fahrenheit digitado.

O Visual Studio oferece vários métodos para criar e executar um aplicativo de IDE, como:

• Start (with Debugging)


Como um projeto do Visual Studio, este aplicativo tem separadas configurações para versões liberação e DEBUG. Criadas essas configurações porque você criado este projeto usando o modelo do projeto Project Win32, Visual Studio automaticamente e definir as opções padrão apropriado e outras configurações. Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Nessa explicação passo a passo, será colocar um ponto de interrupção no aplicativo e use o Start (with Debugging) método.

Para utilizar um ponto de interrupção e iniciar o aplicativo com depuração

1. No menu Debug, clique em New Breakpoint.

Na guia Function, digite AccessService na caixa Function e clique OK para colocar um ponto de interrupção na declaração AccessService de método.

2. No menu Debug , clique em Start.

Dica

é F5 o atalho do teclado padrão para Start.

3. Este comando instrui Visual Studio para executar o aplicativo no depurador. O Visual Studio compila o projeto e o implanta no servidor de desenvolvimento designado. Após a conclusão, o navegador padrão exibe o arquivo.asmx a partir do servidor de implantação.

4. Para interromper a execução do XML Web Service e retornar para o Code Editor, feche o navegador.

ou ——

No menu Debug, clique em Stop Debugging.

Dica

é SHIFT+F5 o atalho do teclado padrão para Stop Debugging.

5. Na janela do console, digite o número 212 e pressione ENTER.

Visual Studio 219

Quando processamento atinge a AccessService função, processamento pára. O depurador do Visual Studio realça a linha que contém o ponto de interrupção e, enquanto interrompido, você poderá executar uma variedade de tarefas. Para obter mais informações, consulte Explicação detalhada sobre o depurador e Exibindo Dados no Depurador.


Dica

é F5 o atalho do teclado padrão para Continue.

7. O aplicativo cria uma mensagem de solicitação SOAP, que ele envia para o serviço XML da Web. Em retorno, o aplicativo recebe uma mensagem de resposta SOAP. O aplicativo então analisa a resposta e exibe uma mensagem indicando que 212 Fahrenheit graus é o equivalente de 100 Celsius graus.

8. Para parar execução do aplicativo e retornar ao editor de código, no menu Debug, clique em Stop Debugging.

9. No menu Debug, clique em Clear All Breakpoints.

Dica

+ CtrlShift + F9 é o atalho do teclado padrão para Clear All Breakpoints.

Visual Studio 220

Passo-a-passo: Criando um aplicativo distribuído

Nessa explicação passo a passo, você criará um aplicativo de várias camadas, distribuídos, intranet. O aplicativo consiste em três camadas lógicas: Dados, objeto comercial, e interface de usuário. A camada de dados é um banco de dados no SQL Server. A camada de negócio-Objeto tratará acessar os dados e distribui-lo para os clientes. A camada da interface do usuário consistirá em tanto um aplicativo baseado na Web e um aplicativo Windows tradicional.

Você criará o aplicativo é um aplicativo de dados simples com pesquisa e editar. Você criará um cliente Windows para exibir a tabela Clientes do banco de dados de exemplo Northwind SQL Server. Você criará um serviço XML da Web para recuperar dados que contém informações clientes a partir do banco de dados. Você então criará um aplicativo do Windows que irão se comunicar com este serviço XML da Web para recuperar um DataSet que contém as informações do autor.

Você criará o serviço da Web XML e o cliente aplicativos no mesmo servidor, embora o banco de dados pode residir em outro servidor. Tanto o servidor de aplicativos e o servidor de banco de dados precisará que residam na mesma intranet. Essa organização de projetos, você pode usar a autenticação do Windows para obter acesso ao banco de dados e testar seu aplicativo. No mesmo, essa organização remove muitos dos detalhes de acessar recursos para que você pode ver a interação do serviço XML da Web e os aplicativos cliente. Essa organização pode não ser exatamente a arquitetura você deseja para aplicativos você Criar por conta própria.

Pré-requisitos


• Acesso a um servidor com o exemplo de SQL Server do Northwind, configurado para autenticação Integrated Windows. O banco de dados Northwind é um banco de dados de exemplo que você pode instalar com SQL Server.

• Uma compreensão básica de como dados são manipulados no Visual Studio .NET. Para obter mais informações, consulte Visão geral do ADO.NET.

Processo para criar um aplicativo distribuídos

Um cenário possível para desenvolver um aplicativo distribuído consiste em criar uma camada ao mesmo tempo, talvez começando com a camada de dados, e mover para o objeto regra negócio-camada intermediária, e finalmente criar a interface do usuário. Para essa explicação passo a passo, os dados já foi gerado e está disponível no banco de dados Northwind no SQL Server. Portanto, o explicação passo a passo iniciará com criando o objeto — comercial o serviço — da Web XML seguido por criando as interfaces — dois usuário uma página de formulários da Web e um formulário do Windows. O processo para essa explicação passo a passo é a seguinte:

1. Criar o objeto comercial da camada intermediária

1. Criar um Projeto Serviço da Web ASP.NET

2. Criar e configurar uma conexão de banco de dados e um esquema DataSet

3. Expor DataSet do seu objeto comercial

2. Criar a interface de usuário

Visual Studio 221

1. Criar uma interface do usuário do Windows

3. Implantar a solução ou adicionar mais recursos

Criar o objeto Business Tier intermediária- O objeto comercial você criar será executado em um servidor Web para fornecer o desempenho e escalabilidade necessária para um aplicativo distribuído. Você além disso, será implementar o objeto comercial como um serviço XML da Web para que os clientes podem usar protocolos padrão da Internet para se comunicar com o objeto comercial de qualquer plataforma. Para obter detalhes, consulte Programação na Web com XML Web Services.

O componente serviço XML da Web nessa explicação passo a passo, será mantenha as conexões de dados e definição DataSet. Métodos Serviço da Web XML depois serão adicionados para expor o DataSet, que tornará possível para outros aplicativos para exibir e modificar DataSet.

O serviço da Web XML será expor dois métodos. O primeiro, GetCustomers,. retornará um DataSet a partir do banco de dados O segundo, UpdateCustomers,. irá atualizar o banco de dados com alterações do usuário

Para criar um projeto Serviço da Web ASP.NET

1. No menu File, aponte para New então Web Site para exibir a New Web Site caixa de diálogo.

2. Selecione ASP.NET Web Service no painel Visual Studio Installed Templates.

3. Na caixa Location, digite o nome do servidor Web (no seu computador de desenvolvimento) com o nome do projeto, http://ServerName/CustomersWebService,. e, em seguida clique em OK

Dica

Como o servidor Web estiver em seu computador, poderá usar o nome do servidor LOCALHOST.

4. O CustomersWebService projeto é adicionado à solução. Observe que o serviço da Web for inicializado no idioma padrão que você escolheu para Visual Studio.

5. No Solution Explorer, clique Service.asmx para selecioná-la.

6. Na janela Propriedades, defina a File Name propriedade de Service para CustomersService.

Nesse componente será criar uma conexão com o armazenamento de dados e obter uma instância dos dados usando um DataSet.

Criar e configurar uma conexão de banco de dados e um esquema DataSet

Do TableAdapter Configuration Wizard irá adicionar um DataSet ao seu aplicativo e depois usar para gerar um tipo TableAdapter específico à tabela Clientes do banco de dados.

Para criar um adaptador conexão e dados de banco de dados

1. No menu Website, escolha Add New Item. A Add New Item caixa de diálogo será aberta.

2. Selecione Dataset e clique em Add

Visual Studio 222

DataSet é adicionado ao seu projeto, e a TableAdapter Configuration Wizard. for iniciado

3. No TableAdapter Configuration Wizard, clique New Connection para criar sua conexão.

A Add Connection caixa de diálogo Abrir, e Microsoft SQL Server é Pre-Selected como o tipo de banco de dados

4. Na caixa Add Connection de diálogo, digite o nome do SQL Server onde o banco de dados Northwind está instalado. Se você tiver SQL Server no computador local, digite (local).

5. Selecione Use Windows Authentication para as informações de logon.

Observação

Se você não faça ter integrada segurança definida backup em seu sistema, consulte o administrador de rede.

6. Selecione o Northwind banco de dados a partir da lista.

7. Clique Test Connection para validar as informações fornecidas, e, em seguida, clique OK para estabelecer a conexão.

Uma nova conexão de banco de dados é criado e adicionado à caixa suspensa no TableAdapter Configuration Wizard.

Observação

Se a conexão de banco de dados falhar, consulte o administrador do banco de dados.

8. Verifique se seu banco de dados está selecionado na caixa suspensa e clique em Next.

9. Clique Next novamente para salvar a seqüência de conexão para o arquivo de configuração.

10. No painel Choose a Command Type, verifique se que Use SQL Statements está selecionado e clique em Next.

11. No painel, tipo SELECT * FROM Customers e Enter a SQL Statement Clique em Next.

12. Na, clique Choose Methods to Generate Finish painel.

Você criou uma conexão com o banco de dados, um dataset digitado, e gerado o adaptador de tabela que interage com o banco de dados.

13. No menu File, escolha Save All

Você precisará definir as configurações de segurança do seu projeto para trabalhar com segurança integrada. É feito isso desativando o acesso anônimo e ativar a representação.

Para configurar a autenticação integrada do Windows para o projeto, você deve alterar os arquivos de projeto e configurar o projeto usando a Internet Information Services ferramenta.

Visual Studio 223

Para configurar a autenticação integrada do Windows

1. Inicie a Internet Information Services ferramenta. Administrative Tools do Control Panel ele pode ser executado a partir de. (Para obter mais informações sobre como iniciar essa ferramenta, consulte o Windows ajuda documentação).

2. Expanda o nó para o servidor.

3. Expanda o Default Web Site nó.

4. Clique com o botão direito do mouse no nó de CustomersWebService e escolha Properties No menu de atalho.

5. Clique na Directory Security guia.

6. Clique no Edit botão na seção Anonymous access and authentication control.

7. Desmarque a Anonymous Access caixa de seleção.

8. Marque a Integrated Windows authentication caixa de seleção. Agora você configurou seu diretório de serviço da Web XML.

9. Retornar para o projeto no Visual Studio, clique duas vezes o arquivo web.config no Solution Explorer.

10. Adicionar a seguinte marca na linha após a <system.web> marca para configurar a segurança integrada para o serviço da Web XML. <identity impersonate="true"/>

Expor o customersDataTable de seu objeto Business

A próxima etapa nessa explicação passo a passo é para expor o objeto DataSet você apenas criado a partir seu objeto comercial. Essa ação tornará DataSet disponíveis para aplicativos Windows ou da Web para usar.

Adicionar métodos para o serviço da Web XML

1. Partir do Build menu, escolha Build Solution para a criação da solução.

2. Na Solution Explorer, clique duas vezes Service.vb para abrir o Editor de Código.

3. Adicionar uma linha para o corpo de classe para criar uma nova instância do adaptador de tabela como mostrado abaixo:

Visual Basic Dim myAdapter As New DataSetTableAdapters.CustomersTableAdapter

DataSetTableAdapters.CustomersTableAdapter myAdapter = new

DataSetTableAdapters.CustomersTableAdapter();

4. Adicionar um método denominado GetCustomers para entregar uma DataTable para o cliente.

Esse método, mostrado a seguir retorna uma DataTable preenchido com os dados do cliente.

Visual Basic <WebMethod()> Public Function GetCustomers() As _ DataSet.CustomersDataTable Return

myAdapter.GetData End Function

C#

Visual Studio 224

[WebMethod] public DataSet.CustomersDataTable GetCustomers() { Return

myAdapter.GetData(); }

5. Adicionar um método denominado UpdateCustomers para propagar alterações a partir do cliente de volta para o banco de dados.

Esse método, mostrado abaixo, apresenta um DataSet.CustomersDataTable parâmetro que contém os dados alterados e atualiza o banco de dados através do CustomersTableAdapter.Update método. O Update método aceita as alterações no DataSet. DataSet é retornada para o cliente. O cliente então usará este DataSet retornado para atualizar sua própria instância da Customers DataTable. Para obter informações sobre o Update método e aceitando alterações em um DataSet, consulte Introdução aos adaptadores de dados.

C# [WebMethod] public void UpdateCustomers(DataSet.CustomersDataTable customerChanges) {

myAdapter.Update(customerChanges); }

Observação

Em um aplicativo de produção, você deve adicionar a verificação de erros e exceção tratamento para esses métodos.

6. Partir do File menu, escolha Save All.

7. Partir do Build menu, escolha Build Solution.

Nas seções anteriores, você ter criado um objeto comercial da camada intermediária que contém um DataSet acoplado a um banco dados do SQL Server. Você adicionou código ao meio-nível CustomersWebService da Web XML serviço para obter dados de uma fonte de dados e atualizar a fonte de dados com alterações. Do GetCustomers o cliente acessar essas funções através de e UpdateCustomers métodos Serviço da Web XML.

Crie a interface de usuário

Depois de criar um objeto comercial da camada intermediária para acesso a dados e expondo-lo como um serviço XML da Web, a próxima etapa é para criar o cliente interfaces. Há dois cenários nessa explicação passo a passo: um Windows Form tradicionais e uma página de formulários da Web. Ambos são criados, neste exemplo como separados projetos na mesma solução. Não é necessário para que você possa criar as duas interfaces.

Interface do Usuário do Windows

Uma interface do Windows usa recursos do computador cliente para manipular parte do processamento do aplicativo. Geralmente, uma interface do Windows fornece maior funcionalidade e uma experiência mais rica que uma interface baseada na Web. Não é menor de uma carga no servidor que com um front-end da Web, porque o servidor não não precisa para executar todos os a lógica do aplicativo. Além disso, uma interface do Windows pode aproveitar dos recursos disponíveis através do sistema operacional, incluindo chamadas para o sistema de arquivos e o registro.

O aplicativo do Windows, que consiste em um formulário do Windows, irá conter uma referência da Web para CustomersWebService. Os dados no banco de dados serão exibidos em um DataGridView controle quando um Load botão no

Visual Studio 225

formulário é clicado. Esse comportamento de carregamento é implementado por chamar método do serviço GetCustomers da Web XML. O DataGridView controle permite direta edição, com alterações de dados passadas diretamente para o conjunto de dados subjacente. O formulário também terá um botão Salvar. O código para este botão será chamar método do serviço UpdateAuthors da Web XML para salvar as alterações de volta para o banco de dados.

Para criar o aplicativo Windows

1. No menu File, aponte para Add e escolher New Project, para abrir a Add New Project caixa de diálogo.

2. Selecione Windows Application no painel Visual Studio Installed Templates.

3. Nome do Projeto CustomersWinClient e selecione um local para o projeto, seguida, clique em OK.

O CustomersWinClient projeto é adicionado à solução. Form1 automaticamente é adicionado ao projeto e aparece o Windows Forms Designer.

4. Adicionar uma referência da Web para o projeto Serviço da Web ASP.NET criado anteriormente:

1. No Solution Explorer, clique com o CustomersWinClient projeto, e clique Add Web Reference no menu de atalho

2. Clique em Web Services In This Solution e clique em CustomersService.

3. Clique em Add Reference.

Agora você pode criar uma instância do DataSet DataSet em seu aplicativo.

Para adicionar os controles ao formulário

1. Arraste um DataGridView controle da guia Data da caixa de ferramentas para o formulário.

2. Do Toolbox arraste um Button controle da guia Common Controls Da para o formulário. Defina propriedades do botão Name para LoadData e sua Text propriedade para Load.

3. Do Toolbox Arraste outro Button controle da guia Common Controls Da para o formulário. Defina propriedades do botão Name para SaveData e sua Text propriedade para Save.

4. Clique duas vezes no formulário para abrir o Code Editor.

5. Sob a declaração de classe, criamos uma instância do localhost.DataSet Como mostrada abaixo:

Visual Basic Dim CustomerData As New localhost.DataSet.CustomersDataTable

localhost.DataSet.CustomersDataTable CustomerData = new

localhost.DataSet.CustomersDataTable();

Para adicionar código para o LoadData e SaveData botões

1. No menu View, clique em Designer. Clique duas vezes no LoadData botão para criar um manipulador de eventos vazio para o Click evento. Métodos Serviço da Web XML são chamados, criando uma instância da classe do

Visual Studio 226

serviço primeiro e depois chamar os métodos do serviço. Nesse caso, o GetCustomers método for chamado. DataSet retornado será mesclado com DataSet CustomerData . A Credentials propriedade do serviço da Web XML é usada para passar sua identidade para o serviço da Web XML, que por sua vez passa-no para o servidor de banco de dados. Adicione o código mostrado abaixo para o método.

Observação

Se o serviço XML da Web não está sendo executado no computador local, você precisará substituir localhost no exemplo de código com o nome do servidor que executa o serviço da Web XML.

C# private void LoadData_Click(object sender, System.EventArgs e) { localhost.Service ws = new

localhost.Service(); ws.Credentials = System.Net.CredentialCache.DefaultCredentials;

CustomerData.Merge(ws.GetCustomers()); DataGridView1.DataSource = CustomerData; }

2. No menu View, clique em Designer. Clique duas vezes no SaveData botão para criar um manipulador de eventos vazio para o Click evento.

Observação

Em um aplicativo de produção, seria deseja considerar questões de simultaneidade de dados na etapa. Para obter mais informações, consulte Introdução ao Concurrency de dados no ADO.NET.

3. Adicione o seguinte código para os métodos:

C# private void SaveData_Click(object sender, System.EventArgs e) { if (CustomerData.HasChanges()) {

localhost.Service ws = new localhost.CustomersService(); ws.Credentials =

System.Net.CredentialCache.DefaultCredentials; ws.UpdateCustomers(CustomerData); } }

Para executar o aplicativo

1. Partir do File menu, escolha Save All.

2. Selecione CustomersWinClient no Solution Explorer, clique com o botão direito do mouse e escolha Set as StartUp Project.

3. Pressione CTRL + F5 para executar o aplicativo.

Uma janela é exibida que contém um DataGridView vazia.

4. Clique Load para preencher a tabela, faça algumas alterações, e seguida, clique Save para salvar as alterações feitas.

Na seção anterior, você adicionou um projeto do Windows Forms para a solução para atuar como uma interface do Windows. Você conectado o formulário Windows ao serviço da Web XML você criado a primeira seção e usado DataGridView e Button controles para criar a interface do usuário para carregar e atualizando os dados.

Próximas etapas

Visual Studio 227

Neste ponto você pode implantar seu aplicativo ou, se que você deseja dar a funcionalidade adicional de programa. Algumas das sugestões são fornecidos abaixo.

• Implantar a solução

Você pode implantar seu aplicativo da Web em um servidor ou criar um projeto de instalação para o aplicativo Windows. Para obter informações sobre como implantar seu aplicativo Windows consulte Passo a passo: Distribuindo um aplicativo baseado no Windows.

• Acesso da Web à Internet de suporte

Essa explicação passo a passo trata autenticação para aplicativos da intranet. O aplicativo pode ser acessado pelos usuários através da Internet, portanto você pode precisa uma solução de autenticação diferente. Para obter mais informações, consulte Usando a autenticação do IIS com representação ASP.NET. Você também pode investigar criando uma interface da Web para seu aplicativo em combinação com protocolos de acesso da Web.

• Considere segurança

Essa explicação passo a passo usa autenticação integrada do Windows para controlar o acesso ao banco de dados. A segurança de banco de dados é apenas uma preocupação para aplicativos da Web. Para obter uma discussão de segurança de aplicativo da Web, consulte Práticas recomendadas de segurança básicas para aplicativos da Web (Visual Studio).

Visual Studio 228

Controle de Código Fonte para o Visual Studio

Sem sair do ambiente de desenvolvimento, você pode gerenciar seus projetos individuais e de equipe facilmente usando os recursos do controle de código fonte do Microsoft Visual Studio. O controle de código fonte do Visual Studio permite que você:

• Gerencie o acesso ao banco de dados. O controle de código fonte do Visual Studio fornece suporte ao acesso de arquivos compartilhados e individuais. Também provê mecanismos para mesclagem de arquivos.

• Recuperar versões sucessivas de itens sob controle de versão. A maioria dos pacotes do controle de código fonte do Visual Studio armazenam dados que distinguem as diferentes versões de um item sob controle de versão.

• Manter o histórico detalhado dos itens sob controle de versão. Muitos pacotes fornecem mecanismos para armazenar e recuperar o histórico de um item, por exemplo, data e hora de criação.

• Trabalhar de modo colaborativo em projetos e soluções. Com o compartilhamento de arquivos, é possível que diferentes projetos e soluções compartilhem o mesmo item sob controle de versão. Alterações feitas em um item compartilhado são refletidas em todos os projetos e soluções.

• Automatizar as operações de controle de código fonte mais comuns. Por exemplo, um pacote do controle de de código fonte do Visual Studio pode definir uma interface de linha de comando que ofereça suporte a recursos importantes do controle de código fonte. Você pode usar essa interface em arquivos em lotes para automatizar as tarefas de controle de código fonte executadas regularmente.

• Recuperar exclusões acidentais. O controle de código fonte do Visual Studio fornece suporte a restauração da última versão do arquivo em que foi realizado o check-in.

• Economizar espaço em disco no pacote do controle de código fonte e no servidor associado.

Introdução ao controle de origem O Visual Studio oferece suporte ao controle de origem usando a camada Visual Studio Integration Protocol (VSIP) no seu Integrated Development Environment (IDE). VSIP pode hospedar uma variedade de pacotes de controle de origem, geralmente implementados como plug-ins escritos para os protocolos apropriados. Um exemplo de um plug-in de controle de origem é o plug-in SourceSafe LAN suportado pelo Visual SourceSafe. Para obter detalhes do plug-in, consulte a ajuda do Visual SourceSafe.

Observação

O Visual Studio trata pacotes de controle de origem como plug-ins, embora eles possam ser implementados como outros tipos de módulos de software.

Visual Studio 229

O controle de origem do Visual Studio é simplesmente um ambiente para plug-ins de controle de origem de terceiros. Por isso, sua funcionalidade só é ativada pela instalação de um plug-in. Para usar um plug-in de controle da origem de terceiros, você deve, geralmente, instalar o aplicativo de terceiros e/ou o(s) plug-in(s) de controle de origem nos computadores cliente e servidor para seu site. Depois de instalar como indicado pelas instruções de terceiros, sua funcionalidade estará disponível através do Visual Studio. As operações que estão ativas são variáveis, dependendo do plug-in de controle de origem. Você deve consultar a documentação de terceiros para detalhes operacionais de pacotes específicos.

Consulte "Visão Geral (controle de origem)" na ajuda do Visual Studio para obter detalhes de design de controle de origem no Visual Studio. Esta seção da Ajuda também fornece todas as informações que serão necessárias para desenvolver um pacote de controle de origem de terceiros que seja compatível com Visual Studio.

Noções básicas de controle de origem suportados pelo Visual Studio

O suporte de controle de origem básico no Visual Studio inclui a configuração de plug-in de controle de origem e opções de ambiente, comutação de plug-in, acesso ao banco de dados, versionamento e manipulação de projetos do Visual Studio, soluções e arquivos e metadados associados. O controle de origem no Visual Studio também aplica protocolos do controle de acessos ao banco de dados, por exemplo, o estilo de trabalho Lock-Modify-Unlock, no qual um usuário que quer modificar um arquivo deve verificá-lo exclusivamente.

É importante lembrar que você deve usar controle de origem em mecanismos do Visual Studio para interagir com um plug-in de controle de origem. Não use outras aplicações de cliente apresentadas por terceiros que forneçam o plug-in, por exemplo, Visual SourceSafe Explorer. O uso apropriado dos mecanismos de controle de origem no Visual Studio garante que somente arquivos corretos sejam adicionados ao controle de origem e que os arquivos de projeto e solução do Visual Studio sejam atualizados com os detalhes corretos do plug-in específico.

Configuração de Plug-in de Controle de Origem e Comutação

O controle de origem do Visual Studio suporta configuração e comutação de plug-in através da entrada Source Control na caixa de diálogo Options. Esta entrada é acessível selecionando-se Options no menu Tools do Visual Studio. Você usará a caixa de diálogo Options para selecionar o plug-in que você deseja utilizar para controle de origem, e configurar as opções de ambiente para o plug-in.

Antes que você e sua equipe possam aproveitar as vantagens dos recursos de controle de origem no Visual Studio IDE, você deve:

• Determinar se qualquer plug-in de controle de origem está disponível.

• Se o plug-in de controle de origem que você deseja usar não estiver instalado em seu computador, instale o produto de terceiros que ofereça suporte ao plug-in e reinicie o Visual Studio para registrá-lo.

• Criar um banco de dados de controle de origem de acordo com a funcionalidade do determinado plug-in.

• Envie um link, com o local do banco de dados, para todos os membros da equipe.

Acesso ao Banco de dados

Comandos básicos de acesso ao banco de dados, por exemplo, Check Out e Add to Source Control, estão disponíveis no menu File do Visual Studio. No entanto, esses comandos são ativados somente depois que você tiver escolhido o plug-in de

Visual Studio 230

controle de origem que deseja usar. Quando você usa um dos comandos básicos de acesso ao banco de dados, o plug-in que você tiver escolhido chama a correspondente funcionalidade de terceiros e/ou o ambiente para concluir a operação associada.

Algumas operações de acesso são ativadas somente com o plug-in selecionado, enquanto outras operações estão somente disponíveis quando você também tiver selecionado um projeto do Visual Studio, solução, ou arquivo no Solution Explorer do Visual Studio. Por exemplo, você pode usar um comando Add to Source Control depois de ter escolhido um plug-in. Entretanto, para usar um comando Check In, você deve ter um item selecionado no Solution Explorer.

Manipulação de arquivo pelo controle de origem

Você pode adicionar os seguintes arquivos ao controle de origem do Visual Studio:

• Arquivos de solução (*.SLN).

• Arquivo de projeto, por exemplo, arquivos *.csproj, *.vbproj.

• Arquivos de configuração de aplicativos com base em XML, usados para controlar comportamento em tempo de execução de um projeto do Visual Studio.

Arquivos que você não pode adicionar ao controle de origem incluem o seguinte:

• Arquivos de opção de solução de usuário (*.suo).

• Arquivos de opção de projeto de usuários, por exemplo, arquivos *.. csproj.user, *. vbproj.user

• Arquivos de informação da Web, por exemplo, *.csproj.webinfo, *. vbproj.webinfo, que controlam o local da raiz virtual de um projeto da Web

• Criar arquivos de saída, por exemplo, arquivos *.dll e *.exe.

A propagação da alteração do espaço para nome

O controle de origem do Visual Studio oferece suporte à propagação de alteração do espaço para nome em plug-ins controle de origem. Propagação de alteração aplica-se a operações de exclusão, renomeação e mudança de local. Quando você solicitar uma operação para qual a propagação de alteração estiver ativada, o plug-in de controle de origem irá alterar a cópia de trabalho do item controlado por fonte, a cópia principal no banco de dados, e as cópias de outros usuários, quando você fizer o check-in no item e os outros usuários o recuperarem.

Como Controle de Origem Trata Soluções e Projetos

Quando você adiciona uma solução ou projeto ao controle de origem, a primeira coisa que um plug-in de controle de origem deve fazer é identificar uma raiz única para o item que está sendo adicionado. Esta raiz é um caminho ao diretório pai de todas as pastas de trabalho e arquivos que compõem a solução ou projeto.

Uma raiz única geralmente mapeia para um caminho físico no disco. Contudo, se uma solução contém arquivos ou projetos que residem em mais de uma unidade de disco, não há nenhuma pasta física à qual uma raiz única pode fazer o mapa. Uma solução pode mapear a unidade de disco, mas a raiz única de um controle de origem, não. Para apoiar esta situação, o controle de origem do Visual Studio apóia o conceito de uma raiz super-unificada. Este tipo da raiz é um contêiner virtual e

Visual Studio 231

todos os projetos e os arquivos em uma solução controlada por fonte estão localizados abaixo dele.

Quando você adiciona uma solução usando um plug-in de controle de origem com recursos avançados, o plug-in cria uma pasta raiz vazia de solução no banco de dados. Esta pasta conterá todos os itens em uma solução controlada por fonte. Por padrão, essa pasta é < nomedasolucao >.root.

Observação

Quando você adicionar um projeto único ao controle de origem, a pasta .root não será criada.

O uso de solução raiz oferece os seguintes benefícios:

• Menos prompt. A solução raiz minimiza o número potencial de ligações de controle de origem para uma solução e, assim, minimiza o número de avisos aos usuários quando você adiciona uma solução para controle de origem e executa outras tarefas.

• Encapsulamento do projeto. A solução raiz garante que todos os projetos em uma solução possam ser identificados como pertencentes ao mesmo conjunto, mesmo quando uma ou mais projetos residam em diferentes partições ou computadores.

Você pode desativar a criação de pasta < nomedasolucao >.root, mas isso não é recomendável. Para mais informações, consulte COMO: desativar a criação da pasta < nomedasolucao>.root.

Soluções no Visual Studio são bem-formadas ou não. Uma solução bem-formada é uma solução para a qual a estrutura hierárquica no disco combina com a sua estrutura no Solution Explorer. Todos os projetos em uma solução bem-formada são armazenados em subpastas da pasta solução no disco. Se a solução é bem-formada quando você a adiciona ao controle de origem, o plug-in do controle de origem cria uma pasta abaixo da pasta *.root para conter as cópias principais de arquivo de solução (*.sln) e arquivos de opção de solução de usuários (*.suo) para a solução. Finalmente, o plug-in de controle de origem cria uma pasta sob a pasta .sln para cada projeto adicional no banco de dados do controle de origem.

Se uma solução não é bem-formada, o plug-in do controle de origem cria uma pasta para a solução e para o seu projeto inicial. Em seguida, as pastas para cada projeto adicional são criadas em paralelo com a pasta de solução.

Modos de exibição de uma solução ou projetos

Visual Studio fornece três modos diferentes de exibição de uma solução controlada por origem ou projeto: design, controle de origem, e físico. Muitas tarefas de controle de origem são mais fáceis de executar quando não há um mapeamento um-para-um entre os elementos individuais desse modo de visualização. Contudo, se você criar as suas soluções e projetos e os acrescentar ao controle de origem usando as configurações padrões do Visual Studio, suas soluções e projetos não serão, necessariamente, organizados do mesmo modo no disco como eles estão no Solution Explorer e no banco de dados.

O modo design de uma solução ou projeto, que você vê no Solution Explorer, é um retrato lógico do conteúdo de uma solução ou projeto. Geralmente, o modo design é limpo e significativo. Arquivos desnecessários estão ocultos e arquivos de vários locais físicos diferentes são colocados em um contêiner de projeto único.

Visual Studio 232

O modo de controle de origem de uma solução ou projeto, que você vê em um aplicativo autônomo, como Visual SourceSafe Explorer, é também um modo de exibição lógico de uma solução ou projeto. Entretanto, o modo de exibição de controle de origem não é, necessariamente, um reflexo do modo de exibição lógico.

O modo de exibição físico de uma solução ou projeto, que você vê no Windows File Explorer, provavelmente não refletirá a estrutura hierárquica da lógica ou visão do controle de origem.

As diretrizes a seguir podem ajudá-lo a obter fidelidade organizacional entre o modos de exibição de design, físico e controle de origem de suas soluções controladas por fonte e projetos:

• Primeiro, crie uma solução em branco e adicione projetos a ela. Isso o ajuda a manter a relação lógica pai-filho entre uma solução e seus projetos no armazenamento. Em seguida, quando você adicionar a solução ao controle de origem, o modo de exibição de controle de origem e design irá espelhar a hierarquia da solução no disco.

• Atribua a cada solução um nome exclusivo e descritivo que se diferencia do nome de cada um dos projetos contidos.

• Evite adicionar arquivos de link para uma solução ou projeto controlado por fonte origem.

• Se possível, armazene todos os arquivos de uma solução ou projeto em uma unidade de disco.

Conexões de controle de origem e ligações

O Visual Studio define uma conexão como uma ligação de dados ativa entre o Visual Studio e um servidor de banco de dados. Quando você adiciona uma solução ou projeto ao controle de origem, o plug-in de controle de origem copia o item e todo o seu conteúdo do disco para o banco de dados. Uma pasta controle de origem é criada para cada pasta que contém um arquivo solução ou projeto. Após adicionar o item, o plug-in de controle de origem vincula sua cópia de trabalho local de uma solução ou projeto à sua versão no banco de dados.

Cada solução controlada por origem tem, pelo menos, uma ligação de controle de origem. No entanto, um item pode ter várias ligações e requerer várias conexões com o banco de dados. O número de vínculos e conexões depende de como você cria a solução inicialmente e se seus projetos e arquivos estão todos salvos na mesma partição.

Como um exemplo de vínculos e conexões, pense em uma solução bem formada de controle de origem, com vários projetos, como uma casa com várias salas. Quando você constrói a casa, você pode instalar uma linha de dados única de alta velocidade de uma sala à rua. Você instala um roteador atrás de um firewall para distribuir a alimentação de dados para outras salas e você paga um provedor de serviços de Internet para conectar sua casa com a Internet.

Você pode pensar em vínculo de controle de origem como representação da linha de dados única criada para a casa. Quando você abre uma solução controlada por fonte, uma conexão é criada através dessa ligação. A conexão estabelece um 'aperto de mão' entre a sua cópia de trabalho da solução no disco e a cópia mestra da solução no banco de dados.

Se uma solução controlada por origem não for bem formada, você pode vê-la como uma casa na qual cada sala é unida à Internet diretamente. Tarifas de Internet são mais caras do que as da casa de conexão única, os custos de manutenção são

Visual Studio 233

superiores, e mudar para um provedor de serviços de Internet diferente é muito mais difícil e demorado.

Idealmente, uma solução e seu projeto compartilham uma ligação de controle de origem única. Soluções Single-Binding são mais gerenciáveis do que soluções Multiple-Binding. Elas tornam mais fácil:

• Desconectar do controle de origem para trabalhar off-line.

• Conectar-se ao banco de dados após a reconexão com a rede.

• Ramificar em uma etapa.

Você pode criar uma solução de multiprojeto com uma ligação única, criando uma solução em branco antes de adicionar seus projetos. Você também pode fazer isso, selecionando a opção Create Directory for Solution na caixa de diálogo New Project, ao criar um par de solução de multiprojeto.

Se você criar um par de solução de multiprojeto em uma etapa e não selecionar a opção Create Directory for Solution na caixa de diálogo New Project (desativado por padrão), uma segunda ligação será criada quando você adicionar um segundo projeto à solução. Uma ligação é criada para o projeto inicial e para a solução. Ligações adicionais são criadas para cada projeto adicional.

Terminologia de controle de origem

A documentação do Visual Studio usa um número de termos para descrever recursos e conceitos de controle de origem. A tabela a seguir define alguns dos termos comuns.

Versão base

A versão do servidor de um arquivo do qual uma versão local é derivada.

Vinculação

Informação que correlaciona uma pasta de trabalho de uma solução ou projeto no disco à pasta no banco de dados.

Ramificação

Processo de criar uma nova versão, ou ramificação, de um arquivo compartilhado ou projeto sob controle de origem. Uma vez que uma ramificação tenha sido criada, as duas versões sob controle de origem terão um histórico compartilhado até um determinado ponto e históricos divergentes após esse ponto.

Conflito

Duas ou mais alterações diferentes para a mesma linha do código em situações em que dois ou mais desenvolvedores tenham feito o check-out e editado o mesmo arquivo.

Conexão

Uma ligação de dados ativa entre um cliente do controle de origem (por exemplo, Visual Studio) e um servidor de banco de dados do controle de origem.

Banco de dados

Local onde todas as cópias mestre, histórico, estruturas de projeto e informações do usuário são armazenados. Um projeto sempre está contido em um banco de dados. Vários projetos podem ser armazenados em um banco de dados, e vários bancos de dados podem ser usados. Outros termos

Visual Studio 234

normalmente usados para um banco de dados são repositório e armazenamento.

Histórico

Registro de alterações de um arquivo desde que ele tenha sido adicionado, inicialmente, no controle de origem. Com o controle de versão, você pode retornar a qualquer ponto no histórico do arquivo e recuperar o arquivo como ele existia até esse momento.

Rótulo

Nome definido pelo usuário anexado a uma versão específica de um item controlado por fonte.

Cópia local

Arquivo em uma pasta de trabalho do usuário para a qual são copiadas alterações antes que seja feito um check-in. Uma cópia local é, às vezes, chamada de uma cópia de trabalho.

Cópia mestra

A versão mais recente do check-in de um arquivo controlado por fonte, em oposição à cópia local de um arquivo em sua pasta de trabalho. Outros termos para cópia mestra são versão do servidor e versão do banco de dados.

Mesclar

Processo de combinar diferenças entre duas ou mais versões modificadas de um arquivo em uma nova versão de arquivo. Mesclar pode afetar diferentes versões do mesmo arquivo ou alterações feitas a uma mesma versão do arquivo.

Arquivo compartilhado

Um arquivo com versões que residem em mais de uma localidade de controle de origem. Outros termos para um arquivo compartilhado são cópia e atalho.

Raiz solução

Uma pasta vazia em um banco de dados que contém todos os itens de uma solução controlada por origem. Por padrão, essa pasta é < nomedasolucao >.root.

Raiz Super-unificada

Um contêiner virtual abaixo do qual todos os projetos e os arquivos em uma solução controlada por origem estão localizados. Por exemplo [SUR]: \. é a raiz super-unificada de uma solução controlada por origem contendo projetos localizados em [SUR]:\C:\Solucao\Proj1 e [SUR]:\D:\Proj2.

Raiz unificada

Um caminho para a pasta pai de todas as pastas de trabalho e arquivos em uma solução ou projeto controlado por origem. Por exemplo, C:\Solucao é a raiz unificada de uma solução controlada por origem contendo arquivos localizados em C:\Solucao, C:\Solucao\Proj1 e C:\Solucao\Proj2.

Pasta de trabalho

Local no qual as cópias locais de itens controlados por origem são armazenados, geralmente no seu próprio computador. Outro termo para uma pasta de trabalho é espaço de trabalho.

Visual Studio 235

O que há de novo no controle de origem para o Visual Studio O Visual Studio tem dado suporte a controle de origem e integração de plug-ins de controle de origem há algum tempo. Entretanto, a versão atual inclui um número de aperfeiçoamentos de integração. Para informações sobre novos recursos da parte de controle de origem do SDK do ambiente Visual Studio, consulte "Novidades para controle de origem"

Alternância de plug-in

Controle de origem agora permite alternar entre todos os tipos de plug-ins de controle de origem em Options no menu Tools. Esta alternância permite a substituição completa da interface do usuário e permite um plug-in por solução.

Melhorias no acesso ao projeto via aberturas assíncronas

Controle de origem do Visual Studio foi aprimorado para abrir soluções de forma assíncrona e refletir o progresso de uma operação de abertura modificando os ícones no Solution Explorer. O recurso de abertura assíncrona marca projetos que ainda estão sendo baixados com uma ampulheta, e marca projetos totalmente baixados para acesso assim que eles estiverem disponíveis. Isso significa que você pode abrir e começar a trabalhar em um projeto mesmo que o Visual Studio esteja ainda abrindo os outros projetos na solução.

Observação

Este recurso está apenas disponível para Visual Basic, C#, J# e projetos da Web e não possui suporte de todos os plug-ins de controle de origem.

Melhorias na caixa de diálogo do Visual Studio para dar suporte a controle de origem

Os seguintes aperfeiçoamentos de acesso a arquivo foram feitos nas caixas de diálogo do Visual Studio:

• Agora você pode adicionar projetos ao controle de origem e abri-los facilmente usando a nova guia Source Control Stores na caixa de diálogo Open Project.

• Você pode adicionar um arquivo existente do controle de origem a um projeto usando a caixa de diálogo Add Existing Item.

• Você pode adicionar automaticamente soluções e projetos ao controle de origem marcando a caixa de seleção Add to Source Control na caixa de diálogo New Project.

Sincronização de exclusões, renomeações e movimentações

Para oferecer suporte a propagação de alteração de namespace, a versão mais recente de controle de origem sincroniza exclusões, renomeações, e movimentações com o banco de dados. Quando você fizer uma alteração você será solicitado a propagar a alteração, enquanto outros usuários poderão sincronizar através de operações de recuperação. Em versões anteriores, se você excluía, renomeava ou movia um item no servidor, ele permanecia na sua pasta de trabalho mesmo após a sincronização.

Melhorias nas operações básicas de controle de origem

Visual Studio 236

Os seguintes aperfeiçoamentos foram feitos nas operações básicas de controle de origem do Visual Studio:

• Você pode agora fazer um check-out de um arquivo de uma pasta de trabalho local sem precisar baixar pela rede a versão mais recente do arquivo no banco de dados.

• Agora checkouts são automáticos e número de solicitações é reduzido.

• Você tem uma opção para configurar o Visual Studio para automaticamente obter do controle de origem a última versão de todos os itens da solução quando você abrir uma solução .

• Você pode configurar o Visual Studio para fazer silenciosamente check-out de arquivos em edição e fazer automaticamente check-in das suas alterações quando você fechar a solução.

Suporte ao Visual Web Developer

O Visual Web Developer pode agora acessar recursos de controle de origem de projeto na Web, como baixar em qualquer local. Em versões anteriores do Visual Studio, o local estava embutido em código para baixar em c:\inetpub\wwwroot.

Execução de Tarefas de Controle de Origem Esta seção descreve tarefas gerais de controle de origem que você pode executar no Visual Studio para qualquer plug-in. Operações básicas de controle de origem como check in, check out e exibição de histórico são amplamente específicas de plug-in, embora essas operações possam fazer uso de alguns dos elementos de interface de usuário padrão suportados pelo pacote de controle de origem do Visual Studio. Para tarefas de plug-in-específico, entretanto, você deve consultar a documentação do plug-in de controle de origem específico.

Observação

Muitos desses procedimentos referem-se à seleção de comandos básicos de controle de origem do menu File do Visual Studio. Alternativamente, você pode acessar muitos dos comandos clicando com o botão direito do mouse em um item controlado por fonte no Solution Explorer.

COMO: Adicionar um projeto ao controle de origem O controle de origem do Visual Studio permite adicionar um projeto e seu arquivo de solução ao controle de origem ao mesmo tempo. Se uma solução já estiver sob controle de origem, você pode adicionar um novo projeto a ela. Fazendo check-in de uma solução automaticamente coloca qualquer novos projetos que esta contém sob controle de origem.

Para adicionar um projeto e solução ao controle de origem

5. No Visual Studio, crie um novo projeto. Se você tiver dúvidas sobre como fazer isso, procure a Ajuda do Visual Studio.

6. Selecione a solução que contém o novo projeto.

7. No menu File, clique em Source Control.

8. Clique em Add Solution to Source Control e selecione a base de dados de projeto à qual quer adicionar a solução usando os procedimentos do plug-in de controle de origem sendo utilizado.

Visual Studio 237

Para adicionar os projetos selecionados ao controle de origem

7. No Visual Studio, abra uma solução existente no Solution Explorer.

8. Crie novos projetos conforme necessário na solução. Se você tiver dúvidas sobre como fazer isso, há vários procedimentos na Ajuda do Visual Studio.

9. Faça o check-out do arquivo de solução, pois o controle de origem precisa incluir os novos detalhes do projeto nesse arquivo. Use o procedimento de check-out específicos para o plug-in de controle de origem em uso.

10. No menu File, clique em Source Control, e em seguida, clique em Add Selected Projects to Source Control

11. Você será solicitado a decidir se deseja adicionar os projetos como subpastas da solução ou como pastas separadas. Na maioria das situações, você deve adicionar os projetos à pasta da solução no banco de dados.

12. Faça o check-in da solução de volta no controle de origem, usando o procedimento de check-in específico para o plug-in de controle de origem em uso.

COMO: acoplar ou desacoplar uma solução ou projeto Você deve ligar uma solução ou projeto ao controle de origem de maneira que este item tenha acesso aos comandos básicos de controle de origem, tais como Check Out, Check In, e Get. Uma ligação associa a cópia local do item à cópia mestre no banco de dados.

Desacoplar uma solução ou projeto controlado por origem remove o item do controle de origem, desassociando a cópia local da cópia mestre no banco de dados, e desativando todos os comandos de controle de origem. Talvez você precise desacoplar um item se:

• Você precisar religá-lo à versão de backup do banco de dados quando o servidor primário for desligado. Você pode conectar a um servidor de backup, religar a sua cópia da solução à cópia mestre do servidor no banco de dados de backup, e continuar trabalhando normalmente. Para mais informações, consulte COMO: conectar ou desconectar uma solução ou projeto.

• Você desejar iniciar uma nova ramificação sem nenhum histórico de controle de origem em uma pasta de banco de dados diferente.

• Você desejar utilizar um outro plug-in de controle de origem .

Desacoplar um item não o remove permanentemente do banco de dados. Para obter mais informações de como excluir um item, consulte COMO: excluir um item controlado por origem.

Para ligar uma solução ou projeto ao controle de origem

5. No Visual Studio, abra o Solution Explorer e selecione uma solução ou projeto a ser ligado.


7. Na caixa de diálogo Change Source Control, clique em Bind.

8. Selecione o banco de dados e local ao qual ligar, e clique em OK.

Visual Studio 238

Para desacoplar uma solução ou projeto do controle de origem

5. No Visual Studio, abra o Solution Explorer e selecione uma solução ou projeto a ser desacoplado.



8. Clique em OK.

COMO: alterar o local da pasta de trabalho Às vezes o Solution Explorer indica locais de pasta por um sublinhado ondulado. Essas entradas representam caminhos inválidos relativos à pasta de trabalho. Para corrigir caminhos inválidos, você deve alterar o local da pasta de trabalho.

Para alterar o local da pasta de trabalho


6. Clique em um caminho inválido na coluna Enter Working Copy Location Here.

7. Clique no botão de reticências (…)

8. Digite um caminho válido, por exemplo, http://<host local>/pasta1, e clique em OK. Se a pasta ainda não existir, o Visual Studio criará uma.

Como conectar ou desconectar uma solução ou um projeto Conforme descrito em Introdução ao Controle de Código Fonte, uma solução no Visual Studio pode ter um ou mais vínculos com o controle de código fonte. Uma conexão é criada automaticamente sempre que um item é vinculado ao controle de código fonte conforme descrito em Como vincular ou desvincular uma solução ou um projeto. Pode-se criar uma conexão manualmente conforme descrito neste tópico.

Se você desconectar seu computador da rede ou perder a conexão por alguma outra razão, você deve desconectar temporariamente os vínculos da solução a fim de editar os projetos e os arquivos nela contidos. Quando você desconecta uma solução do controle de código fonte, o único comando básico que você pode usar é o comando de check-out. Ao realizar o check-out de um item desconectado, a cópia local do item, contida na sua pasta de trabalho, torna-se editável. Quando for possível acessar o banco de dados novamente, você pode reconectar a solução e sincronizar sua cópia local com a cópia mestre mais recente.

Procedimentos

Para conectar uma solução ou um projeto ao controle de código fonte

5. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem conectados.

6. No meu File , clique em Source Control e depois em Change Source Control.

7. Na caixa de diálogo Change Source Control, clique em Connect.

Visual Studio 239

8. Clique em OK.

Para desconectar uma solução ou projeto de controle de código fonte

5. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem desconectados.

6. No menu File, clique em Source Control e depois em Change Source Control.

7. Na caixa de diálogo Change Source Control, clique em Disconnect.

8. Clique em OK.

COMO: copiar um item sob controle de origem Você pode copiar um projeto de uma solução sob controle de origem para outra, ou copiar um arquivo de um projeto sob controle de origem para outro. Quando você copia um item, uma nova ramificação é criada no banco de dados, junto com o histórico e outros metadados do item. Criar ramificações permite que sua equipe desenvolva duas versões de um produto simultaneamente e independentemente.

Observação

Se você copiar um projeto sob controle de origem para uma solução que não está sob controle de origem, não poderão ser criadas ramificações no projeto.

Para copiar um projeto sob controle de origem


9. Clique com o botão direito do mouse na solução de destino no Solution Explorer.

10. No menu File, clique em Add e depois em Existing Project.

11. Na caixa de diálogo Add Existing Project, clique no nome de seu plug-in de controle de origem.

12. Clique duas vezes no banco de dados contendo o projeto que você deseja copiar.

13. Selecione o projeto, e clique em Add.

14. Clique em OK.

Para copiar um arquivo sob controle de origem


9. Clique com o botão direito do mouse no projeto de destino no Solution Explorer. Este projeto deve estar no mesmo banco de dados que o projeto de origem.

10. No menu File, clique em Add e depois em Existing Item.

11. Na caixa de diálogo Add Existing Item, clique no nome de seu plug-in de controle de origem.

12. Clique duas vezes no banco de dados que contém o arquivo que você deseja copiar.

Visual Studio 240

13. Selecione o arquivo, e clique em Add.

14. Clique em OK.

COMO: excluir um item controlado por origem Quando você exclui um item controlado por origem, o Visual Studio exclui automaticamente a cópia local, se o plug-in de controle de origem apoiar a propagação de modificação de espaço para nome. Caso contrário, ele o consultará para obter instruções sobre exclusão. Para mais informações sobre propagação de modificação de espaço para nome, consulte Introdução ao controle de origem.

A maioria dos plug-ins para controle de origem para o Visual Studio não exclui permanentemente itens de um banco de dados. Para obter mais informações sobre como excluir permanentemente um item de controle de origem, consulte a documentação do produto de terceiros para seu plug-in.

Para excluir um item controlado por origem

3. No Visual Studio, abra Solution Explorer.

4. Clique com o botão direito do mouse no item que deseja excluir, depois clique Delete ou Remove.

Observação

O comando Remove só estará disponível para projetos a base de referência, como projetos C++.

8. Você será solicitado para fazer o check-out no item. Faça o check-out como apoiado pelo seu plug-in de controle de origem.

9. Se tiver clicado em Remove, anteriormente, clique em Delete na caixa de diálogo que aparece.

10. Na caixa de diálogo Source Control, clique em Delete the item(s) locally and in the source control store.

11. Em Solution Explorer, faça o check-in do item como apoiado pelo seu plug-in de controle de origem.

12. Notifique a exclusão a qualquer pessoa que possa ter feito o check-out do projeto ao qual o item excluído pertence.

13. Se houver suporte para a propagação de modificação de espaço para nome, permita que os outros usuários façam a atualização de suas cópias locais. Eles receberão uma mensagem notificando-os da exclusão.

14. Se não houver suporte à propagação de modificação de espaço para nome, você terá de informar aos outros usuários para removerem manualmente suas cópias locais do item excluído.

Como ativar recuperação automática Você pode configurar o Visual Studio para recuperar automaticamente a versão mais recente de um item sob controle de versão sempre que você abri-lo. Isso garante que a cópia local permanecerá sincronizada com a cópia mestra.

Visual Studio 241

Procedimentos

Para obter a versão mais recente automaticamente


6. Na caixa de diálogo Options, clique em Source Control e em seguida clique em Environment.

7. Marque a caixa de seleção Get everything when a solution or project is opened.

8. Clique em OK.

Como desativar a criação da pasta <solutionname>.root Quando você adiciona uma solução ao controle de código fonte, o respectivo plug-in cria automaticamente uma pasta < solutionname >.root vazia no banco de dados. Essa pasta irá conter a raiz unificada da solução. Para mais informações sobre a raiz unificada, consulte Introdução ao controle de código fonte.

Cuidado

Desativar a criação automática da pasta < solutionname >.root irá alterar o comportamento do plug-in sempre que uma solução com vários projeto for adicionada ao controle de código fonte. Por exemplo, operações que adicionam projetos levarão mais tempo para concluir. Além disso, você terá que responder a solicitações redundantes ao executar operações de controle de código fonte em vários projetos.

Para desativar a criação automática da pasta < solutionname >.root

7. Na área de trabalho do Windows, clique em Start e, em seguida, clique em Run

8. Digite Regedit e clique em OK.

9. Abra \SourceControl HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\ < número de versão >.

10. Selecione a chave DoNotCreateSolutionRootFolderInSourceControl e clique em Edit e depois em Modify.

11. Na caixa de dados Value, troque 0 por 1.

12. Clique em OK para aceitar a alteração do registro.

COMO: Ativar Check-ins automáticos Você pode configurar o Visual Studio para que efetue automaticamente check-in nas suas alterações no controle de origem quando você fechar uma solução. Automatizar o processo de check-in garante que seus trabalhos mais recentes se tornem periodicamente disponíveis para outros membros da equipe, mesmo se você esquecer fazer check-in manualmente.

Para ativar checkins automáticos


Visual Studio 242

6. Na caixa de diálogo Options, clique em Source Control, clique em Environment.

7. Marque a caixa de seleção Check in everything when closing a solution or project.

8. Clique em OK.

COMO: desativar check-outs automáticos O controle de origem no Visual Studio permite check-outs automáticos por padrão. Esta seção descreve como você pode configurar o Visual Studio para desativar check-outs automáticos.

Procedimentos

Para desativar check-outs automáticos


6. Na caixa de diálogo Options, clique em Source Control, e depois clique em Environment.

7. Na caixa Editing, desmarque a caixa de seleção Check out automatically.

8. Clique em OK.

COMO: ativar ou desativar controle de origem O controle de origem no Visual Studio estará disponível somente se um plug-in válido de controle de origem estiver instalado e registrado para ser usado em seu computador. O plug-in é registrado durante a instalação do software de terceiros. O Visual Studio usa esse registro para localizar os plug-ins e as localidade de seus bancos de dados padrão sempre que você abrir a IDE do Visual Studio. Ela lista todos os plug-ins disponíveis na aba Plug-in Selection da entrada Source Control na caixa de diálogo Options.

Se você não tiver nenhum plug-in de controle de origem compatível instalado em seu computador, o controle de origem no Visual Studio não está ativado. Você não verá nenhuma entrada Source Control no menu File.

Cuidado

Você pode usar um plug-in de controle de origem no Visual Studio e o aplicativo autônomo de controle de origem correspondente para gerenciar o mesmo projeto ou solução. Entretanto, fazer check-outs de itens de ambos os programas para a mesma pasta de trabalho não é recomendável. Isso pode levar a situações em que soluções e projetos não podem ser acessados no controle de origem.

Para ativar um determinado plug-in de controle de origem


6. Na caixa de diálogo Options , clique em Source Control, clique em Plug-in Selection.

7. Selecione o plug-in de controle de origem que deseja usar.

Visual Studio 243

8. Clique em OK.

Para desativar completamente o controle de origem


6. Na caixa de diálogo Options, clique em Source Control, clique em Plug-in Selection.

7. Selecione None na caixa Current source control plug-in.

8. Clique em OK.

COMO: excluir um arquivo de controle de origem Se a solução em você estiver trabalhando contém arquivos que não requerem controle de origem, você pode utilizar o comando Exclude from Source Control para marcar adequadamente o arquivo. Quando você fizer isso, o arquivo permanecerá no banco de dados, mas não é mais realizado check-in ou check-out do mesmo a partir do projeto que o contém.

Observação

Arquivos gerados são excluídos do controle de origem por padrão. Um arquivo gerado é um que pode ser recriado inteiramente pelo Visual Studio, de acordo com o conteúdo de outro arquivo do Visual Studio.

Para excluir um arquivo do controle de origem

4. No Visual Studio, abra Solution Explorer e selecione o arquivo a ser excluído.

5. No menu File, clique em Source Control, clique em Exclude from Source Control.

6. Quando você estiver pronto para colocar o arquivo sob controle de origem, você pode acessar o menu File, clicar em Source Control e então desmarcar Exclude from Source Control.

COMO: mover uma raiz de ligação de projeto Você talvez necessite mover a raiz de ligação de um projeto se alguns arquivos que você deseja adicionar ao projeto estiverem localizados fora da raiz do projeto.

Para mover uma raiz de ligação de projeto

10. No Visual Studio, abra o Solution Explorer e selecione um projeto que contém arquivos que estejam fora da pasta da solução ou raiz do projeto.



13. Na caixa de mensagem, clique em Unbind para confirmar que você deseja remover o projeto do controle de origem.

14. Se a solução e o projeto compartilham uma ligação de controle de origem, desacople a solução também.

Visual Studio 244

15. Com o projeto selecionado, acesse novamente a caixa de diálogo Change Source Control e clique em Bind.

16. Se solicitado, faça logon no seu banco de dados de controle de origem.

17. Selecione a pasta pai na qual todos os arquivos no projeto estão armazenados. Na maioria dos casos, a pasta <nomesolução>.root é esta pasta.

18. Se você teve que desacoplar a solução juntamente com o projeto, você deve religá-la a uma pasta de banco de dados.

COMO: mover um item controlado por fonte No Visual Studio, você pode mover um item controlado por origem de uma pasta de projeto ou solução para outro. Quando você move um item, você move todo o histórico e metadados de controle de origem associados se o plug-in de controle de origem apoiar a propagação de modificação de espaço para nome. Tanto a origem quanto os itens de destino envolvidos em uma operação de mudança de local devem ser localizados no mesmo banco de dados de controle de origem. Para mais informações sobre propagação de modificação de espaço para nome, consulte Introdução ao controle de origem.

Observação

A operação de mudança só pode ocorrer entre dois projetos na mesma solução, ou entre duas soluções. Para uma mudança de local ser ativada, uma solução e seus projetos devem compartilhar uma vinculação de controle de origem. Para mais informações, consulte COMO: acoplar ou desacoplar uma solução ou projetos.

Para mover um item controlado por origem


4. Clique no item que você deseja mover e arraste-o para a solução ou projeto de destino no Solution Explorer.

COMO: abrir um projeto ou solução do controle de origem Quando você abre um projeto ou solução do controle de origem, o Visual Studio baixa a cópia mestra mais recente do item e de todos os arquivos contidos para a pasta de trabalho local. Depois que você recuperar uma cópia local do item, você não precisá abri-lo a partir do controle de origem novamente. Você pode continuar a usar os comandos de controle de origem para o seu plug-in específico de controle de origem.

Cuidado

Se você repetir um dos procedimentos neste tópico, você criará várias pastas de trabalho e várias instâncias dos arquivos que elas contêm.

Visual Studio 245

Para abrir um projeto ou solução do controle de origem


8. Clique em Project/Solution.

9. Na caixa de diálogo Open Project , selecione Close Solution if not already selected.

10. No lado esquerdo da caixa, clique em My <source control plug-in> Stores, e depois clique em Open.

11. Procure e selecione o seu arquivo de projeto (*.proj) ou de solução (*.sln), altere a pasta de destino, e depois clique em Open.

12. Se você já tiver uma cópia local da solução ou do projeto que você está abrindo do controle de origem, você será solicitado a substituir a cópia local de todos os arquivos e projetos na solução. Responda às perguntas conforme necessário.

Para abrir um projeto da Web do controle de origem


7. Clique em Web Site.

8. Na caixa de diálogo Open Web Site, clique em My <source control plug-in> Stores, depois clique em Open.

9. Procure e selecione o projeto da Web, altere a pasta de destino, e depois clique em Open.

10. Se você já tiver uma cópia local do projeto da Web que você está abrindo do controle de origem, você será solicitado a substituir a cópia local de todos os arquivos e projetos na solução. Responda às perguntas conforme necessário.

COMO: Renomear um item controlado por origem Quando você renomeia um item controlado por origem, o Visual Studio renomeia a cópia local automaticamente se o plug-in de controle de origem suporta propagação da alteração de namespace. Caso contrário, ele consultará você para obter instruções de renomeação. Para mais informações sobre propagação de alterações de namespaces, consulte Introdução ao controle de origem.

Para renomear um item de origem controlada


11. Clique com o botão direito do mouse no arquivo a ser renomeado, clique Rename.

12. Digite um novo nome e pressione Enter.

13. Você será solicitado para fazer check-out do item. Efetue o check-out conforme o suporte de seu plug-in de controle de origem.

14. Na caixa de diálogo Source Control, clique em Rename or move the item(s) locally and in the source control store.

15. No Solution Explorer, efetue o check-in do item conforme o suporte de seu plug-in de controle de origem.

Visual Studio 246

16. Notifique qualquer pessoa que possa ter efetuado check-out do item que você renomeou.

17. Se houver suporte para propagação da alteração de namespace, faça com que os outros usuários efetuem um get para atualizar suas cópias locais. Eles receberão uma mensagem notificando-os sobre a operação de renomeação.

18. Se não houver suporte para a propagação da alteração do namespace, é necessário informar aos outros usuários para que renomeiem suas cópias locais manualmente para refletir a alteração do nome.

COMO: definir opções de plug-in Dependendo da como você gerenciar seus itens em controle de origem, você pode desejar alterar algumas das opções padrão de controle de origem antes de usar o banco de dados. Essas opções estão disponíveis através da Configuração Options no menu Tools do Visual Studio.

Observação

Consulte a documentação do plug-in de controle de origem em uso para uma lista completa das opções no nível do banco de dados e das mais avançadas, além de instruções sobre como configurá-las.

Para definir opções de plug-in

10. No Visual Studio, no menu Tools, clique em Options e, em seguida, em Source Control.

11. Na caixa de diálogo Options, clique em Plug-in Selection, assegure-se que seu plug-in é o indicado, e clique em OK.

12. Selecione Environment na caixa de diálogo Options.

13. Na caixa Source Control Environment Settings, selecione a função para a qual você deseja definir as opções de controle de origem. O Visual Studio seleciona automaticamente as opções de controle de origem padrão para a função que você tiver selecionado. Se você desmarcar qualquer uma das opções padrão, a caixa Source Control Environment Settings exibe a Opção Custom para indicar que você personalizou o perfil originalmente selecionado.

14. Personalize o perfil, marcando ou desmarcando as caixas de seleção do controle de origem.

15. Clique em OK.

16. Agora clique em Plug-in Settings na caixa de diálogo Options.

17. Nessa aba, você pode definir configurações para cada função do plug-in. Clicando no botão Advanced tem-se acesso às configurações avançadas para a função que você está configurando.

18. Quando concluir todas as configurações do plug-in, clique em OK para sair da caixa de diálogo Options.

Visual Studio 247

Como: Trocar plug-ins de controle de origem: Se você tiver instalado mais de um plug-in para controle de origem para o Visual Studio, você pode trocá-los a qualquer momento. Lembre-se que projetos controlados por um plug-in de controle de origem não podem ser adicionados a uma solução gerenciada por um plug-in diferente. Uma vez que você acrescenta uma solução ou projeto ao controle de origem que usa um plug-in, você não pode acrescentar o mesmo item ao controle de origem que usa outro plug-in, a menos que você remova, primeiro, o item do controle de origem.

Para mudar o plug-in padrão de controle de origem


5. Na caixa de diálogo Options clique em Source Control, depois em Plug-in Selection.

6. Selecione um plug-in e clique OK.

COMO: exibir uma lista de arquivos com check-out Você pode usar a janela Pending Checkins para exibir uma lista dos arquivos com check-out na solução atual. O controle de origem do Visual Studio permite que você faça um check-in de arquivos desta janela com um único clique de botão.

Para exibir uma lista de arquivos modificados

4. No Visual Studio, no menu View, clique em Pending Checkins.

5. Encaixe a janela conforme desejado.

6. Se você desejar fazer check-in de arquivos desta janela, selecione-os e clique no botão Check In.

Referência a Interface do Usuário do controle de origem Esta seção descreve as caixas de diálogo usadas pelo controle de origem no Visual Studio. As caixas de diálogo a seguir são modelos que o desenvolvedor de plug-in pode adaptar conforme necessário. Você pode ou não ver essas caixas de diálogo no Visual Studio, dependendo do plug-in que está sendo usado para controle de origem:

• Verifique em

• Verificar saída para editar

• Obter

• Desfazer Checkout

Caixa de diálogo Change Source Control Cria e gerencia as conexões e ligações que vinculam uma solução ou projeto localmente salvos a uma pasta no banco de dados.

Visual Studio 248

Observação

Não é possível usar o Visual Studio para vincular, desvincular, conectar ou desconectar um aplicativo da Web criado utilizando as FrontPage Server Extensions.


No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control e depois em Change Source Control.

Observação

Esta caixa de diálogo também está disponível clicando com o botão direito do mouse sobre o item no Solution Explorer.

Vincular

Associa os itens selecionados a uma localidade do servidor de controle de origem especificado. Por exemplo, você pode usar este botão para criar um vinculo à pasta mais recentemente utilizada do servidor de controle de origem e banco de dados. Se uma pasta recente do servidor ou do banco de dados não puder ser encontrada, você será solicitado a especificar outra.

Procurar

Permite que você procure uma nova localidade para o item especificado no servidor de controle de origem.

Colunas


Conectar

Cria uma conexão entre itens selecionados e o servidor de controle de origem.

Conectado

Exibe o status da conexão de uma solução ou projeto selecionado.

Desconectar

Desconecta a cópia local de uma solução ou projeto no seu computador da cópia mestre no banco de dados. Utilize esse comando antes de desconectar seu computador do servidor de controle de origem, por exemplo, ao trabalhar off-line em seu laptop.

OK

Aceita alterações feitas na caixa de diálogo.

Provedor

Exibe o nome do plug-in de controle de origem.

Atualizar

Atualiza as informações de conexão para todos os projetos listados nesta caixa diálogo.

Servidor Binding

Visual Studio 249

Indica a ligação de um item a um servidor de controle de origem.

Nome do servidor

Exibe o nome do servidor de controle de origem ao qual a solução ou projeto correspondente está acoplada.

Solution/Project

Exibe o nome de cada projeto e solução na seleção atual.

Classificação

Altera a ordem de classificação de colunas exibidas.

Status

Identifica o status de vinculação e conexão de um item. As possíveis opções são:

Opção Descrição

Válido Especifica que o item está corretamente vinculado e conectado a pasta do servidor ao qual ele pertence.

Inválido Especifica que o item está incorretamente vinculado ou desconectado da pasta à qual ele pertence. Use o comando Add to Source Control ao invés do comando Bind para este item.

Desconhecido Especifica que status do item sob controle de origem ainda não foi determinado.

Não controlado

Especifica que o item não se encontra sob controle de origem.

Desagrupar

Exibe a caixa de diálogo Source Control que permite que você remova os itens selecionados do controle de origem e permanentemente disassocie-os das suas pastas.

Observação

Se você desvincular um projeto da Web, será impossível revinculá-lo a seu servidor de controle de origem original até que você altere a localidade de sua cópia de trabalho.

Caixa de diálogo Check In (Controle de Código Fonte) Verifica um arquivo, solução ou projeto alterado no banco de dados do controle de código fonte. Check-ins também podem ser feitos a partir da janela Pending Checkins.


No Visual Studio, selecione um item na janela Solution Explorer. No menu File, clique em Source Control depois em Check In.

Visual Studio 250

Observação


Check In

Realiza o check-in de todos os itens selecionados.

Columns


Comments


Don't show Check in dialog box when checking in items

Impede que a caixa de diálogo seja exibidas durante operações de check-in.

Flat View

Exibe os arquivos onde está sendo feito o check-in como listas simples sob sua conexão com controle de código fonte.

Name

Exibe os nomes dos itens onde deve-se fazer o check-in. Os itens aparecem com as caixas de seleção ao lado selecionadas. Se você não desejar fazer check-in de um item específico, desmarque sua caixa de seleção.

Options

Exibe opções de check-in específicas de plug-ins de controle de código fonte quando a seta à direita do botão é selecionada.

Sort


Tree View

Exibe a pasta e a hierarquia dos itens nos quais você estiver realizando o check-in.

Check-out para a caixa de diálogo Edit (controle de origem) Faz check-out de soluções, projetos ou itens individuais do controle de origem. Fazer check-out de um item pode copiar a cópia mestre atual para o seu computador local e remover o seu atributo de somente leitura. Opcionalmente você pode configurar o comando Check Out For Edit para fazer check-out somente da versão local. A menos que o pacote de controle de origem esteja configurado para dar suporte a checkouts compartilhados, fazer check-out de um item também bloqueia o item de maneira que ele estará em somente leitura para outros usuários.

Caixa de diálogo Access

No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control, depois clique em Check Out For Edit.

Visual Studio 251

Observação

Esta caixa de diálogo também está disponível clicando com o botão direito do mouse no item no Solution Explorer.

Verificar saída

Faz check-out de todos os itens selecionados.

Colunas

Identifica as colunas para exibição e a ordem na qual elas são exibidas.

Comentários

Especifica um comentário para associar à operação de check-out.

Não caixa diálogo Show Check Out quando check-out itens

Impede que a caixa de diálogo seja exibida durante operações de check-out.

Exibir simples

Exibe os itens do check-out em progresso como listas simples sob sua conexão de controle de origem.

Editar

Permite que você modifique um item sem fazer seu check-out. O botão Edit aparece somente se você tiver o Visual Studio configurado para dar suporte à edição de arquivos com check-in.

Nome

Exibe os nomes dos itens disponíveis para check-out. Os itens que estão selecionados aparecem com caixas de seleção ao seu lado. Se você não desejar fazer check-out de um item específico, desmarque sua caixa de seleção.

Opções

Exibe opções de check-out específicas do plug-in de controle de origem quando a seta à direita do botão é clicada.

Classificação


Exibir árvore

Exibe a hierarquia de pastas e arquivos para o item do check-out em progresso.

Caixa de diálogo Get (controle de origem) Recupera uma cópia somente para leitura do item selecionado do banco de dados para sua pasta de trabalho, ou outra pasta que você especificar.


No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em Source Control, depois em Get.

Visual Studio 252

Observação

Esta caixa de diálogo também está disponível clicando-se com o botão direito do mouse sobre o item no Solution Explorer.

Ação

Especifica a ação a ser executada nos itens a ser recuperados.

Colunas


Exibir simples

Exibe os arquivos sendo recuperados como listas simples sob suas conexões ao controle de origem.

Hora modificado

Exibe o momento em que um item foi modificado pela última vez.

Nome

Exibe os nomes dos itens a ser recuperados. Os itens aparecem com as caixas de seleção ao lado dos mesmos selecionadas. Se você não desejar recuperar um item específico, desmarque a caixa de seleção correspondente.

Opções

Exibe opções de recuperação específicas do plug-in do Source Safe quando a seta à direita do botão é clicada.

Classificação


Exibir árvore

Exibe a hierarquia de pastas e arquivos para os itens sendo recuperados.

Janela de check-ins pendentes Exibe todos os arquivos com check-out na solução ou projeto atual. Você pode usar esta janela para fazer check-in de todos os arquivos com um único clique de botão.

Caixa de diálogo de acesso

No Visual Studio, no menu View, clique em Pending Checkins.

Change type

Identifica o tipo de alteração que foi feita para o item selecionado.

Check In

Efetua check-in dos itens selecionados.

Columns

Identifica as colunas para exibição e a ordem na qual elas serão exibidas.

Comments


Visual Studio 253

Flat View

Exibe os arquivos que você está efetuando check-in na forma de listas simples em sua conexão de controle de origem.

Name

Exibe os nomes dos itens com check-in a ser efetuado. Os itens aparecem com as caixas de seleção ao seus lados selecionadas. Se você não desejar fazer o check-in de um item específico, desmarque sua caixa de seleção.

Options

Exibe opções de check-in específicas de plug-ins quando a seta à direita do botão é clicada.

Sort


Tree View

Exibe a hierarquia das pasta e arquivos que você estiver efetuando check-in.

Undo checkout

Reverte o check-out de um item selecionado, o qual perde qualquer alteração feita desde o check out.

Guias de plug-in para controle de origem (caixa de diálogo Options) Permitem a personalização de funções de controle de origem e configurações de plug-in no Visual Studio. As guias de plug-in fazem parte da caixa de diálogo Options do Visual Studio, localizada sob a entrada Source Control:

• Plug-in Selection Alterna entre os plug-ins de controle de origem.

• Environment Especifica as configurações de ambiente para as funções padrões definidas pelo Visual Studio. Por exemplo, se o usuário for um desenvolvedor independente, conflitos com outros usuários não são geralmente criados ao manter itens com check-out após um check-in. Para esta função, o Visual Studio seleciona automaticamente a opção Keep items checked out when checking in.

• Plug-in Settings Especifica opções para identificar o plug-in de controle de origem associado a um projeto ou solução.

Guia Access

No Visual Studio, no menu Tools, clique em Options, e depois em Source Control. Opções são definidas para Plug-in Selection, Environment, e Plug-in Settings.

Lista de elementos de interface do usuário, Selection Plug-in

Altera o plug-in atual de controle de origem associado ao IDE do Visual Studio, e faz dele o plug-in padrão. O plug-in selecionado é refletido na entrada Source Control no menu File do Visual Studio. Clique em OK para registrar sua alteração e alternar a operação para o plug-in escolhido por você.

Observação

Visual Studio 254

Você pode usar esta parte da caixa de diálogo Options para desativar o controle de origem clicando em None na lista de plug-ins

Lista de elementos de interface do usuário, Environment

Permitir que itens a serem editadas checked-in

Especifica que itens com check-in podem ser editados na memória. Se este item estiver selecionado, um botão Edit aparecerá na caixa de diálogo Check Out For Edit quando você tentar editar um item com check-in.

Check in tudo ao fechar uma solução ou projeto

Especifica que você irá fazer check-in de todos os itens ao fechar uma solução ou projeto.

Itens Checked-in

Contém configurações para salvar e editar itens com check-in.

Não Mostrar caixa de diálogo check-out quando check-out itens

Especifica que o Visual Studio deve exibir o comando Check Out Now no menu File. Nesse caso, uma caixa de diálogo de check-out não é exibida.

Não Mostrar caixa de diálogo check-in ao verificar em itens

Especifica que o Visual Studio deve exibir o comando Check In Now no menu File. Nesse caso, uma caixa de diálogo de check-in não será exibida.

Não mostrar esta caixa de diálogo novamente

Especifica que o Visual Studio não deve mostrar as configurações de ambiente de controle de origem.

Edição

Especifica a maneira com que itens devem ser manipulados na edição. As opções possíveis são:

Opção Descrição

Prompt for checkout Especifica que o Visual Studio deve emitir um prompt para um check-out.

Prompt for exclusive checkouts

Especifica que o Visual Studio deve emitir um prompt para check-outs exclusivos.

Check out automatically Indica que o Visual Studio deve fazer check-out de itens automaticamente.

Do nothing Especifica que o Visual Studio não deve fazer nada na edição.

Obter tudo quando uma solução ou projeto for aberto

Recupera a versão mais recente de todos os itens quando você abre uma solução ou projeto.

Manter itens check-out ao verificar na

Especifica que itens em processo de check-in devem permanecer com check-out para você. Se você desejar alterar esta opção para um check-in

Visual Studio 255

específico, clique na seta de Options na caixa de diálogo Check In, e desmarque a opção Keep Checked Out.

Redefinir

Redefine confirmações.

Salvar

Especifica a maneira com que itens devem ser manipulados quando você os salva. As opções possíveis são:

Opção Descrição

Prompt for checkout Especifica que o Visual Studio deve emitir um prompt para check-out em uma operação de salvar.

Check out automatically

Especifica que o Visual Studio deve fazer check-out automaticamente em uma operação de salvar.

Save as Especifica que o Visual Studio deve apresentar um prompt Save as em uma operação de salvar.

Configurações de ambiente controle de origem

Especifica o nome do plug-in de controle de origem para o qual você está definindo opções de ambiente.

Lista de elementos de interface do usuário, Plug-in Settings

Avançadas

Permite que você defina opções adicionais para usar o plug-in de controle de origem . O botão Advanced só está disponível quando um plug-in de controle de origem válido está instalado no computador local. As configurações avançadas são específicas para o plug-in.

Identificação de logon

Especifica o nome de usuário para efetuar logon no plug-in de controle de origem. Se seu plug-in der suporte, esse nome será colocado automaticamente na caixa de diálogo de logon usada pelo plug-in de controle de origem para acessar o servidor. Para ativar essa opção, desative logons de usuário automáticos do seu plug-in de controle de origem, e reinicie o Visual Studio.

Observação

A identificação de logon somente pode ser editada quando um plug-in válido de controle de origem estiver instalado na máquina local.

Executar atualizações de status em segundo plano

Atualiza automaticamente os ícones de controle de origem no Solution Explorer à medida que o status de item se altera. Se você tiver atrasos ao executar operações intensivas no servidor, especialmente quando abrir uma

Visual Studio 256

solução ou projeto do controle de origem, desmarcar esta opção pode melhorar o desempenho.

Configurações plug-in

Especifica o nome do plug-in de controle de origem para o qual você está fazendo configurações.

Caixa de diálogo Source Control Permite que você remova itens do controle de código fonte e desfaça permanentemente a associação entre os itens e suas pastas. Esta caixa de diálogo é usada para propagar as operações excluir, renomear e mover.


No Visual Studio, clique em um item com o botão direito do mouse, em seguida, clique em Delete ou Rename. O conteúdo da caixa de diálogo varia dependendo do comando.

Lista de elementos da interface do usuário para renomeações ou movimentações

Make my current choice the default action for all future renames or moves

Especifica que sua escolha será a ação padrão das operações posteriores de renomear ou mover. Você pode redefinir o padrão em

Only rename or move item(s) locally

Especifica que os itens devem ser renomeados localmente. Os itens renomeados ou movidos não mais estarão sob controle de versão.

Rename or move the item(s) locally and in the source control store

Especifica que os itens devem ser renomeados localmente e no banco de dados. A versão mais recente da solução ou projeto não refletirá a renomeação ou a movimentação até o próximo check-in.

You are about to rename or move the following

Lista os itens que você selecionou para serem renomeados ou movidos.

Lista de elementos da interface do usuário para exclusões

Delete the item(s) locally and in the source control store

Especifica que os itens devem ser excluídos localmente e no banco de dados. A versão mais recente da solução ou projeto não refletirá a operação de exclusão até o próximo check-in.

Make my current choice the default action for all future deletes

Especifica que a sua escolha será a ação padrão das operações posteriores de exclusão.

Only delete item(s) locally

Especifica que os itens devem ser excluídos localmente. Outros membros da equipe não são afetados por essa opção até o próximo check-in. Você precisará excluir manualmente os itens no banco de dados após o check-in.

You are about to delete the following

Visual Studio 257

Lista os itens que você selecionou para exclusão.

Caixa de diálogo Undo Checkout (Controle de Código Fonte) Reverte a opção de check-out do item selecionado na janela Solution Explorer. Você perderá qualquer alteração feita desde o último check-out.


No Visual Studio, selecione um item na janela Solution Explorer. No menu File, clique em Source Control e em seguida clique em Undo Checkout.

Observação


Columns


Flat View

Exibe os itens como listas simples sob a sua conexão com o controle de código fonte.

Name

Exibe os nomes dos itens para os quais será desfeito o check-out. Os itens aparecem com as caixas de seleção ao seu lado selecionadas. Se você não deseja desfazer o check-out de um item, desmarque sua caixa de seleção.

Options

Exibe opções para desfazer o check-out específicas de plug-ins de controle de código fonte quando a seta à direita do botão é selecionada.

Sort


Tree View

Exibe a pasta e a hierarquia dos itens nos quais você está revertendo o check-out.

Undo Checkout

Reverte o check-out.

Visual Studio 258

Visual Studio 259












Visual Studio 260



Coleções configurações predefinidas também fornecer personalizações à Ajuda. Configurações especificam o padrão How Do I Página na Ajuda. Eu selecionado como pendente eu página filtros fazer o conteúdo que aparece no índice analítico e no índice,, bem como fornece conteúdo personalizado na caixa como guia. Você pode alterar o ativo How Do I página na lista drop-down como pendente eu outras páginas.


• Favoritos










Visual Studio 261








Observação







Se você está importando o arquivo configurações contém todas as categorias configurações possíveis, importar esse arquivo completamente substitui as configurações existentes. Importar o arquivo se um arquivo de configurações

Visual Studio 262

contém apenas um subconjunto das categorias configurações, apenas aplica essas categorias e não afeta as configurações atuais para categorias não importadas.








Observação










Visual Studio 263


9. Clique em OK.









Import and Export Settings Wizard Use este assistente para exportar configurações, importar configurações, ou substituir as configurações para usar uma coleção configurações predefinidas.

Opção Descrição








Visual Studio 264






Observação


Nomeie O arquivo de configurações, importar e exportar configurações Assistente







Salvar configurações atuais, importar e Assistente para exportação configurações





Visual Studio 265






Escolha Configurações para importar, importar e Assistente configurações exportação





Description


Escolha um coleção de configurações para importar, importar e Assistente configurações exportação





Description


Visual Studio 266

<task> Complete, Import and Export Settings Wizard Esta página do importação e assistente exportar para configurações exibe informações sobre a tarefa configurações concluída com êxito ou não e todos os erros que foram encontrados. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

Details


Visual Studio 267

Gerenciar soluções, projetos e arquivos Os tópicos a seguir descrevem tarefas comuns que você pode executar ao trabalhar com soluções e projetos.

Nesta seção Introdução a soluções, projetos, e itens

Entender os conceitos de soluções, projetos, e itens e as vantagens de usar o Visual Studio para gerenciar seus projetos de desenvolvimento e arquivos.

Propriedades de projeto do Visual Studio

Discute o Designer de Projeto e como modificar as configurações do projeto.

Soluções multi-projeto

Trabalhar em mais de um projeto de cada vez em uma instância do (IDE) o ambiente integrado de desenvolvimento.

Projetos autônomos

Entender quais projetos são autônomos e quando você pode trabalhar com eles.

Projetos temporários

Entender quais projetos são temporários e quando você pode trabalhar com eles.

Solução, Projeto e elementos de interface do usuário de arquivo

Referência para elementos de interface do usuário que permitem que você configure suas soluções, projetos e arquivos.

Introdução ao soluções, projetos, e itens O Visual Studio fornece dois recipientes para ajudá-lo com eficiência gerenciar os itens que são exigidos por seu esforço de desenvolvimento, como referências, conexões de dados, pastas e arquivos. Esses recipientes são chamados soluções e projetos. Além disso, o Visual Studio fornece Solution Folders para organizar projetos relacionados em grupos e executar ações nesses grupos de projetos. O Solution Explorer é uma interface para exibir e gerenciar esses recipientes e seus itens associados, é parte do o ambiente integrado de desenvolvimento (IDE).

Soluções e projetos recipientes: Soluções e projetos contém itens que representam as referências, conexões de dados, pastas, e arquivos que você precisa para criar seu aplicativo. Uma solução pode conter vários projetos e um projeto normalmente contém vários itens. Esses recipientes permitem a você tirar proveito do IDE das seguintes maneiras:

• Gerenciar configurações para a solução como um todo ou para projetos individuais.

• Usar o Solution Explorer para manipular detalhes de gerenciamento de arquivos enquanto você se concentra nos itens que fazem parte do seu esforço de desenvolvimento.

• Adicionar itens que são úteis para vários projetos na solução ou para a solução sem referênciar o item em cada projeto.

Visual Studio 268

• Trabalhar em diversos arquivos que são independentes de soluções ou projetos.

Conexões de dados arquivos, referências, itens: Itens podem ser arquivos e outras partes do seu projeto tais como referências, conexões de dados, ou pastas. No Solution Explorer, itens podem ser organizados das maneiras a seguir:

• Como itens de projetos, que são itens que compõem seu projeto, como formulários, arquivos fonte, e classes dentro de um projeto no Solution Explorer. A organização e exibição depende do modelo de projeto que você selecionar bem como das modificações que voce efetuou.

• Como itens de solução para arquivos que são aplicáveis a sua solução como um todo na pasta Solution Items do Solution Explorer.

• Como arquivos variados para arquivos que não estejam associados a um projeto ou a uma solução e que podem ser exibidos em uma pasta Miscellaneous Files.

Para informações mais detalhadas ou para aprender a usar o Solution Explorer, consulte os tópicos a seguir:

Para obter mais informações Consulte

Soluções e projetos Soluções como Containers

Projetos como Containers

Executar tarefas comuns de gerenciamento de arquivos Gerenciar soluções, projetos, e Arquivos

Soluções e estruturas de diretório HOW TO: criar pastas para soluções

Solution Explorer no ambiente de desenvolvimento integrados (IDE) Explorer solução

Gerenciando múltiplos projetos em uma solução Soluções multi-Project

Itens que são referenciadas por vários projetos e incluídos em compilações da solução

Itens solução

Elementos da interface de usuário relacionados a uma solução no IDE Soluções, interface de usuário elementos

Projetos e soluções criados externamente Arquivos variados

Desenvolvendo e gerenciando scripts Windows Scripting Windows Script Host

Visual Studio 269

Propriedades de Projeto (Visual Studio) O projeto é o ponto de partida para a criação de aplicativos, componentes e serviços em Visual Studio 2005. Ele atua como um recipiente que gerencia o seu código fonte, as conexões de dados e as referências. Um projeto é organizado como parte de uma solução que pode conter vários projetos que sejam interdependentes entre si. Os tópicos nesta seção descrevem as diversas tarefas envolvidas na criação e no gerenciamento de projetos Visual Basic, Visual C# e Visual J#.

Gerenciando propriedades de projeto com o designer de projeto O Project Designer é uma interface de usuário conveniente no Visual Studio que permite a você definir propriedades de projeto, algumas das quais você também pode definir através da Janela Properties.

Gerenciando propriedades de aplicativo As propriedades de aplicativo gerais descrevendo o aplicativo e seu comportamento, tais como tipo de aplicativo, objeto de inicialização, e informações de assembly, são definidas no painel Application do Project Designer. As seguintes tarefas podem ser realizadas no painel Application.

COMO: especificar informações de assembly Propriedades ou atributos de informações de assembly são usadas para fornecer informações sobre um assembly ou aplicativo, incluindo uma descrição, informações de versão, nome da empresa, nome do produto e mais. Essas informações correspondem aos valores dos atributos assembly globais. Para obter mais informações sobre atributos assembly, consulte Atributos globais no Visual Basic.

Você especifica informações assembly na Caixa de diálogo Assembly Information, acessível a partir da página Application do Project Designer.

Para inserir ou editar informações Assembly 1. Selecione um projeto no Solution Explorer, em seguida, no menu Project ,

clique em Properties.

2. Clique na guia Application.

3. Clique no botão Assembly Information para abrir a caixa de diálogo Assembly Information.

Como alterar um nome de conjunto: A Assembly Name propriedade de um aplicativo determina o nome que será usado para o aplicativo compilado. Por exemplo, definir a Assembly Name. Para " MyApplication " para um Windows aplicativo resultaria em um arquivo executável chamado MyApplication.exe Os Assembly Name padrões para o projeto nome; ele pode ser alterado na página Application da a Project Designer.

Observação

Visual Studio 270

Embora o padrão Valor de a Assembly Name. é o mesmo a Assembly Name e alterando o Assembly Name faz não alterar o nome do projeto como o nome do projeto, os dois são não relacionados; alterar o nome do projeto não altera

Para alterar a propriedade Assembly Name 1. Com um projeto selecionado no Solution Explorer, no menu Project ,


2. Clique na Application Guia.

3. No campo Assembly Name, digite o nome para o seu aplicativo.

COMO: alterar o namespace para um aplicativo A propriedade Root Namespace define o namespace raiz para todos os arquivos no projeto. Por exemplo, se você definir o namespace raiz para Projeto1, e você tiver uma classe Classe1 fora de qualquer namespace em seu código, o seu namespace seria Projeto1.Classe1. Se você tiver uma Classe2 em um namespace Order no código, seu namespace seria Projeto1.Order.Classe2.

Também é possível limpar a propriedade Root Namespace, a qual permite que você especifique manualmente a estrutura do namespace do seu projeto. Para mais informações, consulte Declaração de namespace.

Para alterar o namespace de um projeto 1. Com um projeto selecionado no Solution Explorer, no menu Project ,



3. No campo Root namespace, insira o nome.

COMO: alterar o tipo de aplicativo A propriedade Application Type para um projeto determina o tipo de aplicativo a ser criado: Windows Application, Windows Class Library, Windows Service, Command Line Application ou Server Class Library. Diferentes propriedades e opções de projetos estão disponíveis dependendo do tipo de aplicativo.

O padrão Application Type é o mesmo que o Project Type escolhido na caixa de diálogo Add Project.

A propriedade Application Type pode ser definida na página Application do Project Designer.

Para alterar o tipo de aplicativo 1. Com um projeto selecionado no Solution Explorer, clique em Properties

no menu Project .


3. Escolha o tipo desejado na lista suspensa Application Type.

Visual Studio 271

COMO: Alterar o objeto de inicialização para um aplicativo A propriedade Startup object (Objeto de inicialização) ou Startup form (Formulário de inicialização) de um projeto define o ponto de entrada a ser chamado quando o aplicativo é carregado; geralmente você define-o para o formulário principal em seu aplicativo ou para o procedimento Sub Main que deve executado quando o aplicativo é iniciado.

Esta opção pode ser Startup object ou Startup form dependendo do tipo de projeto.

Por exemplo, um aplicativo de console tem uma opção Startup Object que pode ser Sub Main ou Module1. Um aplicativo do Windows tem uma opção Startup Form, que só pode ser Form1. Como bibliotecas de classes não têm um ponto de entrada, sua única opção para essa propriedade é (Vazio).

A opção Enable application framework (Habilitar framework de aplicativo) especifica se um projeto de aplicativo do Windows será iniciado com um procedimento personalizado Sub Main (que você tenha criado). Se você ativar a estrutura de aplicativos, seu aplicativo usa o Sub Main padrão. Se você desativar a estrutura de aplicativos, o seu aplicativo utiliza o Sub Main personalizado (e você deve adicionar código no procedimento Sub Main para o formulário).

Observação

Ao usar um procedimento Sub Main personalizado como o objeto Startup (Inicialização), o código nos eventos do aplicativo (Startup, Shutdown, StartupNextInstance e UnhandledException) não é executado.

Você pode definir a propriedade Startup object ou Startup form na página Application (Aplicativo) do Project Designer (Designer de Projeto).

Para alterar o formulário ou objeto de inicialização 1. Com um projeto selecionado no Solution Explorer (Explorer de Solução),

no menu Project (Projeto), clique em Properties (Propriedades).


3. Selecione um objeto de Startup da lista suspensa Startup object ou Startup form.

Para definir o objeto de inicialização para um aplicativo do Windows como Sub Main 1. Com um projeto selecionado no Solution Explorer, no menu Project, clique

em Properties.


3. Desmarque a caixa de seleção Enable application framework.

4. Selecione Sub Main na lista suspensa Startup object.

Visual Studio 272

COMO: especifica um ícone de aplicativo A Icon propriedade para um projeto Especifica o arquivo ícone (.ico) para o aplicativo compilado que será exibido no Windows Explorer e na barra de tarefas do Windows.

A Icon propriedade pode ser acessado no painel Application da o Project Designer;. Ela contém uma lista dos ícones que foram adicionados a um projeto como recursos ou como arquivos de conteúdo

Para especificar um ícone do aplicativo 1. Com um projeto selecionado no Solution Explorer, no menu o Project

clique Properties.

2. Selecione o Application painel.

3. Selecione um arquivo de ícone (.ico) na lista suspensa o Icon.

Para especificar um ícone do aplicativo e adicioná-la ao seu projeto 1. Com um projeto selecionado no Solution Explorer, no menu Project ,


2. Selecione o Application painel.

3. Selecione <Browse...> na lista Icon suspensa e navegar para a localidade do arquivo de ícones que você deseja.

O arquivo ícone é adicionado ao seu projeto como um arquivo de conteúdo.

COMO: Ativar estilos visuais

Observação

Este tópico se aplica somente para os projetos do Visual Basic.

O Windows XP introduziu um novo aspecto de aparência (look em feel) para a interface de usuário do Windows, com controles que têm cantos arredondados e que alteraram a cor quando você para o mouse sobre eles. Por padrão, aplicativos baseados no Windows criados com Visual Basic automaticamente suportam estilos visuais, também conhecidos como Temas do Windows XP. Quando executado em uma plataforma que não dá suporte para Temas do Windows XP, o aplicativo volta para o aspecto de aparência (look and feel) tradicional do Windows.

Se você não deseja que o aplicativo ofereça suporte a estilos visuais, você pode alterar a propriedade na página Application do Project Designer.

Observação

Suporte a estilos visuais do XP pode também ser ativado ou desativado através de programação através do método EnableVisualStyles da classe Application. Para mais informações, consulte o tópico COMO: Ativar estilos visuais do Windows XP.

Visual Studio 273

Para desativar os estilos visuais do Windows XP 1. Com um projeto selecionado no Solution Explorer, no menu Project, clique

em Properties.


3. Desmarque a caixa de seleção Enable XP visual styles.

Para ativar os estilos visuais do Windows XP 1. Com um projeto selecionado no Solution Explorer, no menu Project, clique

em Properties.


3. Marque a caixa de seleção Enable XP visual styles.

Observação

Estilos visuais são ativados por padrão.

COMO: Especificar comportamento de instâncias para um aplicativo

Observação

Este tópico se aplica somente aos projetos do Visual Basic.

Os aplicativos criados com Visual Basic são, por padrão, aplicativos de múltiplas instâncias; os usuários podem iniciar várias instâncias do aplicativo compilado. Em alguns casos, você pode impedir os usuários de iniciar várias instâncias do seu aplicativo. Isso pode ser feito marcando a propriedade Make Single Instance Application para o seu projeto, acessível da página Application do Project Designer.

Quando a caixa de seleção Make Single Instance Application está marcada, somente uma única instância do aplicativo compilado é permitida. Se um usuário tentar iniciar uma segunda instância, o foco é deslocado para a instância que já está sendo executada e o evento StartupNextInstance é destacado.

Para criar um aplicativo de instância única 1. Com um projeto selecionado no Solution Explorer, no menu Project ,



3. Marque a caixa de seleção Make single instance application.

Para criar um aplicativo de múltiplas instâncias 1. Com um projeto selecionado no Solution Explorer, no menu Project ,



3. Desmarque a caixa de seleção Make single instance application.

Visual Studio 274

Observação

Por padrão, os aplicativos são de múltiplas instâncias.

COMO: ativar autenticação de usuário personalizada

Observação


Aplicativos baseados no Visual Basic usam autenticação do Windows para identificar o usuário conectado no momento. Essas informações podem ser recuperadas em tempo de execução usando o objeto My.User. Para informações sobre programação com o objeto My.User, consulte Acessando dados do usuário. Em tais casos, defina a Authentication mode. para autenticação Windows.

Em algumas situações, convém escrever seu próprio código para autenticar usuários, ao invés de usar os métodos de autenticação padrão do Windows. Em tais casos, defina a Authentication mode para autenticação Application-defined.

Para ativar a autenticação personalizada (Application-DEFINED) 1. Com um projeto selecionado no Solution Explorer, no menu Project ,



3. Na lista suspensa Authentication mode, selecione a autenticação Application-defined.

Você precisará fornecer seu próprio código de autenticação.

Para usar autenticação do Windows 1. Com um projeto selecionado no Solution Explorer, no menu Project ,



3. Na lista suspensa Authentication mode, selecione autenticação Windows.

Isso é a configuração padrão.

COMO: Especificar o comportamento de desligamento para um aplicativo

Observação


A propriedade Shutdown mode (modo de desligamento) para um projeto de Windows Application (aplicativo do Windows) determina o comportamento de

Visual Studio 275

desligamento para o aplicativo. Quando definida como When startup form closes (Quando o formulário de inicialização fechar, o padrão), o aplicativo termina quando o formulário definido como o Startup object (objeto de inicialização) fechar, mesmo que outros formulários estejam abertos. Quando definida como When last form closes (Quando o último formulário fechar), o aplicativo termina quando o último formulário for fechado ou quando a declaração My.Application.Exit ou End for chamada explicitamente.

A propriedade Shutdown mode pode ser definida na página Application (Aplicativo) do Project Designer (Designer de projeto).

Para alterar o comportamento de desligamento 1. Com um projeto selecionado no Solution Explorer (Explorer de Solução),



3. Na lista suspensa Shutdown mode, escolha When startup form closes ou When last form closes.

Gerenciando referências A página References do Project Designer é usada para exibir, adicionar e remover referências e namespaces importados para seu projeto. As seguintes tarefas podem ser realizadas na página References.

Referenciando Namespaces e Componentes

Referências de projeto são usadas para acessar as propriedades, os métodos e os eventos de um objeto definido e aplicá-los em seu programa. Os tópicos a seguir contêm uma visão geral das referências no Visual Basic e Visual C# e fornecem instruções sobre como adicionar, remover e gerenciar as referências existentes.

Referências de projeto Para escrever código contra um componente externo, seu projeto deve primeiramente conter uma referência a ele. Uma referência pode ser feita aos seguintes tipos de componentes:

• Bibliotecas de classes do .NET Framework ou assemblies

• Componentes COM

• Outras bibliotecas de classes de projetos na mesma solução

• XML Web Services

Para obter mais informações sobre referências de XML Web Services, consulte Referências da Web.

Observação do Visual Basic

Referências de projeto são gerenciadas de modo diferente no Visual Studio do que como eram no Visual Basic 6.0. Para mais informações, consulte Gerenciamento de projeto para usuários do Visual Basic 6.0.

Visual Studio 276

Referências a componentes compartilhados Em tempo de execução, componentes devem estar em um dos dois locais: no caminho de saída do projeto ou no cache global de assemblies (GAC). Se o projeto contiver uma referência a um objeto que não esteja em um desses locais, a referência deve ser copiada para o caminho de saída do projeto quando o projeto é criado. A propriedade CopyLocal indica se esta cópia precisa ser feita. Se o valor for true, a referência é copiada. Se false, a referência não é copiada.

Se você implantar um aplicativo que contém uma referência a um componente personalizado que está registrado no GAC, o componente não será implantado com o aplicativo, independentemente da configuração CopyLocal. Em versões anteriores do Visual Studio, você poderia definir a propriedade CopyLocal em uma referência para garantir que o assembly fosse implantado. Agora, você deve adicionar manualmente o assembly à pasta \Bin. Isso coloca todo código personalizado sob exame detalhado, reduzindo o risco de publicar código personalizado com o qual você não está familiarizado.

Por padrão, a propriedade CopyLocal está definida como false se o assembly ou componente está no cache global de assemblies ou é um componente de estrutura. Caso contrário, o valor é definido como true. Referências de projeto-a-projeto são sempre definidas como true.

Referências de projeto-a-projeto Em uma solução com vários projetos, você pode criar referências a objetos criados em outro projeto que reside na mesma solução. Isso cria uma interdependência que requer uma consideração especial ao criar e executar o aplicativo. Para mais informações, consulte Como: preparar e gerenciar Builds.

Solucionando problemas de referências quebradas Se seu aplicativo tentar usar uma referência quebrada, um erro de exceção é gerado. A incapacidade de localizar o componente referenciado é o disparador primário do erro, mas existem várias situações em que uma referência pode ser considerada quebrada. Essas instâncias são mostradas na lista a seguir:

• O caminho de referência do projeto está incorreto ou incompleto.

• O arquivo sendo referenciado foi excluído.

• O arquivo sendo referenciado foi renomeado.

• A conexão de rede ou a autenticação falhou.

• A referência é a um componente COM que não está instalado no computador.

A seguir estão soluções para esses problemas.

Observação

Arquivos em assemblies são referenciados com caminhos absolutos no arquivo de projeto. Devido a isso, é possível que usuários trabalhando em um ambiente com vários desenvolvedores sintam a falta de um assembly referenciado no seu ambiente local. Para evitar esses erros, é melhor nesses casos adicionar referências de projeto-a-projeto. Para obter mais informações, consulte Como: adicionar ou remover referências no Visual Studio e Programando com assemblies.

Caminho de referência está incorreto

Visual Studio 277

Se projetos são compartilhados em computadores diferentes, algumas referências podem não ser encontradas quando um componente está localizado em um diretório diferente em cada computador. Referências são armazenadas sob o nome do arquivo de componente (por exemplo, MeuComponente). Quando uma referência é adicionada a um projeto, o local da pasta do arquivo de componente (por exemplo, C:\MeusComponentes\) será acrescentado à propriedade de projeto ReferencePath.

Quando o projeto é aberto, ele tenta localizar esses arquivos de componentes referenciados procurando nos diretórios no caminho de referência. Se o projeto for aberto em um computador que armazena o componente em um diretório diferente, como D:\MeusComponentes\, a referência não poderá ser encontrada e um erro aparecerá na Lista de Tarefas.

Para corrigir este problema, você pode excluir a referência quebrada e substituí-la usando a caixa de diálogo Add Reference. Uma outra solução é usar o item Reference Path em páginas de propriedades do projeto e modificar as pastas na lista para apontar para os locais correto. A propriedade ReferencePath é mantida para cada usuário em cada computador, assim modificar o seu caminho de referência não afeta outros usuários do projeto.

Dica

Referências de projeto-a-projeto não têm esses problemas. Por esse motivo, use-as em vez de referências de arquivo, se possível.

Para consertar uma referência de projeto quebrada corrigindo o caminho de referência

1. No Solution Explorer, clique com o botão direito do mouse no nó do seu projeto e clique em Properties.

2. O Project Designer aparecerá.

3. Se você estiver usando o Visual Basic, selecione a página References e clique no botão Reference Paths. Na caixa de diálogo Reference Paths, digite o caminho da pasta que contém o item que você deseja referenciar no campo Folder, depois clique no botão Add Folder.

Se você estiver usando o Visual C#, selecione a página Reference Paths. No campo Folder, digite o caminho da pasta que contém o item que você deseja referênciar, e depois clique no botão Add Folder.

Arquivo referenciado foi excluído

É possível que o arquivo sendo referenciado tenha sido excluído e não exista mais na unidade.

Para corrigir uma referência de projeto quebrada a um arquivo que não existe mais no seu disco • Excluir a referência.

• Se a referência existir em outro local no seu computador, leia-a deste local.

• Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Arquivo referenciado foi renomeado

É possível que o arquivo referenciado tenha sido renomeado.

Visual Studio 278

Para corrigir uma referência quebrada a um arquivo que foi renomeado • Exclua a referência, e depois adicione uma referência ao arquivo renomeado.

• Se a referência existir em outra local no seu computador, você precisa lê-lo daquele local. Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Conexão de rede ou autenticação falhou

Pode haver várias causas possíveis para arquivos inacessíveis: uma conexão de rede ou uma autenticação que falhou, por exemplo. Cada causa pode ter meios exclusivos de recuperação; por exemplo, você pode precisar entrar em contato com o seu administrador local para obter acesso aos recursos necessários. No entanto, excluir a referência e corrigir o código que a usa é sempre uma opção. Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Componente COM não está instalado no computador

Se um usuário tiver adicionado uma referência a um componente COM e um segundo usuário tentar executar o código em um computador que não tenha este componente instalado, o segundo usuário receberá um erro de que a referência está quebrada. Instalar o componente no segundo computador irá corrigir o erro. Para obter mais informações sobre como usar referências a componentes COM em seus projetos, consulte Interoperabilidade COM em aplicativos .NET Framework.

COMO: Adicionar ou remover referências no Visual Studio Para usar um componente em seu aplicativo, você precisa adicionar uma referência a ele. O Visual Studio provê cinco opções na Caixa de diálogo Add Reference:

• .NET — Lista todos os componentes do .NET Framework disponíveis para referência.

• COM — Lista todos os componentes COM disponíveis para referência.

• Projects — Lista todos os componentes reutilizáveis criados em projetos locais.

• Browse — Permite que você procure por um componente no sistema de arquivos.

• Recent — Contém uma lista de componentes recentemente adicionados a projetos em seu computador.

Por padrão, a caixa de diálogo Add References somente lista módulos (assemblies) que estão na pasta Public Assemblies (Program Files\Microsoft Visual Studio .NET\Common7\IDE\Public Assemblies) ou na Global Assembly Cache (GAC). Para adicionar seus próprios assemblies à lista, adicionando um caminho de referência.

Você também pode adicionar referências da Web na caixa de diálogo Add Web Reference. Para mais informações, consulte COMO: adicionar e remover referências da Web.

Observação

Você deve evitar adicionar referências de arquivo a saídas de outro projeto na mesma solução, porque

Visual Studio 279

isso pode causar erros de compilação. Em vez disso, use a guia Projects da caixa de diálogo Add References para criar referências project-to-project. Isso torna desenvolvimento em equipe mais fácil, permitindo melhor gerenciamento das bibliotecas de classes criadas em seus projetos. Para mais informações, consulte Solucionando problemas de referências quebradas.

Observação

Se você implantar/copiar um aplicativo que contém uma referência a um componente personalizado que é registrado no GAC, o componente não será implantado/copiado com o aplicativo, independentemente da configuração Copy Local. Para mais informações, consulte Referências do projeto.

Observação

O procedimento para definir o caminho de referência para projetos do Visual C# e do Visual J# é ligeiramente diferente. Para mais informações, consulte COMO: definir o caminho de referência (C#, J#).

Para adicionar uma referência 1. No Solution Explorer, clique duas vezes no nó My Project do projeto.

2. No Project Designer, clique na guia References.

3. Clique no botão Add reference para abrir a caixa de diálogo Add References.

4. Na caixa de diálogo Add Reference, selecione a guia indicando o tipo de componente que você deseja referenciar.

5. No painel superior, selecione o(s) componente(s) que você deseja referenciar, e clique OK.

Dica

Você pode selecionar vários componentes mantendo pressionada a tecla CTRL, desde que os componentes estejam todos na mesma guia.

Para remover uma referência 1. No Solution Explorer, clique duas vezes no nó My Project do projeto.


3. Na lista References, selecione a referência que deseja remover.

4. Clique no botão Remove.

Dica

Você também pode verificar seu projeto procurando referências não utilizadas e remover todas elas de uma vez. Para mais informações, consulte COMO: Remover referências não usadas.

Para definir um caminho de referência 1. No Solution Explorer, clique duas vezes no nó My Project do projeto.


Visual Studio 280

3. Clique no botão Reference Paths.

4. No campo Folder:, insira o caminho completo para a pasta que contém os componentes.

5. Clique no botão Add Folder e em seguida, clique em OK

Observação

Somente a pasta especificada será pesquisada toda vez que a caixa de diálogo Add References for aberta; subpastas não serão pesquisadas. Você deve adicionar um caminho separado para cada subpasta a ser pesquisada.

COMO: Adicionar ou remover namespaces importados Importar um namespace permite que você use elementos deste namespace sem qualificar totalmente o elemento. Por exemplo, se você desejar acessar o método Create na classe System.Messaging.MessageQueue, você pode importar o namespace System.Messaging e apenas referenciar o elemento que você precisa no código como MessageQueue.Create

Namespaces importados são gerenciados na página References do Project Designer. As importações que você especificar na esta caixa de diálogo são passadas diretamente para o compilador (/imports) e aplicadas a todos os arquivos no seu projeto. Usar a declaração Imports para utilizar um namespace em apenas um arquivo de código fonte.

Para adicionar um namespace importado 1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.


3. Na lista Imported Namespaces, selecione a caixa de seleção para o namespace que você deseja adicionar.

Observação

Para ser importado, o namespace deve estar em um componente referenciado. Se o namespace não aparecer na lista, você precisará adicionar uma referência para o componente que o contém. Para mais informações, consulte COMO: Adicionar ou remover referências no Visual Studio.

Para remover um namespace importado 1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.


3. Na lista Imported Namespaces, desmarque a caixa de seleção para o namespace que você deseja remover.

Importações do usuário Importações do usuário permitem que você importe uma classe específica de um namespace em vez do namespace inteiro. Por exemplo, seu aplicativo pode ter uma importação do namespace Systems.Diagnostics, mas a única classe no

Visual Studio 281

namespace em que você está interessado é a classe Debug. Você pode definir System.Diagnostics.Debug como uma importação de usuário, e remover a importação para System.Diagnostics.

Se você posteriormente mudar de idéia e decidir que foi realmente a classe EventLog que você necessitava, você pode inserir System.Diagnostics.EventLog como uma importação de usuário e substituir System.Diagnostics.Debug usando a funcionalidade de atualização.

Para adicionar uma importação de usuário

1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.


3. Na caixa de texto abaixo da lista Imported Namespaces, digite o nome completo do namespace que deseja importar, incluindo o espaço para o namespace raiz.

4. Clique no botão Add user import para adicionar um namespace à lista Imported Namespaces

Observação

O botão Add user import será desativado se o namespace corresponde a um já na lista; você não pode adicionar uma importação duas vezes.

Para atualizar uma importação de usuário

1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.

2. No Project Designer, clique na quia References .

3. Na lista Imported Namespaces, selecione o namespace que você deseja alterar.

4. Na caixa de texto abaixo da lista Imported Namespaces, digite o nome para o novo namespace.

5. Clique no botão Update user import para atualizar o namespace na lista Imported Namespaces.

COMO: Remover Referências Não Usadas Para reduzir o tamanho do seu aplicativo, você pode desejar remover referências a componentes que são na verdade não são chamados pelo seu código. Isso pode ser feito usando a caixa de diálogo Unused References, acessível a partir da página References do Project Designer

Para remover referências não utilizados 1. No Solution Explorer, clique duas vezes com o nó My Project do projeto.

No Project Designer, clique na guia References.

2. Clique no botão Unused references para abrir a caixa de diálogo Unused References

O projeto é varrido, e a caixa de diálogo é preenchida com uma lista de referências que não estão sendo referenciadas no seu código.

Visual Studio 282

3. Na caixa de diálogo Unused References , marque as referências que deseja remover, e em seguida, clique em Remove.

As referências selecionadas serão removidas do projeto.

COMO: Definir a propriedade Copy Local (Copiar Localmente) de uma referência

A Propriedade Copy Local (correspondente a CopyLocal) determina se uma referência é copiada para o caminho de bin local. Em tempo de execução, uma referência deve existir tanto no Cache Global de Assemblies (GAC) quanto no caminho de saída do projeto. Se essa propriedade é definida como True, a referência é copiada para o caminho de saída do projeto em tempo de execução.

Observação

Se você implantar/copiar um aplicativo que contém uma referência a um componente personalizado que está registrado no GAC, o componente não será implantado/copiado com o aplicativo, independentemente da configuração Copy Local. Para mais informações, consulte Referências de projeto.

A propriedade Copy Local está definida na caixa de diálogo Reference Properties, acessível no painel References do Project Designer.

Para definir a propriedade Copy Local como True 1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.

2. No Project Designer, selecione a guia References.

3. Selecione um componente referenciado na lista References.

As propriedades associadas a essa referência aparecem numa lista na janela Properties.

4. Selecione Copy Local da coluna esquerda, e seguida, clique na seta da coluna direita para alterar o valor para True.

Para definir a propriedade Copy Local como False 1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.

2. No Project Designer, selecione a guia References.

3. Selecione um componente referenciado na lista References

As propriedades associadas a essa referência aparecem numa lista na janela Properties.

4. Selecione Copy Local da coluna esquerda, e seguida, clique na seta na coluna direita para alterar o valor para False.

Gerenciando propriedades de depuração

As propriedades de depuração que definem o comportamento da depuração, como ação de inicício, opções de início, e depuração remota são definidas no painel

Visual Studio 283

Debug do designer de projeto. As seguintes tarefas podem ser realizadas no painel Debug.

Nesta seção

COMO: Alterar a ação de início para depuração de aplicativo

COMO: Definir opções de início para depuração de aplicativo

COMO: Ativar depuração remota

COMO: Ativar depuração de código não gerenciado

COMO: Ativar depuração de SQL Server

Gerenciando propriedades de compilação

As propriedades de compilação definindo o comportamento do compilador, como avisos do compilador, otimizações, e constantes de compilação, são definidas no painel Compile do Project Designer. As seguintes tarefas podem ser realizadas no painel Compile.

Nesta seção

COMO: Ativar ou desativar avisos do compilador

COMO: Definir otimizações do compilador

COMO: Definir opções do compilador

COMO: Alterar o local de compilação de um aplicativo

COMO: Gerar documentação XML para um projeto

COMO: Especificar eventos de construção

COMO: Registrar um componente para interoperabilidade COM

COMO: Definir constantes de compilação

COMO: Otimizar um aplicativo para um tipo de CPU específica

COMO: Especificar um endereço base para uma DLL

COMO: Especificar eventos de construção

Gerenciando Recursos de Aplicativo Você pode criar e gerenciar os recursos para o seu projeto usando o Resource Designer ou a página Resources do Project Designer. Os tipos de recurso que têm suporte para o Resource Designer incluem strings, imagens, ícones, áudio e arquivos.

COMO: Adicionar ou remover recursos Você pode usar o Designer Resource para adicionar ou editar recursos para o seu projeto. Os tipos de recurso suportados pelo Resource Designer incluem seqüências de caracteres, imagens, ícones, áudio, e arquivos. Para obter informações sobre

http://msdnwiki.microsoft.com/pt-br/mtpswiki/68c8335t(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/1ktzfy9w(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/febz73k0(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/tdw0c6sf(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/09x4a6at(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/edzzzth4(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/8tt43355(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/c553zwz0(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/1136ff2z(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/x4sa0ak0(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/7xctbe2f(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/w29wacsy(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/76zdzba1(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/5b4eyb0k(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/w4w1x6a7(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/7xctbe2f(VS.80).aspx

Visual Studio 284

como Resource Designer mantém recursos e informações de Designer, consulte Página de recursos, Designer de projeto.

O Resource Designer é uma linguagem neutra e oferece suporte para projetos em todos as linguagens do Visual Studio. Para Visual C# e Visual J#, gera recursos fortemente tipados no namespace padrão da pasta de projeto. o Resource Designer Para o Visual Basic, o Resource Designer gera recursos fortemente tipados no namespace padrão da pasta de projeto My.Resources. Para informações sobre como acessar recursos através do objeto My.Resources, consulte Acessando recursos de aplicação

Observação

Os procedimentos para adicionar e remover recursos de seqüência de caracteres diferem dos outros tipos de recurso. Para mais informações, consulte COMO adicionar ou remover recursos de seqüência de caracteres:.

Além das tarefas listadas abaixo, você pode adicionar recursos usando arrastar-e-soltar para o Resource Designer. Ao soltar, o recurso é adicionado à categoria recurso apropriada com base na sua extensão de arquivo.

Se você adicionar um recurso manualmente para o projeto (por exemplo, adicionando um arquivo .resx usando o Solution Explorer), os recursos no novo arquivo serão separados dos recursos que você criou usando a página Resource do Project Designer. Se você clicar duas vezes no novo arquivo .resx, uma janela separada do Resource Designer será aberta, exibindo conteúdo do arquivo em uma grade de configurações. Observe que quando você adicionar o novo arquivo .resx, lhe será apresentada uma mensagem perguntando, "Você deseja ativar a geração de recurso fortemente tipado para este arquivo?". Clicando Yes fornecerá o novo suporte de recurso fortemente tipado, em tempo de compilação que encapsula o acesso aos recursos criando classes que contêm um conjunto de propriedades estática e somente leitura (GET). Isso fornece uma maneira alternativa para consumir recursos, em vez de usar os métodos GetString e GetObject da classe ResourceManager. Para mais informações, consulte StronglyTypedResourceBuilder.

Para adicionar um recurso existente 1. Com um projeto selecionado no Solution Explorer, no menu Project , clique

em Properties.

2. Selecione a guia Resources.

3. Na barra de ferramentas Resource Designer, aponte para Add Resource, clique na seta, em seguida clique em Add Existing File.

4. Na caixa de diálogo Add existing file to resources, navegue até o arquivo que contém o recurso que você deseja adicionar (.bmp,.ico,.WAV, etc.,), e em seguida, clique em Open.

O arquivo será adicionado ao diretório de recursos e o Resource Designer abrirá o painel Category para o tipo de recurso que você adicionou.

5. Para recursos de arquivo, você pode definir opcionalmente as propriedades Encoding e FileType para o arquivo na janela de propriedades.

Adicionar um novo recurso 1. Com um projeto selecionado na Solution Explorer, no menu Project , clique

em Properties.

Visual Studio 285


3. Na barra de ferramentas Resource Designer, aponte para Add Resource, clique na seta, e clique no tipo de recurso que deseja criar.

4. Na caixa de diálogo Add new resource, digite um nome para o novo recurso, e em seguida, clique em Add

O arquivo será adicionado ao diretório de recursos, e um editor de recurso será aberto para o tipo de recurso que você adicionou.

5. Para recursos de arquivo, você pode definir opcionalmente as propriedades Encoding e FileType para o arquivo na janela de propriedades.

Para remover um recurso 1. Com um projeto selecionado na Solution Explorer, no menu Project , clique

emProperties.


3. Selecione um tipo de recurso a partir da lista suspensa Categories.

4. Selecione o recurso que você deseja remover.

5. Na barra de ferramentas Resource Designer, clique em Remove Resource.

O recurso será removido do Resource Designer, mas ele não será removido da pasta Recursos.

COMO: adicionar ou remover recursos de seqüência de caracteres Você pode usar o Resource Designer para adicionar ou editar recursos de seqüência de caracteres para o seu projeto Para obter informações sobre como o Resource Designer mantém recursos e informações de Designer, consulte Página de recursos, Designer de projeto.

O Resource Designer é uma linguagem neutra e oferece suporte para projetos em todos os idiomas do Visual Studio. Para Visual C# e Visual J#, o Resource Designer gera recursos fortemente tipado no espaço para nome padrão da pasta de projeto. Para o Visual Basic, o Resource Designer gera recursos fortemente tipados no espaço de nome padrão My.Resources para a pasta de projetos. Para informações sobre como acessar recursos através do objeto My.Resources, consulte acessando recursos de aplicação

Se você adicionar um recurso manualmente para o projeto (por exemplo, adicionando arquivo .resx usando Solution Explorer), os recursos no novo arquivo serão separados dos recursos que você cria usando a página Resource do Project Designer. Se você clicar duas vezes no novo arquivo .resx, será aberta uma janela Resource Designer separada, exibindo os conteúdos do arquivo em uma grade configurações. Observe que quando você adicionar o novo arquivo .resx, lhe será apresentada uma mensagem perguntando, " Você deseja ativar a geração do recurso fortemente tipado para este arquivo? "Clicar Yes fornecerá suporte para o novo recurso fortemente tipado, um recurso em tempo de compilação que encapsula o acesso aos recursos criando classes que contêm um conjunto de propriedades estática e somente leitura (get). Isto fornece uma maneira alternativa para consumir recursos, em vez de usar os métodos GetString e GetObject da classe ResourceManager. Para mais informações, consulte StronglyTypedResourceBuilder.

Visual Studio 286

Você também pode adicionar recursos de seqüência de caracteres usando a edição arrastar-e-soltar com o Resource Designer. Ao arrastar e soltar seqüências de caracteres, os campos Name, Value e Comment devem ser separados por tabulações ou a seqüência inteira será adicionada à coluna Name

Para adicionar um recurso de seqüência de caracteres 1. Com um projeto selecionado no Solution Explorer, no menu Project ,


2. Clique na guiaResources. Na barra de ferramentas Resource Designer, aponte para a lista suspensa, clique na seta, e certifique-se de que ele esteja definido como Strings (que é o padrão). Uma grade de configurações aparecerá, exibindo as seqüências de caracteres mantidas por essa instância do Resource Designer.

3. Clique na coluna Name da última linha da grade, que está marcada com um asterisco (*).

4. Na coluna Name, insira um nome para a seqüência de caracteres.

5. Na coluna Value, insira a seqüência de caracteres a ser usada como um recurso.

6. Opcionalmente, digite um comentário na coluna Comment.

Observação

Comentários não são compilados no aplicativo; eles estão disponíveis somente em tempo de projeto.

Para remover um recurso de seqüência de caracteres 1. Com um projeto selecionado no Solution Explorer, no menu Project ,


2. Clique na guia Resources.

3. Na barra de ferramentas Resource Designer, aponte para a lista suspensa, clique na seta, e certifique-se de que ele esteja definido como Strings (que é o padrão).

4. Selecione a linha que contém a seqüência de caracteres que você deseja remover clicando no cabeçalho da linha cinza.

5. Na barra de ferramentas Resource Designer, clique em Remove Resource.

COMO: Editar Recursos Você pode usar o Resource Designer para adicionar ou editar recursos para o seu projeto. Os tipos de recursos suportados pelo Resource Designer incluem seqüências de caracteres, imagens, ícones, áudio, e arquivos. Para obter informações sobre como o Resource Designer mantém os recursos e as informações de designer, consulte Página de recursos, Designer de projeto.

O Resource Designer é neutro com relação a linguagem e oferece suporte a projetos para todas as linguagens do Visual Studio. Para Visual C# e Visual J#, o Resource Designer gera recursos fortemente tipados no namespace padrão da pasta do projeto. Para o Visual Basic, o Resource Designer gera recursos

Visual Studio 287

fortemente tipados no namespace My.Resources. Para informações sobre como acessar recursos através do objeto My.Resources, consulte Acessando Recursos da Aplicação

Observação

Os procedimentos para recursos de edição de seqüências de caracteres diferem dos outros tipos de recursos. Para mais informações, consulte COMO: Recursos de Edição de Seqüências de caracteres.

Cada tipo de recurso é editado usando um editor associado com a extensão de seu arquivo. Por exemplo, o editor padrão para imagens bitmap (.bmp) pode ser o Visual Studio Bitmap Editor, mas o editor padrão para imagens JPEG (.jpg) pode ser o Windows Paint. Você pode abrir qualquer arquivo de recursos em um editor diferente usando o comando Open With, e você pode alterar o editor padrão de qualquer tipo de recurso. Para mais informações, consulte COMO: Associar um editor com um tipo de recurso.

Para editar um recurso usando o editor padrão 1. Com um projeto selecionado no Solution Explorer, no menu Project clique

em Properties.

2. Clique na guia Resources .

3. Na barra de ferramentas Resource Designer, aponte na lista suspensa de exibição de recursos, clique na seta e selecione o tipo de recurso que você deseja para editar

4. Clique duas vezes no recurso para abrir o editor padrão para aquele tipo de recurso.

Para editar um recurso usando um editor diferente 1. Com um projeto selecionado no Solution Explorer, no menu Project clique

em Properties.


3. Na barra de ferramentas Resource Designer, aponte para a lista suspensa de exibição de recursos, clique na seta e selecione o tipo de recurso que você deseja para editar

4. Selecione o recurso que deseja editar, clique nele com o botão direito do mouse e escolha Open With a partir do menu de contexto.

5. Na caixa de diálogo Open With, escolha um editor a partir da lista Choose the program you want to use to open this file:.

O arquivo de recurso é aberto no editor selecionado.

Observação

O editor deve ser capaz de editar o tipo de recurso selecionado; por exemplo, você não pode editar um arquivo de bitmap em um editor de texto.

Visual Studio 288

COMO: Editar recursos que são seqüências de caracteres Você pode usar o Resource Designer (Designer de recurso) para adicionar ou editar recursos para o seu projeto. Os tipos de recursos suportados pelo Resource Designer incluem seqüências de caracteres, imagens, ícones, áudio e arquivos. Para obter informações sobre como o Resource Designer mantém recursos e informações do designer, consulte Página de recursos, Project Designer.

O Resource Designer é neutro com relação à linguagem e oferece suporte a projetos em todas as linguagens do Visual Studio. Para o Visual C# e Visual J#, o Resource Designer gera recursos fortemente tipados no namespace padrão da pasta de projeto. Para o Visual Basic, o Resource Designer gera recursos fortemente tipados no namespace My.Resources. Para informações sobre como acessar recursos através do objeto My.Resources, consulte Acessando recursos de aplicativos

Você pode recortar, copiar, e colar recursos que são seqüências de caracteres entre as linhas no editor de seqüências de caracteres, entretanto, você não pode colar valores individuais ou comentários. Ao copiar e colar seqüências de caracteres de uma origem externa, os campos Name (Nome), Value (Valor) e Comment (Comentário) devem ser separados por tabulações ou a seqüência de caracteres inteira será adicionadas à coluna Name.

Para editar um recurso que é uma seqüência de caracteres 1. Com um projeto selecionado no Solution Explorer (Explorer de Solução), no

menu Project (Projeto), clique em Properties (Propriedades).

2. Selecione a guia Resources (Recursos).

3. Na barra de ferramentas Resource Designer, aponte para o modo recurso suspenso, clique na seta e certifique-se de que ele esteja definido como Strings (seqüências de caracteres, que é o padrão). Uma grade de configurações aparecerá, exibindo as seqüências de caracteres mantidas por essa instância do Resource Designer.

4. Selecione a célula na tabela de seqüências de caracteres que você deseja editar e comece a digitar.

Para copiar recursos que são seqüências de caracteres 1. Com um projeto selecionado no Solution Explorer, no menu Project, clique

em Properties.


3. Na barra de ferramentas Resource Designer, aponte para o modo recurso suspenso, clique na seta, e certifique-se de que ele esteja definido como Strings (seqüências de caracteres, que é o padrão). Uma grade de configurações aparecerá, exibindo as seqüências de caracteres mantidas no Resources.resx.

4. Selecione a linha que contém o recurso que é uma seqüência de caracteres a ser copiado clicando no cabeçalho da linha cinza.

5. No menu Edit (Editar), clique em Copy (Copiar).

6. No menu Edit, clique em Paste (Colar).

Visual Studio 289

Uma cópia do recurso que é uma seqüência de caracteres será adicionado como uma nova linha na tabela de seqüências de caracteres.

COMO: Associar um editor com um tipo de recurso Você pode usar o Resource Designer para adicionar ou editar recursos para o seu projeto. Tipos de recurso suportados pelo Resource Designer incluem seqüências de caracteres, imagens, ícones, áudio, e arquivos. Para obter informações sobre como o Resource Designer mantém os recursos e informações de designer, consulte Página de recursos, Designer de projeto.

O Resource Designer é neutro à linguagem e oferece suporte a projetos para todas as linguagens do Visual Studio. Para Visual C# e Visual J#, o Resource Designer gera recursos fortemente tipados no namespace padrão da pasta do projeto. Para o Visual Basic, o Resource Designer gera recursos fortemente tipados no namespace My.Resources. Para informações sobre como acessar recursos através do objeto My.Resources, consulte Acessando Recursos da Aplicação

Você pode editar cada tipo de recurso usando um editor padrão associado a extensão de seu arquivo. Por exemplo, o editor padrão para imagens bitmap (.bmp) pode ser o Visual Studio Resource Editor, mas o editor padrão para imagens JPEG (.jpg) pode ser do Windows Paint. Você pode abrir qualquer arquivo de recurso em um editor diferente usando o comando Open With, e você pode alterar o editor padrão para qualquer tipo de recurso.

Para alterar o editor padrão de um tipo de recurso 1. Com um projeto selecionado no Solution Explorer, no menu Project clique

em Properties.


3. Na barra de ferramentas Resource Designer, aponte para a lista suspensa de exibição de recurso, clique na seta e selecione o tipo de recurso que você deseja editar.

4. Selecione o recurso que deseja editar, clique com o botão direito do mouse e escolha Open With a partir do menu de contexto.

5. Na caixa de diálogo Open With, escolha um editor a partir da lista Choose the program you want to use to open this file:.

6. Clique no botão Set as Default.

Observação

A configuração de um editor padrão para um tipo de arquivo no Resource Designer também o define como padrão para o Visual Studio. Por exemplo, se você definir o Bloco de Notas como o editor padrão para arquivos.txt, ao clicar duas vezes em um arquivo .txt no Solution Explorer esse arquivo será aberto no Bloco de notas.

Visual Studio 290

Recursos Vinculados versus Recursos Incorporados Os projetos Visual Studio fornecem duas opções diferentes para manipular recursos; eles podem ser vinculados (o padrão) ou incorporados. Mesmo sendo possível ter ambos os recursos, vinculados e incorporados, em um único projeto, na maioria dos casos você irá querer escolher uma opção para todos os recursos do seu projeto.

Os recursos vinculados são armazenados como arquivos dentro do projeto; durante a compilação os dados dos recursos são obtidos dos arquivos e colocado no manifesto do aplicativo. O arquivo de recursos do aplicativo (.resx) armazena somente um caminho relativo ou um link para o arquivo em disco.

Com os recursos incorporados, os dado dos recursos são armazenados diretamente no arquivo .resx, em uma representação textual dos dados binários. Em ambos os casos, os dados dos recursos são compilados no arquivo executável.

Você pode alterar os recursos de vinculados para incorporados, alterando a propriedade Persistence para o arquivo de recurso. Para mais informações, consulte HOW TO: Criar Recursos Incorporados.

Observação

Os recursos string são sempre incorporados e não podem ser alterados; os recursos de arquivo são sempre vinculados e não podem ser alterados.

Escolhendo entre Recursos Incorporados e Recursos Vinculados Na maioria dos casos, você deve preferir os recursos vinculados padrão. Entretanto, há casos em que os recursos incorporados podem ser uma escolha melhor.

Recursos Incorporados

Os recursos incorporados são a melhor opção se você precisa compartilhar arquivos de recurso do aplicativo (.resx) entre vários projetos. Por exemplo, se você tiver um arquivo de recurso comum que contém os logotipos de sua empresa, informação de marca, etc., usar recursos incorporados significa que você tem apenas que copiar o arquivo .resx e não os arquivos de dados de recursos associados.

Você não pode editar os recursos incorporados diretamente. Se você tentar editar um recurso incorporado, você receberá uma mensagem solicitando que você converta o item para um recurso vinculado na ordem para editá-lo; a conversão é recomendada mas opcional. Você deve exportá-los, fazer suas modificações em um programa externo, e depois importá-los de volta para seu projeto.

Para mais informações, consulte HOW TO: Importar ou Exportar Recursos.

Recursos Vinculados

Os recursos vinculados (o padrão) são a melhor opção pela facilidade de uso. Os recursos podem ser editados diretamente dentro do projeto, e você pode facilmente adicionar ou remover recursos conforme o necessário.

Visual Studio 291

COMO: Criar recursos incorporados Quando você adiciona recursos a um projeto do Visual Studio, eles são criados como recursos vinculados. Em alguns casos, convém incorporar os recursos no arquivo de recurso do aplicativo (.resx). Para mais informações, consulte Recursos vinculados vs. incorporados.

Os recursos podem ser alterados de vinculados a recursos incorporados na página Resources (Recursos) do Project Designer (Designer de Projeto).

Observação

Recursos que são seqüências de caracteres são sempre incorporados ao arquivo .resx e não podem ser alterados para recursos vinculados; recursos que são arquivos são sempre vinculados.

Para alterar um recurso de vinculado para incorporado 1. Com um projeto selecionado no Solution Explorer (Explorer de Solução),



3. Na barra de ferramentas Resource Designer (Designer de Recurso), aponte para o modo de exibição de recurso suspenso, clique na seta e selecione o tipo de recurso que você deseja editar.

4. Selecione o recurso que você deseja alterar.

5. Na janela Properties, selecione a propriedade Persistence (Persistência) e altere-a para Embedded in .resx (Incorporado no .resx).

Para alterar um recurso de incorporado para vinculado 1. Com um projeto selecionado no Solution Explorer, no menu Project, clique

em Properties.


3. Na barra de ferramentas Resource Designer, aponte para o modo de exibição de recurso suspenso, clique na seta e selecione o tipo de recurso que você deseja editar.

4. Selecione o recurso que você deseja alterar.

5. Na janela Properties, selecione a propriedade Persistence e altere-a para Linked at compile time (Vinculado em tempo de compilação).

COMO: Importar ou exportar recursos Você não pode editar recursos incorporados em um projeto do Visual Studio diretamente no IDE do Visual Studio; você deve exportá-los e editá-los em um programa externo, e em seguida importá-los de volta para o projeto.

Observação

Visual Studio 292

Por padrão, todos os recursos em um projeto do Visual Studio são criados como recursos vinculados; você precisa convertê-los explicitamente para recursos incorporados. Para mais informações, consulte Recursos vinculados versus incorporados.

Para exportar um recurso 1. Com um projeto selecionado na Solution Explorer, no menu Project clique

em Properties.


3. Na barra de ferramentas do Resource Designer, aponte para a lista suspensa de exibição de recurso, clique na seta e selecione o tipo de recurso que você deseja editar

4. Selecione o recurso que você deseja exportar.

5. Clique com o botão direito do mouse e escolha Export To File no menu de contexto.

Observação

Este comando só estará disponível para recursos incorporados.

6. Na caixa de diálogo Export resource to file, procure a localidade para onde você deseja exportar o arquivo, e clique em Save.

Para importar um recurso 1. Com um projeto selecionado no Solution Explorer, no menu Project clique

em Properties.


3. Na barra de ferramentas do Resource Designer, aponte para a lista suspensa de exibição de recurso, clique na seta e selecione o tipo de recurso que você deseja editar

4. Selecione o recurso que você deseja importar.

5. Clique com o botão direito do mouse e escolha Import From File no menu de contexto.

Observação

Este comando só estará disponível para recursos incorporados.

6. Na caixa de diálogo Import file into resource, navegue até o arquivo que deseja importar, e em seguida, clique em Open

Gerenciando definições do aplicativo A página Settings do Project Designer é usada para especificar configurações de aplicativo para o seu projeto. As tarefas a seguir podem ser realizadas na página Settings:

Visual Studio 293

Configurações de aplicativo Configurações de aplicativos permitem a você guardar e recuperar configurações de propriedades e outras informações da sua aplicação dinamicamente, e elas permitem manter configuração de aplicativos e usuários personalizadas no computador local. Freqüentemente são dados (como uma seqüência de endereço de conexão) críticos para executar o aplicativo que você não deseja incluir diretamente no código do aplicativo. Você pode querer armazenar duas seqüências de conexão de banco de dados diferentes e recuperar uma deles em tempo de execução com base na localidade do computador. Ou, pode preferir armazenar as preferências de cor do usuário para recuperá-las na próxima vez que o aplicativo é executado.

Atente ao fato de que configurações do aplicativo são um recurso do Microsoft Visual Studio 2005 que substitui o recurso de propriedades dinâmicas da versão anterior (para informações sobre propriedades dinâmicas, consulte Configurando aplicativos usando propriedades dinâmicas).

Cada configuração de aplicativo deve ter um nome exclusivo; o nome pode ser qualquer combinação de letras, números ou um sublinhado; desde que não seja iniciada com um número e não contenha espaços. O nome pode ser alterado através da propriedade Name.

As configurações do aplicativo podem ser armazenadas como qualquer tipo de dados que seja serializável em XML ou que tenha um TypeConverter que implementa ToString / FromString. Os tipos mais comuns são String, Integer e Boolean, mas você também pode armazenar valores como Color, Object ou como uma seqüência de conexão.

Configurações do aplicativo também contém um valor. O valor é definido com a propriedade Value e deve corresponder ao tipo de dados da configuração.

Além disso, configurações do aplicativo podem ser vinculadas diretamente a uma propriedade de um formulário ou controle em tempo de projeto. Para mais informações, consulte COMO: Adicionar ou remover configurações de aplicativo.

Há dois tipos de configurações de aplicativo, com base no escopo:

• Configurações Application-Scoped podem ser usadas para informações como uma URL para um serviço da Web ou uma seqüência de conexão de banco de dados. Esses valores estão associados com o aplicativo, para que os usuários não possam alterá-los em tempo de execução.

• Configurações User-Scoped podem ser usadas para informações como lembrar a última posição de um formulário ou uma preferência de fonte. Usuários pode alterar esses valores em tempo de execução.

Você pode alterar o tipo de uma configuração usando a propriedade Scope.

O sistema de projeto armazena as configurações do aplicativo em dois arquivos XML: um arquivo app.config, que é criado em tempo de projeto quando você cria a primeira configuração de aplicativo; e um arquivo user.config, que é criado em tempo de execução quando o usuário executando o aplicativo altera o valor de qualquer configuração de usuário. Observe que alterações nas configurações de usuário não são gravadas em disco a menos que o aplicativo especificamente chame um método para fazer isso.

Criar configurações de aplicativo em tempo de projeto Em tempo de projeto, você pode criar configurações do aplicativo de duas maneiras: com a página Settings do Project Designer ou com a janela

Visual Studio 294

Properties para um formulário ou controle, permitindo que você possa vincular uma configuração diretamente a uma propriedade. Para mais informações, consulte COMO: Adicionar ou remover configurações de aplicativo.

Quando você cria uma configuração Application-Scoped (por exemplo, uma seqüência de conexão de banco de dados, ou uma referência a recursos do servidor), o Visual Studio a salvará em app.config com a marca <applicationSettings> (seqüências de conexão são salvas sob a marca <connectionStrings>).

Quando você cria uma configuração User-Scoped (por exemplo, fonte padrão, home page ou tamanho da janela), o Visual Studio a salvará em app.config com a marca <userSettings>.


Quando você armazenar seqüências de conexão em app.config, você deve tomar precauções para evitar revelar informações sigilosas, como senhas ou caminhos do servidor, na seqüência de conexão.

Se você recebe informações da seqüência de conexão de uma origem externa, como um usuário fornecendo uma identificação de usuário e senha, você deve tomar cuidado para garantir que os valores usados para construir a seqüência de conexão não contêm parâmetros adicionais que alterem o comportamento da conexão.

Considere usar o recurso Protected Configuration para criptografar informações sigilosas no arquivo de configuração. Consulte Protegendo seqüências de conexão para obter mais informações.

Observação

Devido ao fato de não haver nenhum modelo de arquivo de configuração para bibliotecas de classe, configurações do aplicativo não se aplicam a projetos Class Library. A exceção é um projeto Visual Studio Tools for Office DLL, que pode ter um arquivo de configuração.

Acessar ou alterar configurações de aplicativo em tempo de execução no Visual Basic

Observação

Esta seção se aplica somente a projetos do Visual Basic.

Em tempo de execução, você pode acessar configurações de aplicativo usando o objeto My.Settings. Na página Settings, clique no botão View code para exibir o arquivo Settings.vb (para obter mais informações, consulte COMO: acessar Settings Events). Settings.vb define a classe Settings, que permite a você manipular esses eventos na classe de configurações: SettingChanging, PropertyChanged., SettingsLoaded e SettingsSaving Observe que a classe Settings no Settings.vb é uma classe parcial, mostrando apenas o código user-owned (cujo usuário é o proprietário), não a classe toda gerada. Para obter mais informações sobre como acessar configurações de aplicativo usando o objeto My.Settings, consulte Acessando configrações de aplicativo.

Os valores de quaisquer configurações User-Scoped que o usuário altere em tempo de execução (por exemplo, a posição do um formulário) são armazenados em um arquivo user.config. Observe que os valores padrão ainda são salvos no app.config.

Visual Studio 295

Se você tiver alterado quaisquer configurações User-Scoped em tempo de execução durante testes do aplicativo, por exemplo, e deseja redefinir essas configurações para seus valores padrão, clique no botão Synchronize. Para informações sobre este controle, consulte Página Settings, Project Designer.

COMO: Adicionar ou remover configurações de aplicativo As configurações de aplicativo permitem a você armazenar e recuperar configurações de propriedade e outras informações para seu aplicativo dinamicamente. Há dois tipos de configurações de aplicativo, com base no escopo: configurações do escopo do usuário e do escopo do aplicativo.

Em tempo de design, você pode adicionar configurações de aplicativo usando o painel Settings do Project Designer, ou utilizando a janela Properties para um formulário ou controle, que permite a você vincular uma configuração diretamente a uma propriedade.

Para adicionar configurações de aplicativo no Project Designer 1. Selecione um projeto no Solution Explorer; no menu Project , clique em

Properties.

2. Selecione o painel Settings.

3. Clique em uma linha em branco na grade Settings

4. Digite um nome para a configuração na coluna Name. O nome não pode conter espaços.

5. Selecione um tipo de dados para a configuração na lista suspensa Type.

6. Selecione o escopo da configuração na lista suspensa Scope. A configuração do escopo pode ser Application ou User.

7. Insira um valor padrão para a configuração na coluna Value. O valor deve ser apropriado para o tipo de dado selecionado.

Para adicionar configurações de aplicativo na janela Properties 1. Selecione um formulário ou controle no Form Designer; no menu View,

clique em Properties Window.

2. Na janela Properties, expanda a propriedade (Application Settings) (localizada sob o nó Data).

3. Selecione a propriedade (Property Binding) e clique no botão de reticências (...) para abrir a caixa de diálogo Application Settings.

4. Na caixa de diálogo Application Settings, selecione a propriedade a qual você deseja adicionar uma configuração de aplicativo.

5. Na lista suspensa para a propriedade, clique em (New...) para abrir a caixa de diálogo New Application Setting.

6. Na caixa de diálogo New Application Setting, selecione a propriedade Name e digite um nome para a configuração. O nome não pode conter espaços.

7. Selecione a propriedade DefaultValue e digite um valor padrão para a configuração.

Visual Studio 296

8. Selecione o escopo da configuração na lista suspensa Scope. A configuração do escopo pode ser Application ou User.

9. Para vincular a nova configuração à propriedade, selecione-a na lista suspensa, e em seguida clique em OK.

A ligação da propriedade será adicionada à janela Properties, e a nova configuração será adicionada ao Project Designer. Observe que depois de ter criado a configuração, você deve usar o Project Designer para alterá-la.

Para remover configurações de aplicativo 1. Selecione um projeto no Solution Explorer; no menu Project , clique em

Properties.


3. Na grade Settings, clique na linha da configuração que você deseja remover.

4. Pressione a tecla Delete ou clique com o botão direito do mouse e selecione Remove Setting.

A configuração será removida do Project Designer.

Observação

Será necessário remover configurações manualmente do App.config porque o Project Designer não remove quaisquer referências para configurações de aplicativo no código ou em seu próprio código.

COMO: Acessar eventos de configuração Os eventos de configuração permitem que você escreva o código em resposta às alterações de escopo do aplicativo ou do usuário. Os eventos de configuração incluem:

• O evento SettingChanging é disparado antes que o valor de uma configuração seja alterado.

• O evento PropertyChanged é disparado após o valor de uma configuração ter sido alterado.

• O evento SettingsLoaded é disparado após os valores de configuração serem carregados.

• O evento SettingsSaving é disparado antes dos valores de configuração serem salvos.

Para informações sobre como programar usando esses eventos, consulte Acessando configurações de aplicativo

Os eventos de configuração podem ser acessados a partir do painel Settings do Project Designer.

Para acessar eventos de configuração 1. Selecione um projeto no Solution Explorer, e em seguida, no menu

Project , clique em Properties


Visual Studio 297

3. Clique no botão View code para abrir o arquivo Settings.vb ou Settings.cs no editor de códigos. Esse arquivo define métodos que manipulam os eventos disparados quando as configurações de usuário são alteradas, carregadas, ou salvas.

Gerenciando propriedades de projeto C# e J# Você pode usar o Project Designer para definir propriedades em projetos Visual C# e Visual J# . Os tópicos nesta seção se aplicam especificamente a projetos Visual C# e Visual J# . Os tópicos de seções relacionadas se aplicam a propriedades de projeto Visual C# e Visual J#, bem como propriedades de projeto Visual Basic.

Como definir propriedades do projeto (C#, J#): Propriedades de um projeto especificam como um projeto é criado e depurado, bem como que bibliotecas ele referencia, como e onde ele é publicado, e quaisquer configurações de segurança a serem usadas. Use o Project Designer para definir as propriedades do projeto. Para mais informações, consulte Introdução ao Project Designer.

Observação

As opções disponíveis na caixas de diálogo e os nomes e locais de comandos de menu que você vê podem ser diferentes das que são descritas na Ajuda dependendo das suas configurações ativas ou edição. Esta página de Ajuda foi escrita baseada na idéia de General Development settings. Para exibir ou alterar suas configurações, escolha Import and Export Settings no menu Tools. Para mais informações, consulte Configurações do Visual Studio.

Definindo propriedades usando o Project Designer Você pode exibir as configurações de propriedades no Project Designer quando você seleciona o projeto no Solution Explorer.

Observação

Acesse as propriedades de um arquivo individual na janela Properties.

Para definir as propriedades do projeto no Project Designer

1. No Solution Explorer, selecione o projeto.

2. No menu Project, clique em <Project Name> Properties.

3. Selecione o nome da página de propriedades a ser alterada ou visualizada.

4. Defina as propriedades.

Observação

O Project Designer não possui botões OK ou Cancel. Todas as alterações de propriedade terão efeito imediato no projeto ativo; entretanto, as configurações são confirmadas para o arquivo do projeto somente quando você seleciona uma das opções de salvamento ou quando você fecha o designer.

Visual Studio 298

Observação

Propriedades que estão cinza são definidas em outros painéis de propriedades. Elas são exibidas somente para fins informativos.

Se você tiver uma solução de multiprojeto, você pode usar mais de uma instância do Project Designer ao mesmo tempo.

COMO: Definir o Caminho de Referência (C#, J#) Quando você faz referência a uma assembly em seu projeto, Visual Studio primeiramente procurará a assembly no diretório do projeto. Se você usar uma assembly não localizada no diretório do projeto, você pode especificar sua localidade na Página Project Designer, Reference Path (C#, J#) do Project Designer.

Observação

O procedimento para definir o caminho de referência para projetos Visual Basic é ligeiramente diferente. Para mais informações, consulte COMO: Adicionar ou Remover Referências no Visual Studio.

Observação

Se a referência para a assembly não estiver no projeto ou listada no painel Reference Paths do Project Designer, o Visual Studio verifica as pastas exibindo os arquivos na Caixa de Diálogo Add Reference.

Você pode adicionar quantos caminhos de referência forem necessários.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais de comandos de menu você vê podem ser diferentes dos que são descritos na Ajuda, dependendo da sua edição ou configuração ativa. Esta página Ajuda foi escrito com as General Development settings em mente. Para exibir ou alterar as configurações, escolha Import and Export Settings no menu Tools. Para mais informações, consulte Configurações Visual Studio.

Para definir um caminho de referência 1. No Solution Explorer, selecione o projeto.

2. No menu Project, clique em <Nome do Projeto> Properties.

3. Clique em Reference Paths.

4. Na caixa de texto Folder, especifique o caminho para a pasta contendo módulos (assemblies). Para procurar a pasta, clique nas reticências (…).

5. Clique em Add Folder.

Para substituir um caminho de referência 1. No Solution Explorer, selecione o projeto.

Visual Studio 299



4. Na caixa Reference Path, selecione o caminho para sobrescrever.

5. Na caixa de texto Folder, especifique o caminho para a pasta contendo módulos (assemblies). Para procurar o caminho, clique nas reticências (…).

6. Clique em Update. O caminho selecionado na caixa Reference Path é sobrescrito pelo caminho especificado na caixa de texto Folder.

Para remover um caminho de referência 1. No Solution Explorer, selecione o projeto.



4. Na caixa Reference Path, selecione o caminho para remover.

5. Clique em Remove.

COMO: Definir as Propriedades de Compilação (C#, J#) Usando o Build Pane e o Build Events Pane do Visual Studio Project Designer, você pode especificar as configurações e os eventos de compilação para controlar a configuração de compilação e a compilação do seu projeto. Veja Página de Compilação, Project Designer (C#), Página de Compilação, Project Designer (J#) e Eventos da Página de Compilação, Project Designer (C#, J#) para obter mais informações.

Você pode definir as opções do compilador, os eventos de pré-compilação e os eventos de pós-compilação a partir do Project Designer. Consulte COMO: Especificar Eventos de Compilação (C#, J#) para obter mais informações sobre como usar o Project Designer para selecionar os eventos de pré e pós-compilação.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Esta página de Ajuda foi escrita com o General Development settings como base. Para exibir ou alterar as configurações, escolha Import and Export Settings no menu Tools. Para mais informações, consulte Configurações do Visual Studio.

Para acessar e modificar as propriedades de compilação 1. No Solution Explorer, selecione o projeto para o qual você deseja especificar

o evento de compilação.

2. No menu Project, clique em <Project Name> Properties.

3. Selecione a guia Build.

4. A partir da lista Configuration, especifique a sua configuração: Ativa (Depuração), Depuração ou compilação de Versão Final. Por padrão, esta opção é definida como Ativa (Depuração).

Visual Studio 300

5. Defina as propriedades de compilação restantes, incluindo quaisquer configurações avançadas. Consulte Caixa de Diálogo Advanced Build Settings (C#) ou Caixa de Diálogo Advanced Build Settings (J#) para obter mais informações.

COMO: Especificar eventos de compilação Eventos de compilação no Visual Basic podem ser usados para executar scripts, macros ou outras ações como parte do processo de compilação. Eventos pre-build ocorrerão antes da compilação; eventos post-build ocorrem após a compilação.

Eventos de compilação são especificado na caixa de diálogo Build Events, acessível da página Compile do Project Designer.

Para especificar eventos de compilação 1. Com um projeto selecionado no Solution Explorer, clique em Properties

no menu Project.

2. Clique na guia Compile.

3. Clique no botão Build Events para abrir a caixa de diálogo Build Events

4. Insira os argumentos de linha de comando para a ação pre-build ou post-build, e clique OK.

COMO: Adicionar e remover referências no Visual Studio (C#, J#) A caixa de diálogo Add Reference pode ser usada para adicionar ou excluir referências de projeto. Esta caixa de diálogo pode ser acessada a partir do menu Project. Para mais informações, consulte Caixa de diálogo Add Reference.

Para adicionar uma referência de projeto 1. No Solution Explorer, selecione o projeto.

2. No menu Project, escolha Add Reference.

A caixa de diálogo Add Reference é aberta.

3. Selecione a guia indicando o tipo de componente que você deseja referenciar.

4. No painel superior, selecione o componente que você deseja referenciar, e depois clique no botão Select. Pressione e segure a tecla CTRL enquanto clica para selecionar vários componentes.

Dica

Se o componente que você estiver procurando não estiver na lista, você pode localizá-lo usando o botão Browse.

5. Clique em OK depois que você tiver selecionado todos os componentes necessários.

As referências selecionadas serão exibidas sob o nó References do projeto.

Visual Studio 301

Para remover uma referência de projeto • No Solution Explorer, clique com o botão direito do mouse na referência sob

o nó References, e selecione Remove no menu de atalho.

Local e projetos da Web Não há vários fatores a considerar quando você decide se usar um local ou modelo do projeto da Web para seu aplicativo.

Primeiro, estratégia instalação devem desempenhar um papel no sua decisão geral. Se você precisar um aplicativo Quick-deploying em um servidor com a configuração do cliente mínima, o modelo de projeto da Web é melhor. Você pode instalar e executar este projeto no servidor sem instalar arquivos de suporte em cada cliente, e fazer atualizações somente em servidor. Entretanto, para projetos que têm pouca envolvimento servidor ou para aplicativos autônomos, um modelo de projeto local é a melhor opção. No nesse cenário, atualizações pode ser concluída em cada computador cliente individual.

Outro fator é a divisão de carga. Quando Analisando estrutura do seu aplicativo, você precisa considerar a maior do trabalho para onde está indo a ser feito. Projetos da Web oferecem uma estratégia servidor onde a maioria das operações são conduzidas no servidor. O computador cliente utiliza um navegador da Web para enviar informações para e exibir informações do aplicativo do servidor. Se os recursos do servidor estão limitados, considere usando um modelo de projeto local para seu aplicativo. O trabalho pode ser feito no computador cliente sem consumindo hora servidor precious.

A tabela a seguir fornece uma comparação lado a lado de projetos da Web e projetos no design e ambientes de trabalho local:

Consideração Projeto da Web Projeto local

Armazenamento de arquivos durante o desenvolvimento

Os arquivos são armazenados em um URL especificado em um computador com Serviços de Informações da Internet (IIS) instalado. O projeto também mantém um cache temporário de arquivos em computadores cliente para trabalhar off-line.

Arquivos projeto são armazenados no computador local.

Criar modelo ao desenvolver

Código de aplicativo é compilado como uma DLL e executar no servidor. Resultados são visto no computador cliente.

Código é compilado e executado no computador cliente.

Método de implantação

O projeto é implantado em um servidor Web. Arquivos de projeto são instalados no computador cliente com arquivos de suporte necessários.

Carga de trabalho Computadores cliente executar o aplicativo remotamente com um navegador da Web. Processamento é feito principalmente no servidor.

O aplicativo é executado localmente em o computador cliente.

Visual Studio 302

Atualizar Alterações de aplicativo são feitas no nível do servidor sem instalação dos arquivos de suporte em computadores clientes.

As atualizações de aplicativos são instalados em computadores cliente.

Movendo arquivos projeto

O comando Copy Project é usado para mover arquivos para o URL especificado.

Fisicamente arquivos projeto são copiados de uma localidade para outro.

Propriedades de arquivo Você pode usar propriedades de arquivo para indicar quais ações o sistema do projeto deve executar nos arquivos. Por exemplo, você pode definir propriedades de arquivo para indicar se um arquivo deve ser compilado ou incorporado à saída da compilação como um recurso

Você pode selecionar qualquer arquivo no Solution Explorer e depois examinar suas propriedades na janela Properties. Arquivos do Visual Basic e Visual C# têm quatro propriedades: FileName, BuildAction, CustomTool, e CustomToolNamespace.

Observação

As propriedades BuildAction, CustomTool, e CustomToolNamespace são fornecidas para cenários avançados. Os valores padrão são normalmente suficientes e não precisam ser alterados.

Propriedade FileName Você pode renomear um arquivo, clicando na propriedade Propriedade FileName (Extensões para VB e CSharp) na janela Properties e digitando o novo nome. Observe que se você alterar o nome do arquivo, o Visual Studio automaticamente renomeará qualquer arquivo .vb ou .resx associados a ele.

Propriedade BuildAction A Propriedade BuildAction (Visual Basic e C# ProjectItem Object) indica o que o Visual Studio faz com um arquivo quando uma compilação é executada. BuildAction pode ter um dos vários valores:

• None. O arquivo não é incluído no grupo de saída do projeto e não é compilado no processo de compilação. Um exemplo é um arquivo texto que contém documentação, como por exemplo um arquivo leiame.

• Compile. O arquivo é compilado para a saída de compilação. Essa configuração é utilizada para arquivos de código.

• Content. O arquivo não é compilado, mas é incluído no grupo de saída de conteúdo. Por exemplo, essa configuração é o valor padrão para um arquivo .htm ou outro tipo de arquivo da Web.

• Embedded Resource. Este arquivo é incorporado à saída de compilação do projeto principal como uma DLL ou executável. Ele é normalmente usado para arquivos de recurso.

O valor padrão para BuildAction depende da extensão do arquivo que você adicionar à solução. Por exemplo, se você adicionar um projeto do Visual Basic ao

Visual Studio 303

Solution Explorer, o valor padrão para BuildAction é Compile, porque a extensão .vb indica um arquivo de código que pode ser compilado. Nomes e extensões de arquivos aparecem no Solution Explorer.

Observe que o nome do arquivo no seu projeto não será o identificador para o recurso gerenciado no manifesto do assembly (consulte Manifesto do assembly para obter mais informações). O identificador será namespace.nomearquivo.extensão, onde namespace é o valor da propriedade DefaultNamespace em um projeto do Visual C# ou da propriedade RootNamespace em um projeto do Visual Basic. Nomearquivo e extensão permanecem os mesmos que suas designações originais. Se o arquivo for um arquivo .resx, o sistema do projeto executará resgen.exe no arquivo, criando um arquivo .resource. O arquivo .resource será incorporado ao assembly, portanto o manifesto do assembly fará referência ao arquivo .resources e não ao arquivo .resx.

Por exemplo, se você adicionar o arquivo MeuArquivo.bmp a um projeto cujo namespace padrão é MeuProjeto, e definir a ação de compilação como Embedded Resource, MeuProjeto.MeuArquivo.bmp será o identificador no manifesto do assembly. Se você depois adicionar o arquivo MeuArquivo.resx ao projeto, a ação de compilação padrão será Embedded Resource, e MeuProjeto.MeuArquivo.resources será o identificador no manifesto do assembly.

Observe que, quando o editor de recursos adiciona uma imagem, ele configura Build Action como None, porque o arquivo .resx referencia o arquivo de imagem. Em tempo de compilação, a imagem é colocada no arquivo .resources criado a partir do arquivo .resx. A imagem pode depois ser facilmente acessada através da classe fortemente tipada auto-gerada para o arquivo .resx. Portanto, você não deve alterar esta configuração para Embedded Resource, porque fazer isso deverá incluir a imagem duas vezes no assembly.

Para obter mais informações sobre como acessar arquivos de recurso (compilados a partir de arquivos .resx) em tempo de execução, consulte Classe ResourceManager. Para obter mais informações sobre como acessar todos os outros arquivos incorporados e recursos em tempo de execução, consulte Método Assembly.GetManifestResourceStream.

Propriedade CopyToOutputDirectory Esta propriedade especifica as condições sob as quais o arquivo de origem selecionado será copiado para a pasta de saída. Selecione Do not copy se o arquivo não deve ser nunca copiado para o diretório de saída; Copy always se o arquivo deve ser sempre copiado para o diretótio de saída; ou Copy if newer se o arquivo deve ser copiado somente quando ele for mais recente que um arquivo existente com o mesmo nome no diretório de saída.

Observação

Em projetos de dispositivo inteligente, a renovação de um arquivo .dll ou .exe é determinada comparando as versões Win32 da seguinte maneira:

Se a versão do lado do dispositivo for menor do que a da área de trabalho, o arquivo é copiado.

Se a versão do lado do dispositivo for maior do que a da área de trabalho, o arquivo não é copiado.

Se as versões forem iguais, uma comparação de soma de verificação é feita. Se as somas de verificação forem iguais, o arquivo não é copiado. Se as somas de verificação forem diferentes, o arquivo é copiado.

A renovação dos arquivos diferentes de .dll e .exe é baseada somente em soma de verificação.

Visual Studio 304

Propriedade CustomTool Ferramentas personalizadas são componentes que podem ser usados para transformar arquivos de um tipo em outro em tempo de design. Por exemplo, uma ferramenta personalizada pode ser um gerador de código de DataSet que lê um arquivo de esquema XML (.xsd) como entrada, e gera classes em um arquivo de código que programaticamente expõem suas tabelas e colunas. Existe uma lista pré-definida de ferramentas personalizadas disponíveis no produto; esta propriedade permite que você veja qual ferramenta personalizada é aplicada a um arquivo. Em raras circunstâncias, pode ser necessário que você altere o valor dessa propriedade. O valor desta propriedade deve estar em branco ou ser uma das ferramentas personalizadas internas.

Para definir ou alterar a ferramenta personalizada, clique na propriedade Propriedade CustomTool (Visual Basic e C# ProjectItem Object) na janela de propriedades e digite o nome de uma ferramenta personalizada.

Propriedade CustomToolNamespace Se você tiver uma ferramenta personalizada atribuída ao seu projeto, a propriedade Propriedade CustomToolNamespace (Visual Basic e C# ProjectItem Object) permite que você especifique o namespace que você deseja atribuir ao código gerado pela ferramenta personalizada. Quando você especificar um valor para a propriedade CustomToolNamespace, o código gerado pela ferramenta será colocado no namespace especificado. Se a propriedade estiver vazia, código gerado será colocado no namespace padrão para a pasta na qual o arquivo convertido reside; para o Visual Basic, este é o namespace raiz do projeto, e para o Visual C# isso corresponde à configuração da propriedade Propriedade DefaultNamespace (Visual Basic e C# Project Object) para a pasta.

Tipos de arquivos e extensões de arquivos no Visual Basic, Visual C#, e Visual J#

Itens de projeto referem-se aos tipos de arquivos que você adiciona a um projeto. Os itens de projeto, disponíveis para você, diferenciam-se dependendo se você estiver trabalhando em um projeto local ou em um projeto da Web. Para obter mais informações, consulte Projetos locais e da Web e Tour guiado de como se criar sites da Web no Visual Studio.

Adicionando itens de projeto A caixa diálogo Add New Item é acessada através do menu Project. Para obter mais informações sobre como adicionar itens ao seu projeto, consulte COMO: Adicionar novos itens de projeto.

As seguintes tabelas listam os itens de projeto disponíveis para projetos locais e projetos da Web. Observe que para alguns itens de projeto, a extensão de arquivo é diferente, dependendo se o item aparece em um projeto Visual Basic (indicado por .vb), em um projeto Visual C# (indicado por .cs), ou em um projeto Visual J# (indicado por .jsl). Para outros itens de projeto, a extensão de arquivo não faz distinção entre um projeto Visual Basic, um projeto Visual C#, e um projeto Visual J#; isto é, há apenas uma extensão possível para o item de projeto.

Visual Studio 305

Itens de projeto locais

Item de projeto Extensão de arquivo Finalidade do item de projeto

Windows Form .vb ou .cs ou .jsl ou .java

Um formulário para criar aplicativos baseados no Windows.

Explorer Form .vb ou .cs ou .jsl ou .java

Um formulário do Explorer com modo de exibição de árvore e controles de navegação.

MDI Parent Form .vb ou .cs ou .jsl ou .java

Um formulário para um aplicativo de interface de documentos múltiplos.

About Box .vb ou .cs ou .jsl ou .java

Um formulário de caixa de diálogo About para aplicativos baseados no Windows

Login Form .vb ou .cs ou .jsl ou .java

Um formulário de logon para coletar um nome de usuário e senha.

Splash Screen .vb ou .cs ou .jsl ou .java

Um formulário pré-configurado para ser usado como tela inicial.

Dialog .vb ou .cs ou .jsl ou .java

Um diálogo para aplicativos baseados no Windows.

Class .vb ou .cs ou .jsl ou .java

Um arquivo de código que contém uma declaração de classe. Para mais informações, consulte Classes no Common Type System.

Interface .vb ou .cs ou .jsl ou .java

Uma nova interface.

Module (Visual Basic somente)

.vb Um arquivo para armazenar grupos de funções.

Component Class .vb ou .cs ou .jsl ou .java

Uma classe para criar componentes usando o visual designer. Para mais informações, consulte Classes de componente.

User Control .vb ou .cs ou .jsl ou .java

Uma classe para criar um controle de Windows Form usando o visual designer.

Windows Service .vb ou .cs ou .jsl ou .java

Uma classe para criar serviços do Windows. Para mais informações, consulte COMO: Criar serviços do Windows.

DataSet .xsd Um arquivo para criar um esquema XML com classes DataSet. Para mais informações, consulte Gravando informações de esquema de DataSet como esquema XML (XSD).

Visual Studio 306

SQL Database .mdf Um banco de dados SQL vazio para dados locais.

XML File .xml Um arquivo XML em branco. Para mais informações, consulte Designer de esquema XML (XML Designer).

XML Schema .xsd Um arquivo para criar um esquema de documentos XML. Para mais informações, consulte Introdução a esquemas XML (XML Designer).

Settings File .settings Um arquivo de configurações do usuário em branco.

Code File .vb ou .cs ou .jsl ou .java

Um arquivo de código em branco.

Custom Control .vb ou .cs ou .jsl ou .java

Uma classe para criar um controle de Windows Forms de usuário. Para mais informações, consulte COMO: Autorar controles para Windows Forms.

HTML Page .htm Uma página HTML que pode incluir código do lado do cliente. Para mais informações, consulte Modo de exibição Design.

Inherited Form .vb ou .cs ou .jsl ou .java

Um novo formulário baseado em um formulário existente. Para mais informações, consulte Herança visual do Windows Forms.

Inherited User Control

.vb ou .cs ou

.jsl ou .java Um novo controle baseado em um controle Windows Forms existente. Para mais informações, consulte COMO: Herdar de controles Windows Forms existentes.

Web Custom Control

.vb ou .cs ou

.jsl ou .java Uma classe para criar um controle de servidor ASP.NET. Para mais informações, consulte Controles de servidor da Web do ASP.NET (Visual Studio).

COM Class .vb ou .cs Uma classe que pode ser exposta ao COM. Para mais informações, consulte Interoperabilidade COM em aplicativos do .NET Framework.

Transactional Component

.vb ou .cs Uma classe para uso com componentes transacionais.

Arquivo de texto .txt Um arquivo de texto vazio.

XSLT File .xslt Um arquivo usado para transformar documentos XML.

Installer Class .vb ou .cs ou .jsl ou .java

Uma classe para ser chamada no momento da instalação. Para mais informações, consulte Usando componentes de instalação.

Visual Studio 307

Crystal Report .rpt Um arquivo Crystal Report que publica dados para um Windows form.

Bitmap File .bmp Um arquivo de imagem de bitmap em branco que pode ser usado para criar imagens simples.

Cursor File .cur Um arquivo para criar cursores personalizados. Para mais informações, consulte Criação de cursores.

Icon File .ico Um arquivo de imagem para criar um ícone personalizado. Para mais informações, consulte Ícones.

Resources File .resx Um arquivo usado para editar e definir recursos de aplicativo. Para mais informações, consulte Recursos em aplicativos.

Assembly Information File

.vb ou .cs ou

.jsl Um arquivo contendo informações de assembly gerais. Para mais informações, consulte Assemblies na Common Language Runtime.

Application Configuration File

.config Um arquivo usado para definir configurações de aplicativo. Para mais informações, consulte Arquivos de configuração.

Debugger Visualizer

.vb ou .cs ou

.jsl ou .java Um simples visualizador depurador

Class Diagram .cd Um diagrama de classe.

Report .rdlc Um novo relatório vazio.

JScript File .js Um arquivo de script que contém código JScript. Para mais informações, consulte Guia de Introdução do JScript.

VBScript File .vbs Um arquivo de script que contém código VBScript. Para mais informações, consulte Guia do Usuário do VBScript.

Windows Script Host

.wsf Um arquivo contendo script que é executado como um programa do Windows. Para mais informações, consulte Usando arquivos de script do Windows (.wsf).

Itens de projeto da Web

Item de projeto Extensão de arquivo Finalidade do item de projeto

Web Form Dois arquivos: .aspx, e .vb para Visual Basic ou .cs para Visual C# ou .jsl

Um formulário para criar aplicativos da Web.

Visual Studio 308

para Visual J#

Master Page .master Uma página mestre para aplicativos da Web.

Web User Control

.ascx Um controle de servidor do ASP.NET criado usando o visual designer.

HTML Page .htm Uma página HTML que pode incluir código do lado do cliente. Para mais informações, consulte Modo de exibição Design.

Web Service Dois arquivos: .asmx, e .vb para Visual Basic ou .cs para Visual C# ou .jsl para Visual J#

Um componente que fornece a capacidade de trocar mensagens interoperáveis usando protocolos padrões, tais como HTTP, XML, XSD, SOAP e WSDL. Para mais informações, consulte Criando XML Web services em código gerenciado.

Class .vb ou .cs ou .jsl Um arquivo de código que contém uma declaração de classe.

Style Sheet .css Uma folha de estilo em cascata usada para definições de estilo HTML. Para mais informações, consulte COMO: Criar folhas de estilo em cascata externas (Visual Studio).

Global Application Class

.asax Às vezes chamado de arquivo asax, esse arquivo permite que você escreva código para manipular eventos globais a nível de aplicativo do ASP.NET, tais como Session_OnStart e Application_OnStart. O nome do arquivo é global.asax, o qual você não pode alterar.

Web Configuration File

.config O ASP.NET usa este arquivo para definir as configurações da Web para um projeto da Web. O nome do arquivo é Web.config, o qual você não pode alterar.

XML File .xml Um arquivo XML em branco. Para mais informações, consulte Designer de esquema XML (XML Designer).

XML Schema .xsd Um arquivo para criar um esquema de documentos XML. Para mais informações, consulte Introdução a esquemas XML (XML Designer).

XSLT File .xslt Um arquivo usado para transformar documentos XML.

Text File .txt Um arquivo de texto vazio.

Assembly Resource File

.resx Um arquivo usado para editar e definir recursos de aplicativo. Para mais informações, consulte Recursos em aplicativos.

Assembly .vb ou .cs ou .jsl Um arquivo contendo informações de assembly gerais. Para mais informações, consulte Assemblies na Common Language

Visual Studio 309

Information File Runtime.

SQL Database .mdf Um banco de dados SQL vazio para dados locais.

DataSet .xsd Um arquivo para criar um esquema XML com classes DataSet. Para mais informações, consulte Gravando informações de esquema de DataSet como esquema XML (XSD).

Generic Handler

.ashx Uma página para implementar um manipulador genérico

Site Map .sitemap Um arquivo usado para criar um mapa do site.

Mobile Web Form

.aspx Um formulário para criar aplicativos da Web móveis. Para mais informações, consulte Criando aplicativos da Web do ASP.NET para dispositivos móveis.

Mobile Web User Control

.ascx Um controle de servidor ASP.NET criado usando o visual designer e usado em um aplicativo da Web para dispositivos móveis. Para mais informações, consulte Criando aplicativos da Web do ASP.NET para dispositivos móveis.

Mobile Web Configuration File

.config O ASP.NET usa este arquivo para definir as configurações de um projeto da Web para dispositivos móveis. O nome do arquivo é Web.config, o qual você não pode alterar. Para mais informações, consulte Criando aplicativos da Web do ASP.NET para dispositivos móveis.

Crystal Report .rpt Um arquivo Crystal Report que publica dados para um Web Form.

VBScript File .vbs Um arquivo de script que contém código VBScript. Para mais informações, consulte Guia do usuário do VBScript.

JScript File .js Um arquivo de script que contém código JScript. Para mais informações, consulte Guia de Introdução do JScript.

Windows Script Host

.wsf Um arquivo de código vazio usado para scripts do Windows. Para mais informações, consulte Introdução a aplicativos de serviço do Windows.

Skin File .skin Um arquivo usado para definir um tema do ASP.NET.

Browser File .browser Um arquivo para configurar definições de navegador

Report .rdlc Um novo relatório vazio.

Visual Studio 310

Module (Visual Basic somente)

.vb Um arquivo para armazenar grupos de funções.

Component Class

.vb ou .cs Uma classe para criar componentes usando o visual designer.

Data Form Wizard

.aspx (.vb ou .cs para projetos locais)

Um formulário de dados para aplicativos da Web.

Frameset .htm Um arquivo HTML que hospeda múltiplas páginas HTML. Para mais informações, consulte Introdução a conjuntos de quadros.

Web Custom Control

.vb ou .cs ou .jsl Uma classe para criar um controle de servidor do ASP.NET. Para mais informações, consulte Controles de servidor da Web do ASP.NET (Visual Studio).

Code File .vb ou .cs ou .jsl Um arquivo de código em branco.

Static Discovery File

.disco Um arquivo opcional que atua como um mecanismo de descoberta para o XML Web service. O arquivo .disco não é criado automaticamente para um XML Web service. Para informações como criar um arquivo de descoberta para seu XML Web service, consulte COMO: Ativar descoberta para XML Web services.

Installer Class .vb ou .cs ou .jsl Uma classe para ser chamada no momento da instalação. Para mais informações, consulte Usando componentes de instalação.

Bitmap File .bmp Um arquivo de imagem de bitmap em branco que pode ser usado para criar imagens simples.

Cursor File .cur Um arquivo para criar cursores personalizados. Para mais informações, consulte Criação de cursores.

Icon File .ico Um arquivo de imagem para criar um ícone personalizado. Para mais informações, consulte Ícones.

Modelos de projeto padrão no Visual Studio Quando você criar um novo projeto, ícones nas caixas de diálogo New Project e Add Project representam os tipos de projeto disponíveis e seus modelos. O modelo de projeto que está associado ao ícone de projeto de sua escolha determina o tipo de saída e outras opções disponíveis para o projeto.

A tabela a seguir lista os tipos padrão de projetos disponíveis no Visual Studio.

Modelo de Usado para criar

Visual Studio 311

projeto

Modelo Biblioteca de classe

Classes reutilizáveis ou componentes que podem ser compartilhados com outros projetos. Esse tipo de projeto é considerado sem janelas e não conterá uma classe de formulários Windows. Para mais informações, consulte Classes de componentes.

Modelo de Aplicação de console

Aplicativo de linha de comando.

Modelo do Projeto vazio

Um projeto vazio. O modelo cria a estrutura de arquivo necessário para armazenar informações de aplicativo; quaisquer referências, arquivos, ou componentes devem ser adicionados manualmente.

Modelo de Biblioteca de controle da Web

Controle personalizado que pode ser usado em páginas de formuláiros Web.

Observação Visual Basic

Esse tipo de projeto é parecido com o projeto ActiveX Control no Visual Basic 6.0.

Modelo de aplicativos do Windows

Aplicativo Windows autônomos tradicional ou um rico front-end para aplicativo Web distribuído. Para mais informações, consulte Criando aplicativos Windows.

Observação Visual Basic

Isso substitui o modelo de projeto Standard EXE no Visual Basic 6.0.

Modelo de Biblioteca de controle do Windows

Controle personalizado para usar em formulários Windows. Para mais informações, consulte Controle de criação de formulários do Windows.

Modelo de serviço do Windows

Interface de aplicativos que executam por muito tempo e não têm uma interface de usuário. Windows Service Applications (anteriormente chamadas " NT services") podem monitorar itens como o desempenho do sistema. Para mais informações, consulte Introdução aos aplicativos de serviço do Windows.

COMO: Restauração de modelos de projeto padrão Se você acidentalmente excluir os modelos de projeto padrão que são incluídos com o Visual Studio, você pode usar este procedimento para restaurá-los sem reinstalar o Visual Studio.

Visual Studio 312

Para restaurar os modelos de projeto padrão 1. Na linha de comando, navegue para a localidade onde está o devenv.exe.

Este arquivo está localizado em <Visual Studio Installation Path>\Common7\IDE.

2. Digite "devenv /installvstemplates" e pressione ENTER.

Observação

Se você estiver usando um Visual Studio Express Edition, digite "<ExpressName>Express /installvstemplates", onde <ExpressName> é VJS, VB ou VCS para Visual J#, Visual Basic e Visual C#, respectivamente.

3. Se esse procedimento não restaurar os modelos padrão, reinstale o Visual Studio.

Modelo Class Library Você pode usar o modelo Class Library para criar rapidamente, classes e componentes reutilizáveis que podem ser compartilhados com outros projetos. Para obter mais informações sobre como criar classes de componentes, consulte Component Classes.

O modelo adiciona automaticamente arquivos e referências ao projeto essencial.

Modelo de aplicativo de console O modelo de projeto Console Application adiciona os itens necessários para criar um aplicativo de console. Aplicativos de console são normalmente criados sem uma interface gráfica do usuário e são compilados em um arquivo executável autônomo. Um aplicativo de console é executado a partir da linha de comando com informações de entrada e saída sendo trocadas entre o prompt de comando e o aplicativo em execução. As informações podem ser escritas e lidas da janela do console, tornando o aplicativo de console uma excelente maneira para se aprender novas técnicas de programação sem precisar se preocupar com a interface do usuário.

O modelo adiciona automaticamente as referências de projeto essenciais e arquivos para serem usados como um ponto de partida para o seu aplicativo.

Modelo Empty Project O modelo Empty Project pode ser usado quando você desejar criar seu próprio tipo de projeto. O modelo cria a estrutura de arquivos necessária para armazenar as informações do aplicativo. As referências, arquivos ou componentes devem ser adicionados manualmente. Para obter mais informações sobre como adicionar referências, consulte Adicionando e removendo referências.

Visual Studio 313

Modelo de biblioteca de controles da Web Você pode usar o modelo de projeto Web Control Library para criar controles de servidor Web personalizados. O modelo adiciona os itens de projeto necessários para começar a criar um controle que pode ser adicionado a qualquer projeto da Web. Para mais informações, consulte Visão geral de controles de servidor Web do ASP.NET.

O modelo adiciona automaticamente as referências de projeto essenciais e arquivos para serem usados como um ponto de partida para seu aplicativo.

Modelo de Aplicativo Windows O modelo de projeto do Aplicativo Windows em Visual Basic, Visual C# e Visual J# representa a base para um aplicativo Windows padrão. Para obter mais informações sobre como criar um aplicativo Windows, consulte Criando um Projeto de Aplicativo Windows.

O modelo adiciona automaticamente as referências e arquivos essenciais do projeto para usar como ponto de partida para o seu aplicativo.

Modelo de Controle de Biblioteca do Windows O modelo do projeto de controle de Biblioteca do Windows é usado para criar controles personalizados para usar em formulários Windows. Para mais informações, consulte Controles de formulários do Windows.

O modelo automaticamente adiciona as referências essenciais e arquivos do projeto para usar como um ponto de partida para seu aplicativo.

Modelo de Serviço do Windows O modelo de serviço do Windows adiciona os itens necessários para criar um aplicativo de serviço do Windows, um aplicativo executável demorado que é executa em sua própria sessão do Windows. Para mais informações, consulte Introdução aos aplicativos de serviço do Windows.

O modelo adiciona automaticamente as referências e arquivos essenciais para o projeto usar como um ponto de partida para seu aplicativo.

Referenciando Namespaces e Componentes Referências de projeto são usadas para acessar as propriedades, os métodos e os eventos de um objeto definido e aplicá-los em seu programa. Os tópicos a seguir contêm uma visão geral das referências no Visual Basic e Visual C# e fornecem instruções sobre como adicionar, remover e gerenciar as referências existentes.

Visual Studio 314

Referências de projeto Para escrever código contra um componente externo, seu projeto deve primeiramente conter uma referência a ele. Uma referência pode ser feita aos seguintes tipos de componentes:

• Bibliotecas de classes do .NET Framework ou assemblies

• Componentes COM

• Outras bibliotecas de classes de projetos na mesma solução

• XML Web Services

Para obter mais informações sobre referências de XML Web Services, consulte Referências da Web.

Observação do Visual Basic

Referências de projeto são gerenciadas de modo diferente no Visual Studio do que como eram no Visual Basic 6.0. Para mais informações, consulte Gerenciamento de projeto para usuários do Visual Basic 6.0.

Referências a componentes compartilhados Em tempo de execução, componentes devem estar em um dos dois locais: no caminho de saída do projeto ou no cache global de assemblies (GAC). Se o projeto contiver uma referência a um objeto que não esteja em um desses locais, a referência deve ser copiada para o caminho de saída do projeto quando o projeto é criado. A propriedade CopyLocal indica se esta cópia precisa ser feita. Se o valor for true, a referência é copiada. Se false, a referência não é copiada.

Se você implantar um aplicativo que contém uma referência a um componente personalizado que está registrado no GAC, o componente não será implantado com o aplicativo, independentemente da configuração CopyLocal. Em versões anteriores do Visual Studio, você poderia definir a propriedade CopyLocal em uma referência para garantir que o assembly fosse implantado. Agora, você deve adicionar manualmente o assembly à pasta \Bin. Isso coloca todo código personalizado sob exame detalhado, reduzindo o risco de publicar código personalizado com o qual você não está familiarizado.

Por padrão, a propriedade CopyLocal está definida como false se o assembly ou componente está no cache global de assemblies ou é um componente de estrutura. Caso contrário, o valor é definido como true. Referências de projeto-a-projeto são sempre definidas como true.

Referências de projeto-a-projeto Em uma solução com vários projetos, você pode criar referências a objetos criados em outro projeto que reside na mesma solução. Isso cria uma interdependência que requer uma consideração especial ao criar e executar o aplicativo. Para mais informações, consulte Como: preparar e gerenciar Builds.

Solucionando problemas de referências quebradas Se seu aplicativo tentar usar uma referência quebrada, um erro de exceção é gerado. A incapacidade de localizar o componente referenciado é o disparador

Visual Studio 315

primário do erro, mas existem várias situações em que uma referência pode ser considerada quebrada. Essas instâncias são mostradas na lista a seguir:

• O caminho de referência do projeto está incorreto ou incompleto.

• O arquivo sendo referenciado foi excluído.

• O arquivo sendo referenciado foi renomeado.

• A conexão de rede ou a autenticação falhou.

• A referência é a um componente COM que não está instalado no computador.

A seguir estão soluções para esses problemas.

Observação

Arquivos em assemblies são referenciados com caminhos absolutos no arquivo de projeto. Devido a isso, é possível que usuários trabalhando em um ambiente com vários desenvolvedores sintam a falta de um assembly referenciado no seu ambiente local. Para evitar esses erros, é melhor nesses casos adicionar referências de projeto-a-projeto. Para obter mais informações, consulte Como: adicionar ou remover referências no Visual Studio e Programando com assemblies.

Caminho de referência está incorreto

Se projetos são compartilhados em computadores diferentes, algumas referências podem não ser encontradas quando um componente está localizado em um diretório diferente em cada computador. Referências são armazenadas sob o nome do arquivo de componente (por exemplo, MeuComponente). Quando uma referência é adicionada a um projeto, o local da pasta do arquivo de componente (por exemplo, C:\MeusComponentes\) será acrescentado à propriedade de projeto ReferencePath.

Quando o projeto é aberto, ele tenta localizar esses arquivos de componentes referenciados procurando nos diretórios no caminho de referência. Se o projeto for aberto em um computador que armazena o componente em um diretório diferente, como D:\MeusComponentes\, a referência não poderá ser encontrada e um erro aparecerá na Lista de Tarefas.

Para corrigir este problema, você pode excluir a referência quebrada e substituí-la usando a caixa de diálogo Add Reference. Uma outra solução é usar o item Reference Path em páginas de propriedades do projeto e modificar as pastas na lista para apontar para os locais correto. A propriedade ReferencePath é mantida para cada usuário em cada computador, assim modificar o seu caminho de referência não afeta outros usuários do projeto.

Dica

Referências de projeto-a-projeto não têm esses problemas. Por esse motivo, use-as em vez de referências de arquivo, se possível.

Para consertar uma referência de projeto quebrada corrigindo o caminho de referência

1. No Solution Explorer, clique com o botão direito do mouse no nó do seu projeto e clique em Properties.

2. O Project Designer aparecerá.

Visual Studio 316

3. Se você estiver usando o Visual Basic, selecione a página References e clique no botão Reference Paths. Na caixa de diálogo Reference Paths, digite o caminho da pasta que contém o item que você deseja referenciar no campo Folder, depois clique no botão Add Folder.

Se você estiver usando o Visual C#, selecione a página Reference Paths. No campo Folder, digite o caminho da pasta que contém o item que você deseja referênciar, e depois clique no botão Add Folder.

Arquivo referenciado foi excluído

É possível que o arquivo sendo referenciado tenha sido excluído e não exista mais na unidade.

Para corrigir uma referência de projeto quebrada a um arquivo que não existe mais no seu disco • Excluir a referência.

• Se a referência existir em outro local no seu computador, leia-a deste local.

• Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Arquivo referenciado foi renomeado

É possível que o arquivo referenciado tenha sido renomeado.

Para corrigir uma referência quebrada a um arquivo que foi renomeado • Exclua a referência, e depois adicione uma referência ao arquivo renomeado.

• Se a referência existir em outra local no seu computador, você precisa lê-lo daquele local. Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Conexão de rede ou autenticação falhou

Pode haver várias causas possíveis para arquivos inacessíveis: uma conexão de rede ou uma autenticação que falhou, por exemplo. Cada causa pode ter meios exclusivos de recuperação; por exemplo, você pode precisar entrar em contato com o seu administrador local para obter acesso aos recursos necessários. No entanto, excluir a referência e corrigir o código que a usa é sempre uma opção. Para mais informações, consulte Como: adicionar ou remover referências no Visual Studio.

Componente COM não está instalado no computador

Se um usuário tiver adicionado uma referência a um componente COM e um segundo usuário tentar executar o código em um computador que não tenha este componente instalado, o segundo usuário receberá um erro de que a referência está quebrada. Instalar o componente no segundo computador irá corrigir o erro. Para obter mais informações sobre como usar referências a componentes COM em seus projetos, consulte Interoperabilidade COM em aplicativos .NET Framework.

Convenções de nomenclatura para arquivo de recurso Esta seção descreve as convenções de nomeação para recursos manifesto de assembly em projetos do Visual Basic e Visual C#.

Visual Studio 317

Recursos XML Um arquivo de recursos XML é um arquivo cuja extensão é .resx e cuja propriedade BuildAction está definida como Embedded Resource. Esses arquivos XML devem seguir um esquema específico compreendido pela ferramenta de conversão ResXToResources. Com esta ferramenta, arquivos de recursos XML são transformados em BLOBs antes da inclusão no manifesto do assembly.

A seguir, a convenção de nomeação de arquivo para esses recursos:

nomearquivo_base[.string info cultura opcional RFC 1766].resx

Além das limitações do sistema de arquivos, não há restrições sobre base_filename ou a string info cultura opcional RFC 1766. Exemplos de nomes de arquivo de recursos XML válidos incluem:

• MyResource.resx

• MyResource.de-de.resx

• My.Resource.File.resx

Recursos não-XML Um arquivo de recursos não-XML é qualquer arquivo cuja propriedade BuildAction é EmbeddedResource e cuja extensão é algo diferente de .resx. Todos esses arquivos de recursos seguem a mesma convenção de nome, independentemente se eles são arquivos dependentes.

A nomeação para esses arquivos é a seguinte:

base_filename+[.optional RFC 1766 culture info string].extension

Além das limitações do sistema de arquivos, não existem restrições em base_filename, optional RFC 1766 culture info string, ou extension.

Configurando aplicativos usando propriedades dinâmicas

Observação

A interface de usuário para propriedades dinâmicas foi removida do Visual Studio 2005. As propriedades dinâmicas no entanto, ainda são suportadas. Se você importar um projeto de uma versão anterior do Visual Studio, as configurações de propriedades dinâmicas serão preservadas no código e funcionarão em tempo de execução. É recomendável que você em vez disso use o Project Designer para especificar configurações de aplicativo. Para obter mais informações, consulte Página de configurações, designer de projeto e Gerenciando definições de aplicativo.

Com propriedades dinâmicas você pode armazenar alguns dos valores de propriedade do aplicativo em um arquivo externo e carregá-los quando o aplicativo é executado. Isso permite a você fazer alterações nos valores de propriedade sem recompilar o aplicativo, após o projeto ter sido implantado.

Introdução a propriedades dinâmicas (Visual Studio)

Observação

Visual Studio 318

A interface do usuário para propriedades dinâmicas foi removida do Visual Studio 2005. Porém propriedades dinâmicas ainda recebem suporte. Se você importar um projeto de uma versão anterior do Visual Studio, as configurações de propriedades dinâmicas serão preservadas no código e irão funcionar em tempo de execução. É recomendável que você em vez disso use o Project Designer para especificar configurações de aplicativo. Para obter mais informações, consulte Página de configurações, Project Designer e Gerenciando configurações de aplicativo.

Propriedades dinâmicas permitem que você configure seu aplicativo de maneira que alguns ou todos os seus valores de propriedades sejam armazenados em um arquivo de configuração externo em vez de ser armazenados no código compilado do aplicativo. Ao fornecer aos administradores os meios para atualizar valores de propriedades que podem precisar ser alterados ao longo do tempo, isto pode reduzir o custo total de se manter um aplicativo após ele ter sido implantado. Por exemplo, suponha que você esteja criando um aplicativo que usa um banco de dados de teste durante o processo de desenvolvimento, e você precise alterná-lo para um banco de dados de produção ao implantá-lo. Se você armazenar os valores de propriedades dentro do aplicativo, você tem que alterar todas as configurações de banco de dados manualmente antes de implantar, e depois recompilar o código fonte. Se você armazenar esses valores externamente, você pode fazer uma única alteração no arquivo externo e o aplicativo irá pegar os novos valores na próxima vez em que ele for executado.


Valores de propriedades armazenados em um arquivo de configuração não são seguros. Dados confidenciais como senhas e informações de cartão de crédito não devem ser armazenados como propriedades dinâmicas.

Você pode usar propriedades dinâmicas em qualquer aplicativo que seja compilado em um arquivo .exe. Projetos que compilam uma DLL não podem usar propriedades dinâmicas diretamente; entretanto propriedades de DLL podem ser definidas dinamicamente pelo .exe que está referenciando o arquivo .dll. Embora as propriedades de qualquer componente, formulário ou controle nestes aplicativos possam ser tratadas dinamicamente, algumas propriedades são melhores candidatas a propriedade dinâmica que outras. Freqüêntemente, você irá armazenar e recuperar propriedades que se conectam a recursos externos que podem se alterar, incluindo bancos de dados, logs de eventos, ou contadores de desempenho. Muitas dessas propriedades são identificadas como candidatas padrão a propriedade dinâmica.

Observação

O código de exemplo neste tópico depende da existência de um objeto SqlConnection e um arquivo de configuração; ele causará erros de compilação sem eles. Para obter mais informações como criar um arquivo de configuração, consulte Explicação passo a passo: armazenando e recuperando propriedades dinâmicas.

Propriedades dinâmicas e arquivos de configuração Ao definir uma propriedade como configurável, o seu valor é gravado em um arquivo de configuração e código é inserido na classe para indicar que o valor da propriedade deve ser recuperado a partir deste recurso externo. O arquivo de

Visual Studio 319

configuração varia de acordo com o tipo de aplicativo; aplicativos baseados na Web usam o arquivo Web.config, e aplicativos baseados no Windows usam um arquivo semelhante com extensão .config. Todos os formulários e componentes em um aplicativo usam um único arquivo de configuração. Você não pode alternar para um arquivo de configuração diferente ou usar vários arquivos dentro de um único aplicativo.

Dentro do arquivo de configuração, as propriedades são mantidas usando XML. Por exemplo, suponha que você indicou que a propriedade ConnectionString para uma conexão de dados deve ser armazenada no arquivo de configuração. Você poderá ver este código no editor de código, indicando que o valor é armazenado externamente:

C# this.sqlConnection1.ConnectionString =

System.Configuration.ConfigurationManager.

AppSettings.Get("SqlConnection1.ConnectionString");


Para obter mais informações sobre como criar conexões de dados seguras, consulte Tornando seguras seqüências de conexão.

No arquivo de configuração, o valor dessa propriedade seria armazenado via XML, usando a chave indicada no código do formulário: <configuration> <appSettings> <add key="sqlConnection1.ConnectionString" value="data source=myserver;initial catalog=Apps;Integrated Security=SSPI;packet size=4096" /> </appSettings> </configuration> Para cada valor no arquivo de configuração é atribuída uma chave que é usada para armazenar e recuperar o valor. A parte inicial da chave indica o componente do qual originou-se o valor. Por exemplo, essas duas chaves indicam uma propriedade ConnectionString de duas conexões de dados dentro de um único aplicativo: <configuration> <appSettings> <add key="sqlConnection1.ConnectionString" value="data source=myserver;initial catalog=Apps;Integrated Security=SSPI;packet size=4096" /> <add key="sqlConnection2.ConnectionString" value="data source=myserver;initial catalog=Apps;Integrated Security=SSPI;packet size=4096" /> </appSettings> </configuration> Você pode modificar o arquivo de configuração diretamente de maneira a atualizar dinamicamente os valores de propriedades em seu aplicativo. Na próxima vez em que o aplicativo for iniciado, ele irá atualizar os valores.

De uma certa maneira, arquivos de configuração são semelhantes a arquivos de recurso; ambos são usados para armazenar valores fora do aplicativo compilado e ambos usam XML para armazenar suas informações. No entanto, arquivos de

Visual Studio 320

recurso servem para uma finalidade totalmente diferente do que arquivos de configuração. Arquivos de recurso são usados para armazenar seqüências e outros recursos localizáveis para fins de tradução, enquanto arquivos de configuração (no caso de propriedades dinâmicas) são usados para atualizar valores de propriedades. Os valores em um arquivo de recurso são destinados a serem traduzidos, mas tipicamente não são alterados, enquanto valores de propriedades dinâmicas em um arquivo de configuração podem ser alterados conforme necessário. Além disso, você pode associar vários arquivos de recurso a um projeto, mas você só pode ter um único arquivo de configuração para o aplicativo. Para obter mais informações sobre arquivos de recurso, consulte Organização hierárquica de recursos para localização.

Definindo propriedades múltiplas para a mesma chave Propriedades múltiplas podem referenciar o mesmo par chave-valor em um arquivo de configuração. Por exemplo, se você tiver três componentes em sua classe que acessem o mesmo banco de dados, você pode armazenar a propriedade ConnectionString para cada um no mesmo par chave-valor. Isso significa que se o banco de dados for alterado, você pode atualizar um único valor no arquivo de configuração para aplicar a alteração a todos os três componentes. Você faria isso definindo cada uma das propriedades como a mesma chave, assim:

C# this.sqlConnection1.ConnectionString =



this.sqlConnection2.ConnectionString =



this.sqlConnection3.ConnectionString =



Observe que, enquanto os componentes em uso diferem, todos eles referem-se à chave para sqlConnection1.ConnectionString.

Quando você escolhe a mesma chave para propriedades múltiplas, somente uma entrada é feita no arquivo de configuração. O valor inicial armazenado é o mesmo da primeira propriedade para a qual foi fornecida essa chave.

Tipos de dados e propriedades dinâmicas XML armazena tudo como uma seqüência de caracteres. Se o valor da propriedade que você está armazenando não é uma seqüência de caracteres, você irá ver informações adicionais no editor de código para indicar o tipo de dado para o valor da propriedade. Por exemplo, suponha que você esteja armazenando dinamicamente o valor das propriedades Interval e Enabled de um componente Timer. No arquivo de configuração, essa propriedade seria armazenada assim: <appSettings> <add key=timer1.Interval" value="100" /> <add key=timer1.Enabled" value="True" /> </appSettings> No editor de código, você deverá ver este código para indicar que o valor recuperado precisa ser alterado para um Tipo de dados Double (Visual Basic):

C#

Visual Studio 321

this.timer1.Enabled = (bool)(new System.Configuration.

AppSettingsReader().GetValue("timer1.Enabled", typeof(bool)));

this.timer1.Interval = (System.Double)(new System.Configuration.

AppSettingsReader().GetValue("timer1.Interval", typeof(System.Double)));

Observação

Existem dois timers, um para Windows Forms e outro para aplicativos baseados em servidor, com pequenas diferenças nos modelos de programação. Este exemplo usa o timer baseado em servidor. Para obter mais informações sobre os dois timers disponíveis, consulte Introdução a timers baseados em servidor.

Preocupações de desempenho e segurança com propriedades dinâmicas Há dois itens que podem ser preocupantes quando você usa propriedades dinâmicas. Primeiro, armazenamento e recuperação de propriedades dinâmicas podem afetar um pouco o desempenho do aplicativo. Recuperar valores de propriedades de dentro do aplicativo compilado é ligeiramente mais rápido do que recuperar valores de propriedades do arquivo de configuração. Na primeira vez em que um valor de arquivo de configuração é acessado pelo aplicativo, haverá um leve impacto no desempenho quando o aplicativo ler o arquivo. Porém este impacto é muito pequeno e não deve ser notado. Qualquer recuperação subseqüente desta ou outra propriedade tem um impacto no desempenho muito menor — semelhante a ler um valor de uma tabela de hash.

Segundo, se você estiver armazenando valores de propriedades tais como identificações dos usuários e senhas em um arquivo externo, você desejará controlar quem tem acesso ao arquivo e aos valores que ele contém. Uma maneira de se fazer isso é proteger o arquivo com uma lista de controle de acesso (ACL) do Windows. Uma lista de controle de acesso especifica que operações diferentes usuários podem executar em arquivos e diretórios específicos. Além disso, se você estiver trabalhando com um aplicativo baseado na Web, você pode tirar proveito da opção de segurança integrada fornecida pelo Windows, Serviços de Informações da Internet (IIS), e SQL Server. Neste modelo, credenciais de autenticação de um usuário para a rede local também são usadas para acessar recursos de banco de dados, e nenhum nome de usuário ou senha explícitos são usados na seqüência de conexão.

Para obter mais informações sobre segurança, consulte a documentação do Windows ou as seguintes páginas:

• Segurança de aplicativos da Web do ASP.NET

• Visão geral sobre como conectar-se a dados no Visual Studio

Visual Studio 322

Visual Studio 323

Personalizar e automatizar o ambiente de desenvolvimento

O local para aspecto para obter informações sobre como criar Add-ins, personalizar a aparência e comportamento do (IDE), ambiente de desenvolvimento integrado e tópicos de referência.

Nesta seção Personalizar o ambiente de desenvolvimento

Informações sobre como personalizar a janela da Ajuda dinâmica e barras de ferramentas, iniciar outros aplicativos de dentro do IDE, exportar e importar configurações, e fazer outras personalizações em IDE para conveniência e produtividade.

Gerenciamento de janela

Informações sobre como entrar reorganizar janelas ferramenta e documentos no IDE.

Automação e extensibilidade para Visual Studio

Informações sobre como criar macros e suplementos.

Seções relacionadas

Recursos de acessibilidade do Visual Studio

Informações sobre como otimizar layouts janela, alterar a fonte e cor do texto, e outras formas para personalizar o IDE.

Personalizar o ambiente de desenvolvimento Você pode alterar a aparência e comportamento do ambiente de desenvolvimento integrado do Visual Studio (IDE) de várias maneiras. O Visual Studio inclui várias combinações configurações predefinidas que você pode usar para aplicar um grupo de personalizações a IDE. Além disso, você pode Certifique individuais personalização a itens como janelas, barras de ferramentas, teclas de atalho, e várias opções exibe.

Nesta seção

Como: Personalizar Ajuda dinâmica

Instruções para reduzir o tipo de tópicos e categorias que aparecem na janela da Ajuda dinâmica.

Personalizar barras de ferramentas

Instruções para adicionar e personalizar a aparência de barras de ferramentas.

Como iniciar ferramentas no Visual Studio:

Instruções para adicionar um comando no menu Ferramentas para iniciar aplicativos externos para o Visual Studio de no Visual Studio.

Como personalizar a seção de notícias da página Iniciar:

Instruções para especificar um RSS personalizado alimentação para a página inicial.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/hthab0h8(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/4k7zyeba(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/xc52cke4(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/y4b5z3y3(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/25e3x9a7(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/wdee4yb6(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/9814d200(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/ms165466(VS.80).aspx

Visual Studio 324

Como alterar o item exibido em Iniciar Backup do ambiente de desenvolvimento do:

Instruções para especificar que uma caixa de diálogo específico, página, ou ambiente vazia é exibida quando você inicia o IDE.

Trabalhando com configurações

Informações sobre como configurações funcionam no IDE, importar e exportar configurações, e alterar basear configurações.

Seções relacionadas Recursos de acessibilidade do Visual Studio

Informações sobre como criar atalho combinações de teclas, otimizar layouts janela, altere a fonte e cor do texto, e outras formas para personalizar o IDE.

Personalizar recursos e opções do Editor

Detalhes para alterar a aparência do Editor, o texto, ele exibe e informações sobre como criar atalhos Editor.

Especificando configurações do depurador

Como usar e depuração. e Project Settings caixas de diálogo para alterar várias configurações para o depurador a Options

Criando e editando configurações

Procedimentos para especificar uma variedade de criar configurações para seu esforço de desenvolvimento.

Consulte também Outros recursos Personalizar e automatizar o ambiente de desenvolvimento

Visual Studio

Como: Personalizar Ajuda dinâmica Você pode alterar o número e tipo de links que aparecem na janela da Ajuda dinâmica para tornar mais fácil para localizar informações A janela da Ajuda dinâmica fornece links para informações encontradas na Ajuda local com base em parte da (IDE) o ambiente de desenvolvimento integrado que atualmente tem foco. Normalmente, os links que aparecem estão relacionados às você está tentando se realizar a tarefa atual ou a parte atual de IDE que você está usando. Os tópicos mais provável para ser útil para você estão listados primeiro.

Observação

Ajuda filtros não afetam a janela da Ajuda dinâmica. A janela da Ajuda dinâmica filtros automaticamente tópicos com base em suas ações no IDE. Além disso, a janela da Ajuda dinâmica não exibe links para informações encontradas em MSDN Online ou em sites da Web comunidade Codezone; ele só exibe links para tópicos encontrados na Ajuda local.

Por exemplo, você pode:

• Adicionar ou remover categorias tópico, ou vincular grupos.



http://msdnwiki.microsoft.com/pt-br/mtpswiki/2ewd52wf(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/y4b5z3y3(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/12199yxc(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/28ydy176(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/kwybya3w(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/ae3cxw0w(VS.80).aspx

Visual Studio 325

• Classificar categorias tópico.

• Adicionar ou remover tipos tópico.

• Especificar o contexto que a janela da Ajuda dinâmica usa para exibir links.

• Alterar o número de links exibidos para cada categoria tópico.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Esta página Ajuda foi gravada com General Development Settings em mente. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Exibir a janela da Ajuda dinâmico Para exibir a janela da Ajuda dinâmico

1. No menu View, escolha Other Windows e escolha Command Window.

2. Digite Help.DynamicHelp e pressione ENTER.

ou ——

No menu Help, escolha Dynamic Help.

Personalizar categorias tópico Você pode adicionar ou remover categorias tópico, como Miscelânea, treinamento e da janela da Ajuda dinâmico Categorias serão exibidas somente se não há tópicos que correspondem à categoria e o contexto IDE atual. As categorias incluídas no conjunto documentação padrão são ajuda, exemplos, e Guia de Introdução.

Para adicionar ou remover categorias tópico

1. No menu Tools, escolha Options.

2. Na caixa Options de diálogo, escolha Environment.

3. Em Environment, escolha Help e escolha Dynamic Help.

4. Na lista Categories, marque ou desmarque as categorias que estão listadas para adicionar ou removê-los da janela da Ajuda dinâmica.

5. Escolha OK.

Você pode alterar a ordem na qual as categorias aparecem na janela da Ajuda dinâmico

Para classificar categorias tópico




4. Na lista Categories, selecione a categoria você pretende mover e escolha Move Up ou Move Down.

Descrições da categoria:

Actions Lista Links para assistentes, macros, comandos, e outras ferramentas para serem iniciados quando você seleciona o link.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/zbhkx167(VS.80).aspx

Visual Studio 326

Training Lista links para tópicos do Microsoft (MSDN) treinamento conjunto documentação Developer Network.

Help Lista links para tópicos de conjuntos documentação dos msdn.

Samples Links para tópicos que demonstram o uso de tecnologias .NET.

Getting Started

Lista links para tópicos que foram projetados para ajudá-lo rapidamente tornar produtivos usando o Visual Studio.

Miscellaneous Lista links para tópicos que não cabem em uma das categorias acima.

Além disso, você pode especificar o número total de links que são exibidos em cada categoria. Os links são exibidos de acordo com relevância ponderada Os tópicos mais provável para ser útil para você são listados primeiro, para se você limitar o número de links exibida, você ainda deve obter os tópicos mais relevantes. Você pode exibir mais links se você quiser ser capaz de examine rapidamente um número maior de tópicos relacionados ao seu trabalho ou se seu posicionamento resolução e janela da tela permite que você se Consulte mais links ao mesmo tempo.

Para alterar o número de links exibidos para cada categoria tópico


2. Na caixa de diálogo Opções, escolha Environment.


4. Marque a Limit number of links per category caixa de seleção e insira um número na caixa de texto adjacentes.

Personalizar tipos tópico exibidos Em Categorias, você pode incluir ou excluir vários tipos diferentes tópico, tais como artigo e orientação. Por exemplo, se você deseja ver apenas links para tópicos de referência de idioma no janela da Ajuda dinâmico, excluir todos os tipos exceto sintaxe.

Para incluir ou excluir tipos tópico




4. Na lista, selecione ou Topic types desmarque os tipos listados para incluir ou exclui-los dos vínculos exibidos na janela da Ajuda dinâmica.

Descrições tipo tópico:

Article Fornece informações detalhadas sobre conceituais entidades incluindo: visões gerais conceito, backgrounders técnicos, informes oficiais, e as práticas recomendadas..

Procedure Instruções passo a orientação para realizar tarefas específicas.

Visual Studio 327

Orientation Resumos que ajudam a localizar a ajuda necessária na documentação Visual Studio.

Reference Informações sobre elementos syntactical não-, inclusive guias para elementos da interface do usuário, Ajuda sobre mensagens de erro, e tópicos do glossário.

Sample E / descrições de exemplos, muitos dos que contêm arquivos de código de fonte completa, você pode compilar criar, ou executar.

Syntax Descrições dos elementos sintáticos incluindo objetos, métodos, eventos, propriedades, funções, instruções, e expressões.

Especificar o contexto usado para determinar os tópicos para incluir Você também pode especificar o contexto de IDE que a janela da Ajuda dinâmica usa para determinar o escopo dos tópicos para exibir Esta opção pode limitar o número de tópicos exibidos.

Para especificar o tipo de contexto IDE para usar 1. No menu Tools, escolha Options.



4. Na Show links for, selecione o contexto você deseja a janela da Ajuda dinâmica exibir tópicos para.

Descrições contexto:

Selection only Limita a lista para tópicos associados com o elemento de interface do usuário que está selecionado no momento.

Active UI elements

Limita a lista para tópicos associados com qualquer elemento de interface do usuário que está aberto.

Show all links Exibe os tópicos que podem ser associados com o estado atual de IDE.

Consulte também Visual Studio

Como personalizar barras de ferramentas Visual Studio (): Você pode alterar o layout, Posição, e conteúdo de barras de ferramentas no ambiente de desenvolvimento integrado (IDE) Você também pode adicionar botões a barras de ferramentas e alterar o ícone atribuído de qualquer botão.

Criar novas barras de ferramentas Para criar uma nova barra de ferramentas

1. No menu Tools, escolha Customize.

2. Na caixa Customize de diálogo, selecione a Toolbars guia.

3. Escolha New.

4. Na caixa New Toolbar de diálogo, digite um nome para a barra de ferramentas

Visual Studio 328

5. Escolha OK.

Para adicionar um botão de comando a uma barra de ferramentas

1. No menu Tools , escolha Customize.

2. Na caixa Customize de diálogo, selecione a Commands guia.

3. Clique em Rearrange Commands.

4. Em Choose a menu or toolbar to rearrange, selecione Toolbar e escolha Barra de Ferramentas correta na lista drop-down.

5. Clique em Add.

6. Na caixa Add Command de diálogo, selecione Nome de Categoria da lista Categories e depois escolha um comando apropriado na lista Commands.

7. Clique em OK.

8. Clique Close em Close novamente.

Personalizar imagens de botão de ferramentas O IDE fornece forty-duas imagens de botão que podem ser trocadas com os ícones da barra de ferramentas Padrão.

Para alterar imagens de botão de ferramentas





5. Selecione o comando de ferramentas do qual você pretende alterar a imagem.

6. Escolha Modify Selection.

7. Escolha Change Button Image e selecione uma alternativa no menu em cascata.

Dica

Se você estiver unsatisfied com as imagens alternativas fornecidas, você pode personalizar uma imagem de sistema selecionada

Para editar imagens de botão





5. Selecione o comando de ferramentas do qual você pretende alterar a imagem.

6. Escolha Modify Selection.

7. Escolha Edit Button Image.

Visual Studio 329

8. Use a Button Editor caixa de diálogo para personalizar imagem do botão selecionado.

Observação

A Customize caixa diálogo pode ser usada para personalizar menus, assim.

Para obter mais informações sobre como aprimorar a usabilidade e acessibilidade de barras de ferramentas, Como definir opções de acessibilidade: consulte.


Como iniciar ferramentas no Visual Studio: Você pode adicionar itens para o menu Ferramentas que permitem a você para iniciar ferramentas externas a partir do Visual Studio. Por exemplo, você pode adicionar um item para o menu Ferramentas para iniciar utilitários, como exibir OLE ou WinDiff.

Observação


Para saber mais sobre Consulte

Fornecendo acoplamentos de teclas e teclas de aceleração para ferramentas externas

Adicionando chaves Accelerator e vinculação de chaves

Argumentos predefinidos para ferramentas externas Argumentos para ferramentas externos

Adicionar uma ferramenta externa ao menu Ferramentas Você pode adicionar um comando para o menu Ferramentas para iniciar outro aplicativo, como o Bloco de notas, de dentro do ambiente de desenvolvimento integrado (IDE).

Para adicionar uma ferramenta externa a esse menu

1. No menu Tools, escolha External Tools.

2. Na caixa de diálogo da External Tools, escolher Add, e digite um nome para a opção de menu na caixa Title.

Dica

Digite um E comercial antes uma das letras no nome ferramenta para criar uma tecla aceleradora para o comando quando ela aparecer no menu Tools. For example, if you use M&y External Tool, the letter 'y' will be the accelerator key.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/a2wb0asd(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/80cb6ks3(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/80cb6ks3(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/ekbzk5f8(VS.80).aspx

Visual Studio 330

3. Na caixa Command, digite o caminho para o arquivo você pretenda iniciar, ou optar Browse por navegue até o arquivo. Tipos de arquivos que você pode iniciar incluem.exe,.bat,.com,.cmd, e.pif.

Observação

Se o arquivo reside no caminho do sistema, poderá inserir apenas o nome de arquivo. Caso contrário, insira o caminho completo para o arquivo.

4. Selecione Use output window e Close on exit, como apropriado, e escolha OK.

Observação

A Use output window opção está disponível para arquivos.bat e.com somente.

Um comando para a ferramenta, usando o texto inserido como o título, agora aparece no menu Tools. Para iniciar a ferramenta, escolhendo o novo comando de menu.

Observação

Adicionando uma ferramenta externa a esse menu não não registrar um aplicativo como a ferramenta padrão do seu tipo. Por exemplo, se você desejar usar seu editor externo favorito para modificar marcações HTML, você pode definir essa preferência do Caixa de diálogo Opções browser, Ambiente, Web.. o Caixa de diálogo Opções browser, Ambiente, Web Também facilmente você pode criar um projeto add-in Visual Studio para informar o IDE na inicialização um utilitário externo que manipulará tarefas, como marcação validação ou fonte integração de controle de código.

Passar variáveis para ferramentas externas Você pode especificar que determinadas informações ser passadas para um comando quando ele for iniciado, como opções de linha de comando para aplicativos de console.

Para passar variáveis para a ferramenta

1. Na caixa Arguments, digite os argumentos que deseja passar para a ferramenta, ou escolha o botão de direção para selecionar um argumento predefinido.

Observação

Para obter mais informações sobre sintaxe argumento, consulte Argumentos para ferramentas externos.

2. Selecione Prompt for arguments Se você desejar a opção de edição os argumentos no momento o comando é iniciado.

Quando você iniciar a ferramenta externa partir menu Ferramentas, em seguida os argumentos que você selecionou será automaticamente passados para a ferramenta. Se você selecionou Prompt for Arguments, caixa Arguments de diálogo aparecerá.

Especificar uma pasta de trabalho

http://msdnwiki.microsoft.com/pt-br/mtpswiki/11k47e6y(VS.80).aspx



http://msdnwiki.microsoft.com/pt-br/mtpswiki/ekbzk5f8(VS.80).aspx

Visual Studio 331

Você também pode especificar a pasta de trabalho para a ferramenta ou comando Por exemplo, se a ferramenta lê dados do sistema de arquivos da pasta atual, a ferramenta requer se certos componentes de programa estão presentes na pasta atual na inicialização.

Para especificar uma pasta de trabalho para a ferramenta • Na caixa Initial directory, digite a pasta de trabalho para a ferramenta, ou

escolha o botão de direção para selecionar um local de diretório predefinidos.

Selecione Prompt for arguments se você gostaria que tem a opção de especificar argumentos adicionais no momento o comando é iniciado.

Exibir saída Unicode na janela de saída Se você usar uma ferramenta que fornece a saída de unicode em vez de ASCII, você pode optar por exibir o Unicode na janela de saída.

Para exibir saída Unicode na janela de saída • Selecione Treat output as Unicode.

Observação

Não selecionar esta opção para ferramentas que fornecem saída em ASCII.


Como personalizar a seção de notícias da página Iniciar: Você pode especificar qualquer RSS válido alimentação para a seção de notícias do Start Page.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Esta página Ajuda foi gravada com General Environment Settings em mente. Para alterar as configurações, no menu Tools, clique em Import and Export Settings. Para obter mais informações, consulte Configurações do Visual Studio.

Para personalizar a seção de notícias da página inicial 1. No menu Tools, clique em Options.

2. Expanda Environment e clique em Startup.

3. Em Start Page news channel, digite um novo RSS alimentação URL.

4. Clique em OK.


Como alterar o item exibido em Iniciar Backup do ambiente de desenvolvimento do:

Você pode alterar a interface de usuário que aparece por padrão quando você inicia Visual Studio.


Visual Studio 332

Observação


Para alterar o padrão UI exibida quando você inicia o Visual Studio 1. No menu Tools, escolha Options.

2. Expandir Environment e escolha Startup.

3. Na lista At startup drop-down, escolha uma das opções. Para obter mais informações, consulte Caixa de diálogo Opções inicialização, Ambiente,.

4. Clique em OK.

As alterações tenham efeito você iniciar Visual Studio na próxima vez.



Nesta seção Configurações do Visual Studio


Como: Alterar configurações selecionadas

Como: Especificar configurações para uma equipe

Import and Export Settings Wizard

Referência

Importar e exportar configurações, Ambiente, caixa de diálogo Opções







http://msdnwiki.microsoft.com/pt-br/mtpswiki/1x6229t8(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/f1z20s6z(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/xdfb57tf(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/2253f386(VS.80).aspx

Visual Studio 333











Coleções configurações predefinidas também fornecer personalizações à Ajuda. Configurações especificam o padrão How Do I Página na Ajuda. Eu selecionado




Visual Studio 334

como pendente eu página filtros fazer o conteúdo que aparece no índice analítico e no índice,, bem como fornece conteúdo personalizado na caixa como guia. Você pode alterar o ativo How Do I página na lista drop-down como pendente eu outras páginas.


• Favoritos


Consulte também Outros recursos Como: Alterar configurações selecionadas

Você pode aplicar um sub-set das configurações de uma coleção configurações diferentes para as configurações atuais para criar um ambiente de desenvolvimento mais personalizada. Para obter mais informações sobre configurações predefinidas, consulte Configurações do Visual Studio.








Consulte também Trabalhando com configurações

Esta seção contém informações sobre a aplicação, exportar e importar configurações para personalizar o ambiente de desenvolvimento integrado (IDE) para melhor correspondência seu estilo de desenvolvimento. Você também pode encontrar informações gerais sobre como configurações funcionam e os tipos de itens que são personalizadas através das configurações. Além disso, aprender a especificar um conjunto de configurações de uso da equipe.

Nesta seção


Visual Studio 335



Como: Alterar configurações selecionadas

Como: Especificar configurações para uma equipe

Import and Export Settings Wizard

Referência Importar e exportar configurações, Ambiente, caixa de diálogo Opções


Você pode exportar configurações para o editor, projetos, depuração, fontes e cores, e outras áreas IDE a um arquivo que você pode importar e usar em outro computador, como seu computador de desenvolvimento segundo ou computador um colega na.






Observação







Se você está importando o arquivo configurações contém todas as categorias configurações possíveis, importar esse arquivo completamente substitui as




http://msdnwiki.microsoft.com/pt-br/mtpswiki/xdfb57tf(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/2253f386(VS.80).aspx

Visual Studio 336

configurações existentes. Importar o arquivo se um arquivo de configurações contém apenas um subconjunto das categorias configurações, apenas aplica essas categorias e não afeta as configurações atuais para categorias não importadas.








Observação










Visual Studio 337


14. Clique em OK.


Consulte também Como: Especificar configurações para uma equipe

Quando estiver trabalhando em um grupo, ele pode ser útil para que cada desenvolvedor usar as configurações mesmas exatas em algumas áreas do ambiente de desenvolvimento integrado (IDE), como o editor. Você pode incentivar Essa consistência criando um arquivo.vssettings para um subconjunto de categorias configurações disponíveis que todos os desenvolvedores de seu grupo podem usar. Quando aplicado, essas configurações da equipe não seria substituem qualquer categoria não especificada no arquivo.vssettings, permitindo que desenvolvedores individuais para manter personalizações feitas para outras áreas do IDE. Para obter informações sobre como criar um arquivo.vssettings, consulte COMO: Compartilhar configurações entre computadores.







Consulte também Import and Export Settings Wizard

Use este assistente para exportar configurações, importar configurações, ou substituir as configurações para usar uma coleção configurações predefinidas.

Opção Descrição










Visual Studio 338






Observação


Consulte também Conceitos Nomeie O arquivo de configurações, importar e exportar configurações Assistente







Consulte também Conceitos Salvar configurações atuais, importar e Assistente para exportação configurações




Visual Studio 339







Consulte também Escolha Configurações para importar, importar e Assistente configurações exportação





Description


Consulte também Escolha um coleção de configurações para importar, importar e Assistente configurações exportação





Description


Visual Studio 340

Consulte também <task> Complete, Import and Export Settings Wizard

Esta página do importação e assistente exportar para configurações exibe informações sobre a tarefa configurações concluída com êxito ou não e todos os erros que foram encontrados. Você pode acessar este assistente a partir do Tools menu clicando Import and Export Settings.

Details


Consulte também

Visual Studio







Observação






Importar um arquivo.vssettings Após ter criado um arquivo.vssettings, você pode usar esse arquivo em outros computadores ao importar esse arquivo para outra instalação do Visual Studio.

Visual Studio 341

Você também pode importar arquivos de configuração criados por outros usuários e aplicar essas configurações para o Visual Studio.

Se você está importando o arquivo configurações contém todas as categorias configurações possíveis, importar esse arquivo completamente substitui as configurações existentes. Importar o arquivo se um arquivo de configurações contém apenas um subconjunto das categorias configurações, apenas aplica essas categorias e não afeta as configurações atuais para categorias não importadas.








Observação






Quando você compartilhar um arquivo.vssettings único em vários computadores, personalizações feitas, independentemente do computador no qual você torná-los na, são salvas para o arquivo.vssettings. A lista Tarefas por exemplo, se você

Visual Studio 342

fechar a lista de tarefas em um computador, na próxima vez que você iniciar o Visual Studio em outros computadores, não será exibida.





4. Clique em OK.













Visual Studio 343








Gerenciamento de janela O IDE (ambiente de desenvolvimento integrado) fornece várias ferramentas e opções para ajudá-lo a posicionar e mover entre janelas de documento e ferramenta.

Dois modos interface diferente são fornecidos para trabalhar com janelas de documento: Multiple documents modo e Tabbed documents modo.

Modo de interface Descrição

Vários documentos O IDE fornece uma moldura pai que serve como um contêiner visual e lógica de todas as janelas de documento.

Documentos com guias

Janelas de documento são colocadas lado a lado-em painéis com guias. O IDE usa esse modo por padrão.

Você pode altera modos interface IDE usando o Geral, Ambiente, caixa de diálogo Opções.

Tipos janela O ambiente de desenvolvimento integrado (IDE) contém dois tipos básicos janela: tool windows e document windows. Esses tipos de janela dois se comportar de maneiras ligeiramente diferentes.

Janelas ferramenta e janelas de documento não podem ser agrupadas juntos no IDE.

Janelas de ferramentas

Janelas de ferramentas são listados no menu View e são definidos pelo aplicativo atual e seus Add-ins.

Você pode configurar janelas de ferramentas no IDE para:

• Mostrar ou ocultar automaticamente

• Guia Vínculo com outras janelas ferramenta

• Encaixar contra as bordas do IDE

Visual Studio 344

• Flutuar sobre

• Exibir em outros monitores

Além disso, você pode exibir mais de uma ocorrência de determinadas janelas ferramenta ao mesmo tempo. Por exemplo, você pode exibir mais de uma janela do navegador. Você pode criar novas instâncias de uma janela ferramenta, escolhendo New Window no menu Window. Além disso, você poderá determinar como os botões fechar e AutoOcultar afetam um grupo de janelas de ferramentas ancorada juntos.

Janelas de documento

Janelas de documento dinamicamente são criadas quando você abrir ou criar arquivos ou outros itens. A lista de janelas de documento abertas é exibida no menu Window do atual na ordem z, com a janela mais alto-listada primeiro.

As maneiras em que você gerenciar as janelas de documento depende muito do modo de interface selecionado no Geral, Ambiente, caixa de diálogo Opções. Você pode optar por trabalhar no modo documentos Tabbed (o padrão) ou no modo de interface documentos múltiplos (MDI). Faça experiências com essas configurações para criar um documento edição ambiente que satisfaça suas necessidades e preferências. Para obter mais informações, consulte Gerenciamento de janela.

Janelas dockable

Em modo Tabbed, você pode tornar janelas de documento dockable ou undockable ao marcar ou desmarcar Dockable no menu Janela. No modo MDI, as janelas de documentos são undockable.

Dica

Determinados janelas de documento no IDE são realmente janelas ferramenta que têm a característica dockable está desativado. Para essas janelas, escolha Dockable a partir do Window Menu. ancorado

Grupos guia

Grupos guia estão disponíveis somente no Tabbed Documents modo. Elas estendem sua capacidade para gerenciar espaço de trabalho limitado ao trabalhar com dois ou mais documentos abertos no IDE. Você pode organizar várias janelas de documento em grupos guia vertical ou horizontal e ordem facilmente aleatória documentos de um grupo guia para outro.

Dica

Documentos com guias podem ser arrastados entre o IDE por suas guias.

Janelas tiled / Cascading

O Windows pode ser lado a lado ou organizados em cascata pilhas somente no modo MDI.

Windows dividir Quando você encontrar mesmo que precisam exibir ou editar dois locais simultaneamente em um documento, janelas de divisão podem ser útil. Para dividir o documento em duas seções independentemente rolagem, escolha Split No menu Window. Selecione Remove Split a partir do Window menu para restaurar a exibição única.

Visual Studio 345

Reutilizar janelas de documento

Para reduzir o número de janelas abertos ao mesmo tempo, você pode optar exibir todos os documentos inalterados na mesma janela do documento, permitindo que cada novo documento você aberto substituir a última. Escolha a Re-use current document window opção na página General do Environment Options.

Observação

Novos documentos será aberto no janela de documento atual para desde que o documento ativo não foi alterado.

Exibindo tópicos ajuda nas janelas

É possível exibir tópicos Ajuda interna ou externamente. Essas opções estão disponíveis no Ajuda, Ambiente, caixa de diálogo Opções.

Observação

Alterações para essas configurações só fazer terão efeito até que o IDE seja reiniciado.

Por padrão, ajuda inicia tópicos da Ajuda em um programa externo chamado Microsoft Document Explorer. Ajudar a ferramenta janelas podem flutuar, ou ser encaixado e fixado aberto ou defina para ocultar automaticamente quando não estiver em uso, muito semelhante janelas de ferramentas no IDE.

COMO: Organizar e ancorar janelas O ambiente de desenvolvimento integrado (IDE) tem dois tipos de janelas: ferramenta janelas e janelas de documento. Você pode aumentar a exibição e edição espaço para código, dependendo do como você organizar as janelas no IDE. Você tem várias opções para organizar janelas no IDE, incluindo o seguinte:

• Guia - ancorado janelas de documento.

• Ancorar janelas de ferramentas até a borda da moldura no IDE.

• Minimizar janelas de ferramentas ao longo da borda do IDE.

• Exibir janelas em monitores diferentes.

• Colocar janelas de documentos lado a lado.

• Redefinir posicionamento janela para o layout padrão.

Para obter mais informações sobre as diferenças entre janelas ferramenta e documentos, consulte Tipos janela.

Observação


Visual Studio 346

Encaixe Windows Editor janelas que exibem documentos podem ser organizadas em painéis com guias dentro do quadro de edição de IDE.

Para janelas Editor ancorado

1. No menu Tools, clique em Options.

2. Expanda a Environment pasta, e selecione General.

O Geral, Ambiente, caixa de diálogo Opções abre.

3. Em Window layout, selecione a Tabbed documents opção.

Quando essa opção é definida, documentos abertos em instâncias do editor automaticamente são organizados em painéis com guias.

Quando uma janela ferramenta estiver dockable, ele pode ser encaixado para um lado de uma moldura em IDE. Um losango guia aparece quando você arrastar janelas de ferramentas do seu local atual para outro local no IDE. O losango guia permite-lhe encaixar rapidamente novamente uma janela ferramenta em um dos quatro lados de IDE. Quando uma janela ferramenta é desencaixado ou não dockable, ele flutua na parte superior de outras janelas das.

Para janelas de ferramentas ancorado

1. Clique na janela ferramenta você deseja ancorado, para que ele foco.

2. No menu Window, clique em Dockable.

3. Arraste a janela de ferramentas do seu local atual em direção ao meio de IDE.

Um losango guia aparece. As setas do losango quatro ponto em direção as quatro bordas de IDE.

Dica

Para mover uma janela dockable sem ajustá-lo para o lugar, pressione CTRL ao arrastá-lo.

4. Quando você está arrastando a janela atingir a posição onde você deseja ancorado.-lo, mova o ponteiro sobre a parte correspondente do losango guia Tópicos da janela aparece na área designada.

5. Para ancorado a janela em posição indicado, versão o botão do mouse.

Por exemplo, se Solution Explorer está encaixado na borda direita do IDE ele na borda esquerda, você deve arrastar Solution Explorer para o meio do IDE, mova o ponteiro sobre à esquerda da versão o botão do mouse no losango guia, e. e você desejar ancorado

Minimizar Windows da ferramenta Janelas de ferramentas, todos os que apareça no menu View, suporte a um recurso chamado AutoOcultar. Ocultar automática permite-lhe ver mais do seu código ao mesmo tempo, minimizando janelas de ferramentas ao longo das bordas do IDE quando não estiver em uso. Ocultar automática só está disponível no modo vários documentos.

Para ativar AutoOcultar • Clique na janela você deseja ocultar para que ele foco.

Visual Studio 347

• No menu Window, clique em Auto Hide.

ou ——

Clique no ícone de anotações na barra de título da janela.

Ocultar automática ativada

Volta para sua guia quando uma janela hidden auto-perde o foco, ele slides automaticamente na borda de IDE. Enquanto uma janela estiver hidden auto-, seu nome e ícone estão visíveis em uma guia na borda de IDE. Para exibir uma janela hidden auto-, mova o ponteiro sobre o guia. A janela slides no modo de exibição e está pronto para uso.

Para desativar AutoOcultar • Clique na janela você deseja manter visíveis para que ele foco.

• No menu Window, clique Auto Hide para desmarcar a marca de seleção.

ou ——

Clique no ícone de anotações na barra de título da janela.

Automática desativada ocultar

Você pode controlar a velocidade em que esses transições ocorrem. Para obter mais informações, consulte Geral, Ambiente, caixa de diálogo Opções.

Dica

Janelas de ferramentas que têm AutoOcultar ativado temporariamente slide no modo quando a janela tem foco. Para ocultar a janela novamente, selecione um item fora da janela atual. Quando ela perde o foco, ele slides volta fora de vista.

Visual Studio 348

Para ativar AutoOcultar para janelas de ferramentas

1. No menu Tools, clique em Options.

2. Expanda a Environment pasta, e selecione General.

O Geral, Ambiente, caixa de diálogo Opções abre.

3. Em Window Layout, selecione a Multiple documents opção.

4. Selecionar OK, seguida, feche e reinicie Visual Studio.

Quando Visual Studio funciona no vários modo documentos, ferramenta janelas podem ser minimizadas ao longo das bordas de IDE.

5. No Multiple documents modo, selecione a janela ferramenta você deseja ancorado, para e siga os procedimentos anteriores " " ancorado janelas de ferramentas.

Dica

Para mover uma janela dockable sem ajustá-lo para o lugar, pressione CTRL ao arrastá-lo pela tela monitor.

6. Clique com o botão direito do mouse na janela ancorada ferramenta e, em seguida clique em Auto Hide Os slides janela volta para sua guia na borda de IDE.

7. Para exibir a janela, mova o ponteiro sobre sua guia na estrutura do IDE.

Observação

Para determinar a Geral, Ambiente, caixa de diálogo Opções. se Auto Hide opera em janelas de ferramentas individualmente ou como ancorados grupos, consulte a Auto Hide button affects active tool windows only opção na

Especificando um monitor Se você tiver um segundo monitor e seu suporta de plataforma usá-lo, você pode escolher que monitoram para exibir janelas no.

Para colocar janelas de ferramentas em monitores diferentes

1. Usar as Display configurações em para configurar as configurações monitor vários. o Control Panel Consulte a Ajuda do Windows para obter mais informações.

2. Arraste a janela de ferramentas para o outro monitor. Esta opção somente estará disponível em plataformas que dão suporte a vários monitores.

Tiling Windows do documento Se você deseja exibir mais de um documento ao mesmo tempo enquanto edita código, você pode colocar lado lado as janelas de documento.

Para colocar lado a lado janelas de documento • Se o IDE está sendo executado no Tabbed documents modo, selecione

uma guia e arraste-abaixo ou acima no lado de documento atual. Um contorno retangular aparece no local onde o novo lado de documento será colocado.

ou ——

Visual Studio 349

• Se você tiver definido o IDE para usar o Multiple documents layout janela, clique no Windows menu e, em seguida, clique em Tile Horizontally ou Tile Vertically. Para obter mais informações, consulte Geral, Ambiente, caixa de diálogo Opções.

Redefinindo layouts da janela Você pode retornar o IDE para o layout janela original para a coleção configurações usando o Reset Window Layout comando. Quando você executar este comando, as seguintes ações ocorrem:

• Todas as janelas são movidas para suas posições padrão.

• Janelas que estão fechadas no layout janela padrão são fechadas pelo comando.

• Janelas que estão abertas no layout da janela padrão são abertas pelo comando.

Você pode especificar um layout janela padrão diferente, modificando as configurações atuais. Para obter mais informações, consulte Como: Alterar configurações selecionadas.

Para redefinir posicionamento janela para o layout padrão

1. No menu Windows, clique em Reset Window Layout.

2. Na caixa de mensagem, clique em Yes.

Consulte também

HOW TO: Windows IDE de lista e arquivos Active Como uma conveniência, (IDE) o Ambiente de Desenvolvimento Integrado do Visual Studio fornece um IDE Navigator. Esta caixa de diálogo permite que você escolha rapidamente as janelas IDE e abrir arquivos você estiver usando. Para exibir o IDE Navigator, uso uma das combinações de teclas de atalho atribuídas ao comando Window.NextDocumentWindowNav.

Se o esquema de mapeamento do teclado padrão para o idioma em que você são programando atribui o atalho global CTRL + TAB para este comando, você pode duas pressione este atalho e mantenha pressionada a tecla CTRL para exibir com a janela IDE anterior selecionada.. Com o anteriormente arquivo ativo selecionada, ou pressione o atalho ALT+F7 e mantenha pressionado o ALT chave para exibir com o anteriormente arquivo ativo selecionado, ou pressione o atalho ALT+F7 e mantenha pressionado o ALT chave para exibir com a janela IDE anterior selecionada o IDE Navigator o IDE Navigator o IDE Navigator o IDE Navigator

Se o esquema de mapeamento do teclado para o idioma de desenvolvimento não incluir uma ligação chave para o Window.NextDocumentWindowNav Comando, ou se você preferir usar um ícone diferente, você pode remapear o atalho para este comando na página Keyboard na pasta Environment da caixa Options de diálogo. Para obter mais informações, consulte Como: Trabalhar com combinações de teclas de atalho.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Esta

Visual Studio 350

página Ajuda foi gravada com configurações Visual C# em mente. Para exibir ou alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Para selecionar um item em uma lista do Windows e arquivos aberta com as teclas CTRL+TAB 1. Pressione atalho CTRL + TAB para executar o Window.NextDocumentWindowNav

comando.

O IDE Navigator é exibida com o arquivo anterior selecionado.

2. Continuar a mantenha pressionada a tecla CTRL. Pressione a tecla TAB para mover para baixo na Active Files lista, ou pressione SHIFT+TAB para mover de volta backup desta lista.

-Ou--

Pressione as teclas SETA para mover acima e abaixo esta lista, ou esquerda e direita para colunas adjacentes.

3. Quando você tenha selecionado o nome do item desejado, versão a tecla CTRL.

A IDE Navigator Fecha, e o item selecionado é exibida.

Para selecionar um item em uma lista do Windows e arquivos aberta com ALT+F7 1. Pressione o atalho ALT+F7 para executar o Window.NextDocumentWindowNav

comando.

O IDE Navigator é exibida com a janela IDE anterior selecionada.

2. Continuar a mantenha pressionada a tecla ALT. Pressione a tecla F7 para mover para baixo e Active Files listas, ou pressione SHIFT+F7 para mover de volta backup essas listas. o IDE Windows

-Ou--

Pressione as teclas SETA para mover acima e abaixo essas listas, ou esquerda e direita para colunas adjacentes.

3. Quando você tenha selecionado o nome do item desejado, versão a tecla ALT.

A IDE Navigator Fecha, e o item selecionado é exibida.

Consulte

Caixa de diálogo do Windows Visual Studio () Esta caixa de diálogo permite que você para exibir, Fechar, e organizar documentos que estão abertos no editores e projetistas. Você pode exibir esta caixa de diálogo, escolhendo Windows no Window menu.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Name (Nome)

Visual Studio 351

Exibe os nomes das janelas de documentos e ferramenta, com o item ativo selecionado.

Path

Exibe o caminho completo para documentos. Janelas normalmente não tem um caminho.

Ativar

Faz o documento ou ferramenta Janela selecionado o item ativo no editor ou Designer.

Fechar janelas

Fecha os documentos selecionados e janelas em Da lista.

Lado a lado horizontalmente

Exibe as janelas selecionadas um em cima do outro. Disponível quando a opção " de ambiente " MDI (Interface de Documentos Múltiplos) estiver ativada no, os Geral, Ambiente, caixa de diálogo Opções nomes e o de dois ou janelas mais abertas são selecionadas.

Lado a lado verticalmente

Exibe a lado-a-lado Janelas selecionadas. Disponível quando a opção " de ambiente " MDI (Interface de Documentos Múltiplos) estiver ativada no, os Geral, Ambiente, caixa de diálogo Opções nomes e o de dois ou janelas mais abertas são selecionadas.

Consulte também

Caixa de diálogo colunas Determina as colunas que irá ser exibidas na janela do qual a Columns caixa de diálogo é exibida.

Colunas disponíveis

Uma lista em ordem alfabética ordenada das colunas que você pode exibir na janela pai.

Colunas exibidas

Uma lista em ordem alfabética ordenada das colunas exibidas na janela pai do momento.

Add

Move as colunas selecionadas na caixa Available Columns para a Displayed Columns Caixa. Quando você fechar a caixa de diálogo, as colunas são exibidas na janela do qual você exibida esta caixa de diálogo.

Remover

Remove as colunas selecionadas da lista Displayed Columns para a Available Columns Lista.

Redefinir

Do Available Columns redefine e Displayed Columns listas para conter as colunas que eles contidos quando a caixa de diálogo foi exibida. Do Move Up clicando no Reset botão também desfaz quaisquer alterações de classificação que você fez usando e Move Down Botões.

Visual Studio 352

Adicionar tudo

Move todas as colunas na lista Available Columns para a Displayed Columns Lista.

Remover tudo

Move todas as colunas na lista Displayed Columns para a Available Columns Lista.

Mover para cima

Move a coluna selecionada uma posição acima na ordem de exibição.

Mover para baixo

Move a coluna selecionada uma posição na ordem de exibição abaixo.

Consulte também

Caixa de diálogo colunas de classificação Caixa Sort Columns de diálogo determina como informações é organizado e exibida na janela pai através do qual a caixa é chamada.

Você pode usar a Sort Columns caixa para escolher colunas, especificar a ordem em que colunas são exibidas, e defina como a escolhida colunas são classificados

Colunas de classificação

Lista as colunas que serão classificadas na caixa de diálogo pai.

Todas as colunas

Lista as colunas que podem ser classificadas na caixa de diálogo pai.

Add

Move o item selecionado da lista All Columns para a Sort Columns Lista.

Mover para cima

Move o item selecionado cima na ordem de classificação.

Mover para baixo

Move o item selecionado para baixo na ordem de classificação.

Remover

Remove o item selecionado da lista de colunas a ser classificado.

Crescente

Especifica que os itens na coluna selecionada serão classificados em ordem crescente.

Decrescente

Especifica que os itens na coluna selecionada serão classificados em ordem decrescente.

Consulte

Visual Studio 353

COMO: Navegar dentro do ambiente de desenvolvimento integrado

O IDE (ambiente de desenvolvimento integrado) foi criado para tornar mais fácil de mover a janela da janela e documento ao documento. O IDE fornece várias maneiras para mover rapidamente entre documentos abertos.

Do IDE Navigator você pode usar para mover rapidamente para documentos que você está editando e para abrir janelas de ferramentas. Para obter mais informações sobre exibição e uso o IDE Navigator, consulte HOW TO: Windows IDE de lista e arquivos Active.

Observação


Selecionar Windows do documento Se você tiver Tabbed Documents Modo selecionado no documento Geral, Ambiente, caixa de diálogo Opções,. janelas são colocadas lado a lado-em painéis com guias como eles são abertos Esse modo IDE padrão simplifica para percorrer os documentos que você está editando.

Para percorrer documentos abertos por ordem de uso • Pressione CTRL + TAB para ativar documentos abertos na ordem que eles

foram mais recentemente toucheds.

• Pressione CTRL + SHIFT + TAB para ativar documentos abertos na ordem inversa.

Para obter informações sobre marcando e localizando locais específicos em arquivos, consulte Navegar através de código.

Para obter informações sobre como salvar uma lista pessoal de útil tópicos de ajuda, consulte Ajudar a janela de favoritos (Ajuda Explorer documento Microsoft).

Consulte também

Automação e extensibilidade para Visual Studio Automação e extensibilidade se refere a capacidade de forma programática automatizar tarefas repetitivas e estender (IDE) o Visual Studio ambiente de desenvolvimento integrado com ferramentas como os suplementos e assistentes. Os tópicos a seguir explicam como usar os diversos modelos de programação para fazer isso.

Estendendo o ambiente Visual Studio Embora Visual Studio você talvez precise um nível de controle adicionais ou maiores. oferece várias ferramentas e a energia para executar quase cada tarefa, Por exemplo, convém automatizar uma tarefa ou uma série de tarefas que você executar regularmente. Ou você pode ter criado ferramentas que você deseja usar no ambiente Visual Studio de desenvolvimento integrado (IDE).

Visual Studio 354

Para resolver esses problemas, Visual Studio Rich modelos de programação conhecidos como os modelos de objeto de automação, para estender e automatizar o IDE recursos. Os modelos automação vários fornecem a capacidade para automatizar o ambiente e fornecer extensões e novos recursos a ela. Cada modelo concentrates a uma área específica do IDE, como as janelas ferramenta, o editor de código, vários projetos, e assim por diante.

As seções abaixo apresentar a você para automação e extensibilidade e mostram como usá-los para facilitar a programação.

O que há de novo no extensibilidade e automação do Visual Studio 2005

Apresenta Visual Studio uma série de modelos de objeto de destino, programável. Com esses modelos, você pode acessar os componentes e eventos dentro do Visual Studio ambiente de desenvolvimento integrado (IDE) e seus projetos subjacente. Cada modelo contém tipos e membros que representam soluções, projetos, janelas de ferramentas, editores de código, depuradores, objetos de código, documentos, eventos, e mais. Conseqüentemente, você pode estender a funcionalidade de IDE, automatizar tarefas repetitivas, e integrar outros aplicativos ao IDE. Os modelos de objeto possam ser acessados por qualquer um dos quatro métodos:. Macros, suplementos, assistentes, e o Visual Studio Industry Partner (VSIP) program

Novo para Visual Studio 2005 Os Visual Studio modelos de automação têm o seguintes alterações e novos recursos:

• Rather Registro suplemento XML que registrar componentes no Registro do Windows, você arquivos XML uso agora para definir as configurações de Registro para Add-ins. Basta copiar o arquivo de Registro XML para as pastas apropriadas para Visual Studio para localizar e carregar o suplemento. Os arquivos contêm comentários que descrevem as marcas vários, que ajudam a facilmente localizar e editar suas configurações. Quando você criar Add-ins, usando esse arquivo é criado automaticamente. o Add-In Manager, Para obter mais informações, consulte Add-in de registro.

• o DTE2.Toolwindows Novo EnvDTE80.ToolWindows objeto também está disponível como a EnvDTE80.DTE2.ToolWindows propriedade. Ele melhora a descoberta e usabilidade de janelas de ferramentas no modelo de objeto, fornecendo acesso fácil às janelas ferramenta no IDE em seus tipos nativos. janelas de ferramentas Visual Studio podem ser acessadas através das propriedades membro. Outras janelas ferramenta podem estar localizadas com a nova GetToolWindow Função.

• o DTE.Toolwindows.CreateToolWindow2 Novo CreateToolWindow2 método torna mais fácil para criar suas próprias janelas de ferramentas personalizada que hospedam os controles do usuário. Um controle correção é não mais necessário.

• o Código gerenciado Add-ins Add-In Wizard oferece suporte agora em C++, assim, o .NET Framework como obter recursos de gerenciado Satellite DLLs.

• Não Ferramentas opções gerenciados há novas opções no menu Opções ferramentas para código gerenciado.

• a Suplemento Assistente e Visual J# Add-In Wizard agora oferece suporte criando Add-ins usando Visual J# e Visual C++ 2005.

Visual Studio 355

• o Eventos KeyPress modelo de automação Editor oferece um novo EnvDTE80.TextDocumentKeyPressEvents objeto que tem dois eventos para lidar com entradas pressionamento de de Tecla no Editor: EnvDTE80.TextDocumentKeyPressEventsClass.BeforeKeyPress e EnvDTE80.TextDocumentKeyPressEventsClass.AfterKeyPress.

• o Método InsertNewLine modelo de automação Editor oferece um novo EnvDTE80.EditPoint2.InsertNewLine(System.Int32) método para inserir linhas em documentos no editor.

• Soluções Pastas de solução agora podem conter pastas Solution, além de projetos. São Pastas de Solução (Solution Folders) recipientes do projeto que permitem a você para organizar melhor aplicativos grandes.

• do Lista de tarefas (Visual Studio) Agora você Tarefas de navegação padrão lista pode ir diretamente para linhas de código clicando duas vezes em itens em sem que seja necessário fornecer código adicional.

• o Localizar síncrona EnvDTE80.DTE2.Find Objeto oferece uma nova propriedade EnvDTE80.Find2.WaitForFindToComplete,. que permite a você para especificar se uma pesquisa é executada de forma síncrona ou assincronamente

• Algumas Suporte barra Comando Janela ferramenta janelas ferramenta incluem uma barra de ferramentas para acessar sua funcionalidade. Embora essas barras de ferramentas não estão disponíveis a partir da CommandBars coleção no objeto DTE, eles são disponíveis no objeto Window da janela da ferramenta.

• o AddNamedCommand avançada Novo EnvDTE80.vsCommandControlType Parâmetro em AddNamedCommand2 agora permite-lhe especificar o estilo de um botão, como somente texto, apenas, ícone ou texto e ícone. Você também pode criar tipos adicionais de controles para colocar nas barras de ferramentas e menus, como controles caixa de listagem, controles da caixa de edição da, e controles menu drop-down.

• Macros de exemplo Localização agora estão localizadas, e o Assistente para Adicionar-in gera Add-ins com o idioma apropriado. Por exemplo, se você estiver executando japonês Visual Studio, add-ins são criados usando os modelos Japonês (se eles estão disponíveis).

• Agora você Add-in e segurança de macro pode especificar se as macros são permitidas para executar, se os suplementos têm permissão para carregar, e onde Visual Studio procura por arquivos de configuração.AddIn. Para obter mais informações, consulte Add-in de segurança e Segurança macros e compartilhamento questões.

• Funcionalidade barra comando Novo conjunto barra de comando foi movida para um novo Visual Studio conjunto, Microsoft.VisualStudio.CommandBars,. eliminando dependência na biblioteca Microsoft Office (Mso.dll) Para obter mais informações, consulte Alterações CommandBar para o Visual Studio 2005.

• Todos Consistência do modelo de código os idiomas de programação em Visual Studio Uso do código principal Modelo em relação a versões anteriores, fazer para uma experiência mais consistente de programação.

• Um Adições do modelo principal Novo conjunto chamado EnvDTE80 contém um número de novos membros de automação. Para obter mais informações, consulte Novos membros de automação para Visual Studio 2005.

Visual Studio 356

• Um Adições do modelo de idioma Novo conjunto chamado VSLangProj80 contém um número de novos membros de automação, para Visual Basic, Visual C# e Visual J#. Para obter mais informações, consulte Novos membros de automação para Visual Studio 2005.

• Mais Mais código exemplo Tópicos da Ajuda para os diversos modelos de objeto de automação agora recurso código de exemplo. Muitos deles têm ambas Visual Basic e Visual C# código.

Automação e extensibilidade do Visual Studio

Novos membros de automação para Visual Studio 2005 Este tópico contém uma lista de todos os tipos novos para todos os modelos de automação (principais e idioma) em Visual Studio.

Adiciona Visual Studio 2005 uma grande quantidade de funcionalidade a Automação e atualiza funcionalidade existente. Para preservar compatibilidade com versões-e facilitar Migração de código, na maioria dos casos a nova funcionalidade foi adicionada aos novos conjuntos. Isso ajuda a evitar quebrar o código existente que depende as montagens antigas permitindo você a atualizar os aplicativos com a nova funcionalidade, se você desejar.

Comentários

Existem atualizações para as áreas Recurso de automação a seguir:

• Modelo de automação principal Visual Studio

• / Visual BasicVisual C# Projeto Modelo de automação

• Modelos de automação Visual C++

Modelo de automação Core Studio Visual

Nova funcionalidade para o Visual Studio modelo de automação principal está em um novo conjunto, EnvDTE80. Este tópico lista todos os seus novos tipos e membros.

A biblioteca originais e inalterados usado nas versões anteriores do Visual Studio — Como, EnvDTE — está incluído. Pode, conseqüentemente, os suplementos criados no Visual Studio .NET 2002 ou o Visual Studio .NET 2003 na maioria dos casos, ser migradas para Visual Studio 2005. Se você desejar acessar qualquer uma da nova funcionalidade, no entanto, seu projeto deve incluir uma referência para EnvDTE80.

Visual Basic C# / Model automação Project Visual J# / Visual

Nova funcionalidade para todos os o Visual Basic, Visual C#., e Visual J# Modelos de automação do projeto está em um novo conjunto, VSLangProj80 Este tópico lista todos os seus novos tipos e membros.

As bibliotecas originais e inalterados usados nas versões anteriores do Visual Studio — ou seja, VSLangProj e VSLangProj2 — são incluídos. Conseqüentemente, os suplementos criados no Visual Studio .NET 2002 ou Visual Studio .NET 2003 e que consultar esses podem bibliotecas, na maioria dos casos, ser migrados para Visual Studio 2005.

Modelos de automação do Visual C++

A seguir é uma lista de novos tipos e membros para os Visual C++ modelos de automação. Ela inclui:

• o modelo de projetos / criar contido em Microsoft.VisualStudio.VCProject e Microsoft.VisualStudio.VCProjectEngine.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/microsoft.visualstudio.vcproject(VS.80).aspx

Visual Studio 357

• o modelo de código contido em Microsoft.VisualStudio.VCCodeModel.

e-

• o modelo Assistente contido em Microsoft.VisualStudio.VsWizard.

Nome Tipo Novos membros

compileAsManagedOptions enum managedAssemblyPure

managedAssemblySafe

managedAssemblyOldSyntax

Enum BuildWithPropertySheetType Todos

compilerErrorReportingType enum Todos

eCLRImageType enum Todos

eCLRThreadAttribute enum Todos

cppExceptionHandling enum Todos

eDebuggerTypes enum Todos

driverOption enum Todos

eFileType enum eFileTypeCSharpFile

eFileTypeClassDiagram

eFileTypeMHT

eFileTypePropertySheet

eFileTypeCUR

eSqlClrPermissionLevel enum Todos

eWebRefUrlBehavior enum Todos

floatingPointModel enum Todos

linkerErrorReportingType enum Todos

Enum LinkTimeCodeGenerationOption Todos

machineTypeOption enum machineAM33

machineARM

machineEBC

machineIA64

machineM32R

machineMIPS

machineMIPS16

machineMIPSFPU

machineMIPSFPU16

machineMIPSR41XX

machineSH3

Visual Studio 358

machineSH3DSP

machineSH4

machineSH5

machineTHUMB

machineAMD64

midlTargetEnvironment enum midlTargetIA64

subSystemOption enum subSystemNative

subSystemEFIApplication

subSystemEFIBootService

subSystemEFIROM

subSystemEFIRuntime

subSystemPosix

subSystemWindowsCE

Enum WholeProgramOptimizationTypes Todos

IVCBuildOptionsPage ExtensionsToInclude (GET & SET)

ExtensionsToHide (GET & SET)

ToolFileSearchPaths (GET & SET)

ShowMatchingRuleDialog (GET & SET)

ShowNoMatchingRuleDialog (GET & SET)

ValidateSchemas (GET & SET)

DefaultSolutionExplorerMode (GET & SET)

IVCWizCtl Todos

IVCWizCtlUI DatabaseConnection

SuspendParsing

ResumeParsing

DoesFileOrDirectoryExist

solutionExplorerMode Todos

VCActiveXReference WrapperSuccessfullyGenerated (get)

GenerationErrorMessage (get)

VCCLCompilerTool ErrorReporting (GET & SET)

EnablePREfast (GET & SET)

FloatingPointExceptions (GET & SET)

floatingPointModel (GET & SET)

GenerateXMLDocumentationFiles (GET & SET)

Visual Studio 359

OmitDefaultLibName (GET & SET)

OpenMP (GET & SET)

UseFullPaths (GET & SET)

UseUnicodeResponseFiles (GET & SET)

XMLDocumentationFileName (GET & SET)

VCCodeBase Referências

VCCodeClass AddTemplateParameter

RemoveTemplateParameter

TemplateParameters

Referências

VCCodeElement Referências

VCCodeEvent IsVirtual

IsShared

Funções

VCCodeFunction AddTemplateParameter


TemplateParameters

IsSealed

Referências

VCCodeModel DotNetNameFromLanguageSpecific

LanguageSpecificNameFromDotNet

ElementFromID

VCCodeParameter IsConstant

IsVolatile

VCCodeProperty IsTrivial

IsVirtual

IsShared

Funções

Parâmetros

VCCodeReference Todos

VCCodeStruct AddTemplateParameter


TemplateParameters

Referências

Visual Studio 360

VCCodeTypedef Referências

VCCodeVariable Referências

IsVolatile

VCConfiguration BuildLogFile (GET & SET)

BuildWithPropertySheet

BuildWithPropertySheetPath

ClearToolProperty

Implantar

DeploymentTool (get)

ExcludeBuckets (GET & SET)

InheritedPropertySheets (GET & SET)

IntrinsicPropertySheets (GET & SET)

PropertySheets (get)

Vincular novamente

SqlAssemblyOwner (GET & SET)

SqlDebugScript (GET & SET)

SqlDeploySource (GET & SET)

SqlPermissionLevel (GET & SET)

SqlPostDeployScript (GET & SET)

SqlPreDeployScript (GET & SET)

WaitForBuild

VCCustomBuildRule Todos

VCDebugSettings ApplicationArguments (GET & SET)

ApplicationCommand

DebuggerFlavor (GET & SET)

Env (GET & SET)

EnvMerge (GET & SET)

MPIAcceptFilter (GET & SET)

MPIAcceptMode (GET & SET)

MPIRunArguments (GET & SET)

MPIRunCommand (GET & SET)

MPIRunWorkingDirectory (GET & SET)

ShimCommand (GET & SET)

VCDirectories Todos

Visual Studio 361

VCFile UnexpandedRelativePath

VCFileCodeModel IsManaged

IsMCOldSyntax

VCFileCodeUnion AddTemplateParameter


TemplateParameters

Referências

VCFilter Remove()

UrlBehavior (get)

VCLanguageManager CompareTokenStreams

VCLibrarianTool UseUnicodeResponseFiles (GET & SET)

Entradas (get)

LinkTimeCodeGeneration (GET & SET)

VCLinkerTool AdditionalManifestDependencies (GET & SET)

AllowIsolation (GET & SET)

AssemblyLinkResource (GET & SET)

CLRImageType (GET & SET)

CLRThreadAttribute (GET & SET)

DelaySign (GET & SET)

Driver (GET & SET)

ErrorReporting (GET & SET)

GenerateManifest (GET & SET)

KeyContainer (GET & SET)

KeyFile (GET & SET)

LinkLibraryDependencies (GET & SET)

ManifestFile (GET & SET)

Profile (GET & SET)

ProfileGuidedDatabase (GET & SET)

UseLibraryDependencyInputs (GET & SET)

UseUnicodeResponseFiles (GET & SET)

VCManagedResourceCompilerTool AdditionalOptions (GET & SET)

VCManifestTool Todos

VCNMakeTool AssemblySearchPath (GET & SET)

CompileAsManaged (GET & SET)

Visual Studio 362

ForcedIncludes (GET & SET)

ForcedUsingAssemblies (GET & SET)

IncludeSearchPath (GET & SET)

PreprocessorDefinitions (GET & SET)

VCPlatform CommitChanges

DebuggerTool (get)

DefaultDirectory (get)

DeploymentTool (get)

DisableAlternateDebuggers (get)

DumpfileExtensions (get)

ExcludeDirectories (GET & SET)

ExecutableExtensions (get)

GeneralPageTool (get)

GetMacroValue

GetToolNameForKeyword

IsDumpfile

IsExecutable

NumberOfPlatformMacros (get)

PlatformMacro (get)

vcprojCATIDS Todos

VCProject AddToolFile

AssemblyOriginatorKeyFile (GET & SET)

AssemblyReferenceSearchPaths (GET & SET)

DelaySign (GET & SET)

ExcludedPermissions (GET & SET)

FullPath (get)

GenerateManifests (GET & SET)

IncludeHeaderFile

LoadUserFile

MakeManagedDBConnection

ManagedDBConnection (GET & SET)

ManagedDBProvider (GET & SET)

ManifestCertificateThumbprint (GET & SET)

ManifestKeyFile (GET & SET)

Visual Studio 363

ManifestTimestampUrl (GET & SET)

RemoveToolFile

SaveUserFile

ShowAllFiles (GET & SET)

SignAssembly (GET & SET)

SignManifests (GET & SET)

TargetZone (GET & SET)

ToolFiles (get)

VCProjectConfigurationProperties OutputPath

VCProjectEngine AddFakeProps

CreatePropertySheet

CreateToolFile

LoadPropertySheet

LoadToolFile

PropertySheets

RemovePropertySheet

ToolFiles (get)

ToolFileSearchPaths (GET & SET)

ValidateSchemas (GET & SET)

VCProjectReference IsProjectLoaded

VCPropertySheet (VCStyleSheet anteriormente) BuildLogFile (GET & SET)

FileEncoding

ConfigurationType

ClearToolProperty

Salvar

UserMacros

AddUserMacro

RemoveAllUserMacros

VCReference UseInBuild (GET & SET)

SET VCReferences ()

AssemblyName (get)

SubType (GET & SET)

UseDependenciesInBuild (GET & SET)

CopyLocalDependencies (GET & SET)

Visual Studio 364

CopyLocalSatelliteAssemblies (GET & SET)

CopyLocal (GET & SET)

VCReferences Referências (get)

AddAssemblyReferenceWithStrongName

CanAddAssemblyReferenceWithStrongName

AddProjectReferenceByIdentifier

CanAddAssemblyReferenceByIdentifier

AddReferenceToFile

CanAddReferenceToFile

VCRuntimeBooleanProperty Todos

VCRuntimeEnumProperty Todos

VCRuntimeEnumValue Todos

VCRuntimeIntegerProperty Todos

VCRuntimeProperty Todos

VCRuntimeStringProperty Todos

VCToolFile Todos

VCUserMacro Todos

VCXDCMakeTool Todos

A seguir estão tipos e membros que foram removidos da Visual Studio 2005.

Nome Tipo Membros excluído

genProxyLanguage enum genProxyCs

pchOption enum pchGenerateAuto

Enum RemoteDebuggerType RemoteLocal

RemotePipe

runtimeLibraryOption enum rtSingleThreaded

rtSingleThreadedDebug

VCActiveXReference SET ControlGUID ()

SET ControlVersion ()

SET ControlLocale ()

VCAssemblyReference SET RelativePath ()

VCAuxiliaryManagedWrapperGeneratorTool Todos

VCCodeClass AddEvent

Templateization (get)

VCCodeFunction Templateization (get)

Visual Studio 365

VCCodeStruct Templateization (get)

VCCodeUnion Templateization (get)

VCCLCompilerTool GlobalOptimizations (GET & SET)

ImproveFloatingPointConsistancy (GET & SET)

OptimizeForProcessor (GET & SET)

OptimizeForWindowsApplication (GET & SET)

VCConfiguration AppliedStyleSheets (GET & SET)

BuildBrowserInformation (GET & SET)

SET StyleSheets ()

ReferencesPath (GET & SET)

FullReferencesPath (get)

ReferenceTools (get)

VCDesignerReference Todos

VCFileCodeModel Sincronizar

VCFilter Excluir

VCManagedWrapperGeneratorTool Todos

VCPrimaryInteropTool Todos

VCProjectConfigurationProperties BuildBrowserInformation (GET & SET)

VCProjectEngine RemoveProject

VCProjectReference NativeOutputForConfiguration

SET ReferencedProjectIdentifier ()

SET ReferencedProject ()

VCReference BaseFileNameForConfiguration

BuildNumberForConfiguration

CultureForConfiguration

FullPathForConfiguration

MajorVersionForConfiguration

MinorVersionForConfiguration

Nome (set)

PublicKeyTokenForConfiguration

ReferenceConfigurations

ReferenceIsManaged

RevisionNumberForConfiguration

StrongNameForConfiguration

Visual Studio 366

VersionForConfiguration

VCReferenceconfiguration Todos

VCStyleSheet (changed to VCPropertySheet Plataforma

BuildBrowserInformation (GET & SET)

ToolSet (GET & SET)

ReferencesPath (GET & SET)

A seguir estão tipos e membros que foram alterados no Visual Studio 2005.

Nome Tipo Membros alterados Alteração

compileAsManagedOptions enum managedAssembly Era managedAssembly = 2

midlTargetEnvironment enum midlTargetWin64 (midlTargetAMD64 agora)

Alteração de nome membro

genProxyLanguage enum genProxyManagedCpp (genProxyManaged agora)


pchOption enum pchNone = 0 Era pchNone

IVCProjectEngineEvents ItemPropertyChange Parâmetro adicionado

VCActiveXReference WrapperTool Era NonBrowsable

VCConfiguration ManagedExtensions (GET & SET) Parâmetro digite alteração

WholeProgramOptimization (GET & SET)

Parâmetro digite alteração

VCCLCompiler ExceptionHandling (GET & SET) Parâmetro digite alteração

VCLinkerTool LinkTimeCodeGeneration (GET & SET) Parâmetro digite alteração

VCProjectConfigurationProperties WholeProgramOptimization (GET & SET)

Parâmetro digite alteração

ManagedExtensions (GET & SET) Parâmetro digite alteração

VCReference BuildNumber Alteração de nome de parâmetro

CopyLocal (GET & SET) Alteração de nome de parâmetro

Cultura Alteração de nome de parâmetro

Descrição Alteração de nome de parâmetro

FullPath Alteração de nome de parâmetro

Identidade Alteração de nome de

Visual Studio 367

parâmetro

Label Alteração de nome de parâmetro

MajorVersion Alteração de nome de parâmetro

MinorVersion Alteração de nome de parâmetro

Nome (get) Alteração de nome de parâmetro

PublicKeyToken Alteração de nome de parâmetro

Referência Alteração de nome de parâmetro

RevisionNumber Alteração de nome de parâmetro

StrongName Alteração de nome de parâmetro

Version Alteração de nome de parâmetro

VCReferences AddAssemblyReference Alteração de nome de parâmetro

AddActiveXReference Alteração de nome de parâmetro

AddProjectReference Alteração de nome de parâmetro

RemoveReference Alteração de nome de parâmetro

Contagem Alteração de nome de parâmetro

VCStyleSheet / VCPropertySheet StyleSheetName (PropertySheetName agora)

Alteração de nome de parâmetro

StyleSheetFile (PropertySheetFile agora) Alteração de nome de parâmetro

AppliedStyleSheets (InheritedPropertySheets agora)


ManagedExtensions Parâmetro digite alteração

StyleSheetDirectory (PropertySheetDirectory agora)


PropertySheet (get) Alteração de nome de parâmetro

VCXMLDataGeneratorTool GeneratedProxyLanguage (GET & SET) (now Namespace)


Visual Studio 368

Práticas recomendadas para segurança na automação Os desenvolvedores de automação Visual Studio devem compreender e aceitar a responsabilidade de criação de aplicativos seguros por noções básicas sobre vulnerabilidades de segurança. Um aplicativo seguro protege a confidencialidade, integridade, e disponibilidade de informações a clientes '. Além disso, protege a integridade e disponibilidade de recursos de processamento, que controla proprietário ou administrador do sistema.

Para fins de discussão, uma vulnerabilidade de segurança é uma falha em um produto que permite um invasor — mesmo quando o produto é usado corretamente — para:

• apropriado privilégios no sistema do usuário,

• regular, alterar ou redirecionar sua operação,

• comprometer seus dados,

- ou -

• Suponha confiança ungranted.

Importante

Nunca pressupõem que será o aplicativo ser executado em alguns ambientes determinados, somente especialmente se o aplicativo ficar muito popular. Possibilidade é proporcional que ele será usado em outro, imprevistas, configuração. Suponha que seu código será executado nos ambientes hostis mais ser em vez disso. Criar, gravar, e testar seu código de acordo.

Há benefícios para criar aplicativos seguros. Código que é inicialmente projetado e criado com segurança em mente é mais robusto que código escrito com segurança que é adicionada como um afterthought. Aplicativos com segurança projetados são também mais resistente a criticism de mídia, mais atraente para usuários, e menor custo para corrigir e suporte.

APIs arriscada Algumas funções API podem ser consideradas mais arriscadas que outros do ponto de vista de segurança. Alguns podem estar inerentemente arriscada na forma que eles funcionam. Outras pessoas podem ser arriscadas se não chamado ou manipulados corretamente. O ponto é que você deve estar familiarizado com as armadilhas e quirks das várias funções API você chamar, e se eles representam qualquer classificação de risco de segurança, assegurar que elas são usadas corretamente.

Além disso, além disso, não assumir que como seu código usa somente funções de API que são consideradas " seguros " que seu aplicativo é automaticamente segura e protegida, bem.., bem Negligent práticas de programação podem expor seu aplicativo para como risco ou muito mais do que usar funções supposedly " perigosas ". Tais práticas podem incluir:

• Não tratamento exceções corretamente,

• Usando caminhos embutidas,

• Utilizando seqüências de conexão embutidas,

Visual Studio 369

- ou -

• Não verificando credenciais de usuário correta ou permissões.

Completamente para proteger seus aplicativos, você deve entender questões de segurança de código por pesquisar o assunto. O livro da Microsoft Press, Writing Secure Code, e o site diretrizes codificação de segurança em http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnnetsec/html/seccodeguide.asp são recursos boas.

Outro ponto importante para compreender é que muitos problemas de segurança resultar de aplicativos que blindly confiam entrada dados. É essencial que os aplicativos cuidadosamente examinar e avaliar dados como ele é recebido para verificar se os dados é válido e confiável antes de usá-lo.

Recursos de segurança de automação Além de seguir estas diretrizes, Visual Studio automação oferece algumas maneiras simples e específicos para ajudá-lo a proteger seu sistema de automação exploitations de segurança. Lembre-se, entretanto, que eles são não um panacea de todos problemas de segurança. Em vez disso, eles são um bom começo. Para informações, consulte Add-in de segurança.

Pesquise e seguir diretrizes de segurança .NET cuidadosamente antes de criar seus aplicativos de automação.

Consulte também

O espectro de automação Visual Studio oferece Visual Studio três níveis diferentes de extensibilidade:. Macros, suplementos e assistentes, e o Visual Studio Industry Partner (VSIP) program

Macros Macros são a maneira mais fácil para estender (IDE) o Visual Studio ambiente de desenvolvimento integrado com o código. Não somente eles fornecem um aumento grande de produtividade permitindo que você para registrar várias ações no IDE e executá-las novamente como um único comando, elas também permitem que você para saber os Visual Studio modelos automação durante a gravação macros. Macros também oferecem um ambiente de desenvolvimento Full-fledged chamado o IDE macros que seja baseado em Ide Visual Studio. Ele usa o Visual Basic idiomas e é usado para criar, editar e depurar macros. Para obter mais informações sobre macros, consulte Automatizar ações Repetitive usando macros.

Os suplementos e assistentes Os suplementos são aplicativos tempo-economia labor e anexar a e são usados dentro do Visual Studio ambiente de desenvolvimento integrado (IDE). Do EnvDTE são objetos COM que implementam a IDTExtensibility2 interface e se comunicar com o IDE através do modelo de objeto de automação principal que está contido em, e EnvDTE80 montagens. O modelo de ferramentas estão contido no Microsoft.VisualStudio.CommandBars.

As linguagens de programação vários em Visual Studio fornecem objetos de automação adicionais por seus próprios conjuntos. As montagens de automação específicas projeto são:

Nome do conjunto Descrição

VSLangProj Visual BasicVisual C# e Visual J# projeto modelo de automação.,

Visual Studio 370

VSLangProj2 Visual BasicVisual C# e Visual J# projeto modelo de automação.,

VSLangProj80 Visual BasicVisual C# e Visual J# projeto modelo de automação.,

Microsoft.VisualStudio.VCCodeModel Modelo de automação de código Visual C++.

Microsoft.VisualStudio.VCProject Projeto Visual C++ Modelo de automação.

Microsoft.VisualStudio.VCProjectEngine Projeto Visual C++ Modelo de automação.

Microsoft.VisualStudio.VsWizard Modelo de automação Assistente Visual C++.

Como Add-ins são código compilado, binário, sua propriedade intelectual é protegida. Você pode implementar Add-ins em qualquer idioma consuming com tal, Visual C# como Visual C++, Visual Basic e assim por diante.

Para a maioria dos desenvolvedores, as macros são suficientes para programação com o Visual Studio modelo de automação. Em alguns casos, entretanto, add-ins pode ser preferível para desenvolvedores, como os ISVs, que deseja perfeitamente adicionar todos recursos novos ao IDE. Add-ins cabe esses recursos na IDE Visual Studio como se fossem internos.

Add-ins também permite que sejam fazer algumas coisas que não podem macros. Usando suplementos, você pode:

• Hospedar sua ferramenta de uma menu ou barra de ferramentas no IDE.

Isso permite que você para facilmente acessá-lo enquanto você está programando.

• Criar páginas de propriedades personalizadas para a Options caixa de diálogo no menu Tools.

Para obter mais informações, consulte Como criar páginas opções ferramentas personalizadas:.

• Criar janelas de ferramentas que agem como Visual Studio janelas de ferramentas.

Para obter mais informações, consulte Criando e Controlling ambiente Windows.

• Ativar e desativar comandos de menus e a Visual Studio barra de comando dinamicamente.

Para obter mais informações, consulte Como Adicionar e identificador comandos:.

• Adicionar contato e informações descritivas a ajuda sobre a Visual Studio Caixa.

Assistentes são aplicativos que levar usuários através de um processo de criação programas ou realizar tarefas de programação que são mais difíceis ou complicado que usual Instruções passo. Por exemplo, Visual Studio oferece o assistente suplemento para ajudar os usuários criar um projeto Add-In e projeto de implantação. Você pode criar seus próprios assistentes criando um projeto que implementa a IDTWizard interface. Do New Project assistentes são geralmente chamados através de ou New File caixas de diálogo.

Programa Partner (VSIP) Industry Studio Visual

Visual Studio 371

Para a maioria dos usuários, macros, add-ins, e assistentes atender à maioria de suas necessidades em Visual Studio. Entretanto, alguns usuários, precisará ir além os recursos do modelo Visual Studio de automação consideráveis. Por exemplo, um usuário pode querer incorporar um totalmente nova linguagem de programação ao IDE Visual Studio, possivelmente criar uma necessidade de:

• Um novo tipo de projeto.

• Um editor personalizado.

• Depuração recursos avançados.

O Visual Studio Industry Partner (VSIP) program foi criado para você pode fazer isso. VSIP fornece a ferramentas e informações necessárias para integrar o produtos para o Visual Studio ambiente. VSIP, que é uma coleção de SDKs, é um conjunto do desenvolvedor e plataforma. Ele fornece parceiros VSIP controle maiores e mais ampla sobre o IDE, fornecendo acesso a mais interfaces e Total Visual Studio Integração ajuda. Parceiros com VSIP, podem fornecer maior funcionalidade em ambiente de criação seus usuários '. Para obter mais informações, pesquise a ajuda para Visual Studio Industry Partner (VSIP) program, ou visite o site VSIP em http://msdn.microsoft.com/vstudio/Extend.

Escolhendo a abordagem de automação adequada Fornece Visual Studio várias opções para criar aplicativos de automação. No entanto, o método exato deve escolher, dependerá basicamente na tarefa iminente. Para ajudar a orientá-lo para o método melhor, considere os seguintes fatores.

Você deseja distribuir o código ou um aplicativo compilado?

• Usar Distribuir código — uma macro. Você pode implantar macros, copiando arquivos do projeto uma macro para o novo local. Não há nenhuma configuração ou o registro, mas usuários de sua macro deverá clique no Tools menu, aponte para Macros, e, em seguida, clique Load Macro Project Para iniciar usá-los. Você também pode enviar uma macro como texto para uso por outros usuários. Para obter mais informações, consulte Como gravar macros:.

• Usar Distribuir um aplicativo compilado — um suplemento ou um assistente, ou um aplicativo que usa as interfaces de automação. Os suplementos, assistentes e outros aplicativos que usam as interfaces de automação proteger sua propriedade intelectual a compilação. No entanto, para distribuí-los, você deve usar um projeto de implantação ou alguma outra forma de instalação. Para obter mais informações, consulte Como criar um add-in: ou Passo-a-passo: Criando um assistente.

Linguagem de programação que você deseja usar para desenvolver o aplicativo de automação?

• Você Visual Basic — pode criar macros, suplementos, ou assistentes. Para obter mais informações, consulte Automatizar ações Repetitive usando macros ou Criando Add-ins e assistentes.

• Você Outros idiomas — pode criar os suplementos e assistentes, usando a IDTExtensibility2 interface e a IDTWizard interface. Você deve ser capaz para implementar um objeto com able CoCreate-na linguagem de programação.

A tarefa requer entrada do usuário?

• Uma Nenhuma entrada de usuário é necessário — macro ou add-in é adequado. Para obter mais informações, consulte Automatizar ações Repetitive usando macros ou Criando Add-ins e assistentes.

Visual Studio 372

• Uma Entrada simples — macro, Add-in, ou assistente é adequado.

• Se Entrada complexas — a entrada tem várias etapas ou Exigir verificação, um assistente pode ser mais apropriado.

Como complicada é a tarefa você estiver automatizando?

• Se Muito simples — você pode realizar a tarefa na apenas algumas linhas de código, uma macro é apropriada.

• Enquanto Complicado — macros podem incluir formulários, referências, e classes, um suplemento ou assistente pode ser mais apropriado.

Como você acha que o usuário será iniciado o aplicativo?

• Usar Menus ou barras de comando — um suplemento.

• Usar Um atalho de teclado ou o Explorer macro — uma macro.

• Usando Novo projeto ou item novo item de menu — um assistente é característico para adicionar um novo projeto ou arquivo para um aplicativo.

O que é o tempo de vida de seu aplicativo?

• Uma Preciso apenas de hoje — macro gravada temporária pode ser suficiente.

• Uma Eu vai ser usando ele tempo term — macro, assistente, ou add-in é adequado.

O que você precisa desenvolver?

• Macros Uma tarefa automatizada —, suplementos, e assistentes todos podem ser usados para automatizar tarefas. Para obter mais informações, consulte Automatizar ações Repetitive usando macros ou Criando Add-ins e assistentes.

• Adicionar Páginas de propriedades personalizadas para as ferramentas, caixa de diálogo Opções — -. ins e assistentes suporte a essa funcionalidade Para obter mais informações, consulte Como criar páginas opções ferramentas personalizadas:.

• Adicionar Ferramenta ou documento janela personalizadas — -. ins e assistentes suporte a essa funcionalidade Para obter mais informações, consulte Como ferramenta Windows criar e controlar:.

• Become Um novo tipo de projeto — um parceiro VSIP. Para obter mais informações, consulte http://msdn.microsoft.com/vstudio/Extend.

• O suporte para um novo idioma de programação no Visual Studio ou um novo editor — Become a VSIP partner.

Funcional grupos de automação O modelo de objeto de automação consiste expansivas grupos funcional de objetos de alguns,. Esses objetos controlar principais aspectos do ambiente de desenvolvimento integrado (IDE) e aplique a todos os tipos de projeto em Visual Studio. Noções básicas sobre como esses grupos funcionam torna mais fácil para compreender e usar o modelo.

Os objetos nesses grupos funcional totalmente são descritos no Gráfico do modelo de objeto de automação. Os grupos são:

Visual Studio 373

• Solução, projeto, e objetos item projeto.

• Criar objetos.

• Código objetos Editor.

• Código objetos de manipulação definição.

• Ferramenta janela e documente objetos de manipulação.

• Ferramenta específicas janela-objetos, tais como a Task List, Output janela, e Toolbox.

• Comandos objetos.

• Depuração objetos.

• Objetos de tratamento de eventos.

Cada grupo funcional consiste de um ou mais relacionados objetos, coleções, ou interfaces que contribuem para uma finalidade específica. Por exemplo, a função primária do grupo objetos do evento é para fornecer acesso a eventos que ocorrem no IDE Um tal objeto do grupo é o TaskListEvents objeto, que permite que você para responder a eventos que ocorrem no Task List. Outra nesse grupo é o BuildEvents objeto, que permite que você para responder a eventos que ocorrem em uma operação de criação, como o início ou conclusão de uma compilação.

Modelos de automação específicas projeto- Além para o modelo — de automação " principal " então chamado, porque ele — Qualquer Visual Studio idioma pode cada idioma em Visual Studio oferece um ou mais automação específicas projeto-modelos para acessar seus recursos especiais. Para Visual Basic, Visual C# e Visual J# projetos, esse modelo está localizado nos seguintes conjuntos:

• VSLangProj,

• VSLangProj2

• VSLangProj80

Para obter mais informações sobre essa funcionalidade, consulte Introdução à extensibilidade de projeto.

Para Visual C++, os conjuntos são:

• Microsoft.VisualStudio.VCCodeModel

• Microsoft.VisualStudio.VCProject

• Microsoft.VisualStudio.VCProjectEngine

• Microsoft.VisualStudio.VsWizard

Eles representam (respectivamente), o Visual C++ modelo código específico, o Visual C++ modelo de projeto, e o Visual C++ modelo Assistente.

Consulte também

Acessando o modelo de automação por usando macros Macros Visual Studio são uma maneira excelente para facilmente obter acesso aos diversos Visual Studio modelos de automação. Use-los para criar ferramentas-com base Automation para uso em Visual Studio.

Rápido e fácil de Use

Visual Studio 374

Macros são criadas, executado, e depurado em seu próprio ambiente separado, (IDE) o ambiente de desenvolvimento integrado macros. Conseqüentemente, é fácil para executar e depurar o código de automação nele, contra o IDE principal, sem iniciar outra instância do Visual Studio.

Como referências para as bibliotecas de automação Principal. (EnvDTE) já são fornecidos, imediatamente para começar escrever código direita após iniciar o IDE macros e EnvDTE80

Macros são também uma maneira excelente para criar ferramentas de automação rápido, disposable para ajudar a automatizar um processo repetitivo, ou ainda mais sofisticadas ferramentas Automação. Para obter mais informações sobre como criar, usando, e depuração macros, consulte Automatizar ações Repetitive usando macros.

Consulte também

Criando Add-ins e assistentes Embora Visual Studio alguns desenvolvedores exigir um nível de controle adicionais ou maiores. oferece várias ferramentas e a energia para executar quase cada tarefa, os desenvolvedores Por exemplo, eles podem ter uma tarefa ou série de tarefas que executar regularmente e gostaria de automatizar. Para resolver esse problema, Visual Studio recursos um Rich programação modelo, conhecido como o modelo de automação, para estender e automatizar o IDE (ambiente de desenvolvimento integrado). O modelo Automação fornece a capacidade de automatizar o ambiente e fornecer extensões e novos recursos a ela.


Gravação e execução macros Automatizar ações Repetitive usando macros

As três maneiras para acessar Visual Studio Automação O espectro de automação Visual Studio

Grupos functional de objetos no modelo de objeto de automação

Funcional grupos de automação

Como criar Add-ins Como criar um add-in:

Como referência espaço para nome EnvDTE e obter uma instância do objeto DTE

Referência conjuntos de automação e o objeto DTE2

Registrar um suplemento Add-in de registro

Como limitar o acesso a arquivo de Registro Xml.AddIn do seu projeto

Add-in de segurança

Expor Add-ins nos menus e barras de ferramentas Exibindo Add-ins em barras de ferramentas e menus

Conectando Add-ins a teclas de atalho Comandos Suplemento de ligação para chaves

Novas alterações na funcionalidade barra de comando Alterações CommandBar para o Visual Studio 2005

Como restaurar comandos que desaparecem de um menu Como restaurar comandos suplemento para o menu:

No ambiente carregando, descarregando, e controlar Add-ins HOW TO: com o Gerenciador de Suplementos controle Add-ins

Visual Studio 375

Depuração Add-ins Depuração Walkthrough: um projeto Add-in

Criando um assistente Passo-a-passo: Criando um assistente

Iniciar assistentes programaticamente Parâmetros de contexto para Launching assistentes

Arquivos do assistente (.vsz) Configurando Arquivos VSZ para iniciar assistentes

Arquivos VSDir, a Add Item e New Project caixas de diálogo e como elas afetam

Adicionando assistentes para a Adicionar Item e novas caixas de diálogo Project usando arquivos VSDir

Como criar uma nova instância de Visual Studio forma programática ou anexar a uma instância específica de Visual Studio que já está executando

Como criar e anexar a outra instância do Visual Studio:

Como atualizar projetos de automação das versões anteriores do Visual Studio para Visual Studio 2005.

Migrando e atualizando Add-ins do Visual Studio .NET 2003 para o Visual Studio 2005

Referência conjuntos de automação e o objeto DTE2 Para criar aplicativos de automação, você deve executar etapas para obter acesso a membros de automação. Primeiro, você deve fazer referência os conjuntos de automação necessários, e Segundo, você deve obtém uma referência para o objeto DTE2 de nível superior.

No Visual Studio .NET 2002 e Visual Studio .NET 2003, todos os itens de automação principais estavam localizados em um conjunto nomeado EnvDTE, e seu objeto maior, hierárquica é o DTE objeto. Ele é o objeto pai para todos os objetos de automação principais, coleções, e seus membros. Derivar DTE2 de DTE.

Para Visual Studio 2005, adições e atualizações foram feitas para alguns desses objetos, coleções, e membros. Em vez de atualizar o conjunto existente e comprometer compatibilidade com versões-para existente Add-ins e projetos de automação, novo e atualizado toda funcionalidade está em um conjunto chamado EnvDTE80 (EnvDTE versão 8.0). Mais funções atualizadas no EnvDTE80 manter os mesmos nomes que versões anteriores mas acrescentar o número 2 ao nome da função. Por exemplo, a nova versão da coleção TaskItems é denominada TaskItems2, e a nova versão do objeto Solution é chamada Solution2. Como os novos membros são mais robusta que versões anteriores e contêm a funcionalidade mais recente, a abordagem recomendada é para usar os novos objetos e coleções ao escrever novos aplicativos de automação. Para obter uma lista completa dos novos objetos e coleções, consulte Novos membros de automação para Visual Studio 2005.

Embora novos itens sejam no EnvDTE80, a maior parte da funcionalidade de automação do principal é ainda em EnvDTE. Assim, quando você escrever novos aplicativos de Automação (como os suplementos), certifique-se referência ambos EnvDTE e EnvDTE80. Para fazer isso em uma etapa fazendo referência a biblioteca COM. " Ambiente de desenvolvimento Microsoft 8.0 ". Além disso, se você usar membros do conjunto EnvDTE, precisará também definir uma referência ao tanto o DTE objeto e o DTE2 objeto. Isso fornece acesso a todos os itens.

Para obter informações sobre ganhar acesso aos modelos de objeto específicos projeto-, consulte Funcional grupos de automação.

Visual Studio 376

Nesta seção Como adicionar referências a EnvDTE e Namespaces EnvDTE80:

Demonstra como adicionar referências para os espaços para nome apropriado.

Erro usando EnvDTE com conjuntos VSLangProj

Descreve um possível erro você pode receber quando um projeto usa o EnvDTE conjunto e uma ou mais dos VSLangProj conjuntos.

Como obter referências a do DTE e objetos DTE2:

Demonstra como obter referências aos objetos apropriados.

Anexar a instâncias específicas do IDE

Fornece informações sobre como fazer referência uma instância específica de (IDE) o ambiente de desenvolvimento integrado.

Seções relacionadas Gráfico do modelo de objeto de automação

Fornece um mapa gráfico a todos os componentes compartilhados do modelo de objeto de automação.

Criando Add-ins e assistentes

Fornece informações básicas sobre como criar suplementos e assistentes no Visual Studio.

Controlar projetos e soluções O Visual Studio modelo de automação fornece objetos e coleções que permitem que você para controlar a solução, projetos, e os itens de projeto dentro do projeto, independentemente da linguagem de programação na qual o aplicativo foi escrito.

Este núcleo, modelo de automação projeto agnostic idioma, além de cada idioma programação possui seu próprio modelo de automação do projeto que fornece acesso a recursos exclusivos para esse idioma.

Objetos e coleções • O Solution2 objeto e a Projects coleção e Projects. () contenha, uma

referência para a solução, bem como referências a todos os projetos nessa solução, respectivamente que é retornado pelo Projects

• A ProjectItems coleção representa todos os itens contidos em um projeto (Project. com exceção dos projetos virtuais), O ProjectItem objeto representa itens individuais dentro do projeto.

Um projeto virtual é uma que não está associado a um projeto específico mas está associado a solução em vez disso. Uma solução pode conter dois projetos virtuais adicionais: a itens solução e os projetos Miscellaneous arquivos.


Controlando a solução, e projetos na solução.

Controlar a solução e seus projetos

Como programaticamente criar solução e projeto configurações de

Como criar soluções e configurações construir Project:

Visual Studio 377

compilação.

Lidando com projetos que não oferecerem suporte o Visual Studio modelo de automação.

Unmodeled Overview de projetos

Trabalhando com os projetos — virtuais itens Solution e itens Miscellaneous projetos.

Trabalhar com itens Solution e itens Miscellaneous

Salvando solução e projeto variável valores entre sessões IDE (ambiente) de desenvolvimento integrado.

Persisting informações nos projetos e soluções

Manipular Solution Explorer.

HOW TO: controle Solution Explorer

Controlando Visual Basic, Visual C#,. e Visual J# projetos

Introdução à extensibilidade de projeto

Controle Visual C++ Projetos.

e Microsoft.VisualStudio.VCProjectMicrosoft.VisualStudio.VCProjectEngine.

Criando e Controlling ambiente Windows O Visual Studio IDE (ambiente de desenvolvimento integrado) é composto de várias janelas de ferramentas. Uma janela ferramenta é uma janela criado por Visual Studio, ou um que pode ser manipulado pelo Visual Studio Automação. O Visual Studio modelo de automação permite que você se manipular suas janelas e em muitos casos, seu conteúdo. Por exemplo, a janela ferramentas é representada pelo objeto ToolBox,, bem como a ToolBoxTabs. e ToolBoxItems Coleções Você pode usar seus membros para adicionar e remover guias e itens ferramentas. Você também pode criar suas próprias janelas de ferramentas para atender seu conteúdo personalizado.

Enquanto algumas janelas ferramenta, como Solution Explorer e a Class View janela ferramenta, não faça têm recursos de automação explícitas, você pode manipular as janelas próprios ainda. é Solution Explorer uma janela ferramenta no IDE Visual Studio que exibe uma imagem de sua solução e seus projetos e seus itens de projeto físico, com base em arquivo. Como qualquer outra janela ferramenta no Visual Studio, você pode controlar seus parâmetros físicos, como tamanho, local, e se ele está ancorada ou Free-floating. é Class View uma janela que exibe os símbolos ferramenta definido, referenciado ou chamado no aplicativo que esteja desenvolvendo. Para informações, consulte Como alterar características da janela:.


Alterar as características físicas de uma janela ferramenta, como sua altura, largura, e assim por diante.

Como alterar características da janela:

Manipular código fonte e texto no editor do código. Como controlar o editor de código (Visual Basic):

Visual Studio 378

Automatizar operações de pesquisa e substituição no Editor do código.

Como pesquisar e substituir automatizar texto:

Manipular Solution Explorer e seu conteúdo. HOW TO: controle Solution Explorer

Usando o Visual Studio modelo de código para descobrir código.

Descobrir Código com o modelo de código (Visual Basic)

Manipular a Output janela e seu conteúdo. Como controlar a janela de saída:

Alterar as configurações na caixa Options de diálogo no menu Tools.

Controlar configurações opções ferramentas

Do Toolbox manipular e seu conteúdo. Como controlar a caixa de ferramentas:

Do Task List manipular e seu conteúdo. Como controlar a lista de tarefas:

Manipular a Command janela e seu conteúdo. Como controlar a janela de comando:

Manipulação da Dynamic Help janela e afetar atributos. Como controlar a janela da Ajuda dinâmico:

Manipular a gravação de macros a partir de um suplemento. Como usar Add-ins para macros de controle:

Controlando modos de exibição de árvore em janelas de ferramentas usando o UIHierarchy objeto.

HOW TO: Manipulate modos de exibição da árvore usando UIHierarchy

Criar e manipular janelas de ferramentas. Como ferramenta Windows criar e controlar:

Como criar e anexar a outra instância do Visual Studio: Em alguns casos é útil para criar uma nova instância de Visual Studio forma programática ou anexar a uma instância específica de Visual Studio que já está sendo executado. Se duas instâncias da Visual Studio estiver executando em um sistema e ter a mesma solução abrir — por exemplo, uma instância está executando uma compilação de solução e o outro é executar uma compilação — de depuração você pode programar o suplemento para diferenciá-las.

Você pode, por exemplo:

• Iniciar uma ocorrência Visual Studio com base em um caminho para um arquivo ou solução.

• Anexar a uma instância Visual Studio com base em um caminho para um arquivo ou solução.

• Carregar um arquivo ou solução em uma instância existente do Visual Studio.

• Criar uma nova instância de Visual Studio onde a instância desligado quando:

o A contagem de referência externa em ambos o DTE objeto e o Solution objeto são 0.

e- o O ambiente de desenvolvimento integrado (IDE) não é exibida para

o usuário ou não está sob controle de usuário.

• Criar uma nova instância de Visual Studio onde a instância permanece carregada mesmo quando:

Visual Studio 379

o A contagem de referência externa em ambos o DTE objeto e o Solution objeto são 0.

o O IDE será exibido para o usuário.

e- o O IDE está sob controle de usuário.

Os objetos retornados podem ser convertidos em seus objetos respectivos, tais como DTE2 e Solution2.

Observação

As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help (Ajuda) dependendo das configurações ativas ou edição. Esses procedimentos foram desenvolvidos com as configurações Development geral ativo. Para alterar as configurações, escolha Import e Export Settings no menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Exemplo Para criar uma nova instância do Visual Studio, use um ou System.Activator.CreateInstance. o Função CreateObject (Visual Basic) Ao usar a CreateObject função no Visual Basic, você pode passar valores de um "VisualStudio.DTE.8.0" ou "VisualStudio.Solution.8.0." os exemplos abaixo ilustrar esses métodos três.

C# // Create a new instance of Visual Studio by using // GetTypeFromProgID and CreateInstance. private void CreateNewInstance1() { System.Type type = System.Type.GetTypeFromProgID ("VisualStudio.DTE.8.0"); Object obj = System.Activator.CreateInstance(type, true); EnvDTE80.DTE2 dte8Obj = (EnvDTE80.DTE2)obj; }

No exemplo Visual Basic, ambas as instruções criar uma nova instância de IDE Visual Studio. A primeira instrução diretamente cria uma nova instância enquanto a segunda instrução cria uma nova instância, criando uma nova solução.

Para obter uma referência a uma instância existente do IDE Visual Studio, você pode usar o Função GetObject (Visual Basic). Você pode siga um destes procedimentos:

Visual Basic Private Sub GetInstance1 () Dim inst As Object Dim dte80Obj As EnvDTE80.DTE2 inst = Microsoft.VisualBasic.Interaction.GetObject(, _ "VisualStudio.DTE.8.0") dte80Obj = CType(inst, EnvDTE80.DTE2) MsgBox(dte80Obj.DisplayMode.ToString) End Sub ' -or- Dim inst As Object inst = Microsoft.VisualBasic.Interaction.GetObject(, _ "VisualStudio.Solution.8.0") ' --------------------------- ' -or- ' Change the path to your application. Dim inst As Object inst = Microsoft.VisualBasic.Interaction.GetObject _

Visual Studio 380

("C:\Projects\WindowsApplication1\WindowsApplication1.sln") ' --------------------------- ' -or- ' Change the path to your application. Dim inst As Object inst = Microsoft.VisualBasic.Interaction.GetObject _ ("C:\Projects\WindowsApplication1\WindowsApplication1.sln", _ "VisualStudio.Solution.8.0")

Estendendo o ambiente Visual Studio Embora Visual Studio você talvez precise um nível de controle adicionais ou maiores. oferece várias ferramentas e a energia para executar quase cada tarefa, Por exemplo, convém automatizar uma tarefa ou uma série de tarefas que você executar regularmente. Ou você pode ter criado ferramentas que você deseja usar no ambiente Visual Studio de desenvolvimento integrado (IDE).

Para resolver esses problemas, Visual Studio Rich modelos de programação conhecidos como os modelos de objeto de automação, para estender e automatizar o IDE recursos. Os modelos automação vários fornecem a capacidade para automatizar o ambiente e fornecer extensões e novos recursos a ela. Cada modelo concentrates a uma área específica do IDE, como as janelas ferramenta, o editor de código, vários projetos, e assim por diante.

As seções abaixo apresentar a você para automação e extensibilidade e mostram como usá-los para facilitar a programação.

Nesta seção O que há de novo no extensibilidade e automação do Visual Studio 2005

Descreve as atualizações e melhorias de extensibilidade e automação os modelos em Visual Studio 2005 Vários.

Novos membros de automação para Visual Studio 2005

Lista os novos tipos específicos e membros em Visual Studio 2005 Destaque.

Práticas recomendadas para segurança na automação

Fornece conselhos para ajudar você segura Visual Studio e os aplicativos de automação.

O espectro de automação Visual Studio

Descreve os tipos de projetos de automação disponíveis para você em Visual Studio: macros, add-ins e assistentes e VSIP.

Escolhendo a abordagem de automação adequada

Ajuda você a escolher as ferramentas mais eficientes para usar para realizar suas tarefas de automação.

Funcional grupos de automação

Lista as diversas áreas de Visual Studio que pode ser automatizada.

Acessando o modelo de automação por usando macros

Ilustra como programa contra os diversos modelos de automação usando macros.

Criando Add-ins e assistentes

Descreve os conceitos de automação e extensibilidade,, bem como os fundamentos de como criar suplementos e assistentes.

Referência conjuntos de automação e o objeto DTE2

http://msdnwiki.microsoft.com/pt-br/mtpswiki/67k1hky6(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/4ac9ya6b(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/9b54865a(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/6aa952xb(VS.80).aspx


http://msdnwiki.microsoft.com/pt-br/mtpswiki/5abkeks7(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/t6d9sf9k(VS.80).aspx

Visual Studio 381

Fornece detalhes sobre como usar as ferramentas fundamentos de automação.

Controlar projetos e soluções

Ilustra como controlar projetos e soluções usando Visual Studio objetos de automação, como salvar variáveis entre sessões IDE; como para trabalhar com itens de solução, diversos itens, e unmodeled projetos; e como criar configurações de solução.

Criando e Controlling ambiente Windows

Explica como criar e controlar janelas de ferramentas, alterar características janela, automatizar pesquisa de texto e substituir, controlar macros, controlar configurações opções ferramentas, descobrir Código com o modelo de código, e manipular modos de exibição de árvore, usando UIHierarchy.

Como criar e anexar a outra instância do Visual Studio:

Explica como criar uma nova instância do Visual Studio ou anexar a um arquivo existente.

Respondendo a eventos de automação

Demonstra como usar o Visual Studio modelo de automação para manipular eventos que ocorrem no ambiente.

Como Adicionar e identificador comandos:

Explica como criar e manipular comandos em Visual Studio Menus ou barras de ferramentas usando o Visual Studio modelo de automação.

Criando DLLs satélite Managed Walkthrough:

Fornece informações sobre como criar satélite DLLs, que pode conter recursos para uso em seus aplicativos de automação.

Implementar e usando Extenders de automação

Explica como adicionar e filtrar propriedades em objetos usando Extenders Automação.


Personalizar o ambiente de desenvolvimento

Demonstra como personalizar barras de ferramentas, teclas de atalho, e outros Visual Studio itens.

Automatizar ações Repetitive usando macros

Explica como criar e usar macros para automatizar ações no Visual Studio.

Macros do Visual Studio Uma macro é uma série de comandos e instruções que você agrupa como um único comando para realizar uma tarefa automaticamente. Macros permite que sejam automatizar ações repetitivas. Inclui Visual Studio o ambiente de desenvolvimento integrado macros (IDE), que é usado somente para criar, manipular, editar, e execute macros. O IDE de Macros é separado do IDE Visual Studio.

Nesta seção

Como gravar macros:

Descreve como criar e gravar macros.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/y849h0w1(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/keet1583(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/envdte.uihierarchy(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/6cefss65(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/h5dyz5be(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/90855k9f(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/e9zazcx5(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/0y92k2w2(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/hthab0h8(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/8h31zbch(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/7kyhdt1z(VS.80).aspx

Visual Studio 382

HOW TO: executar macros

Aborda várias maneiras de executar macros e passar parâmetros.

Gravação de Macro e executando questões

Oferece soluções para problemas normalmente encontrados na gravação e execução macros.

Como gerenciar macros:

Descreve como editar uma macro existente ou criar um novo arquivo manualmente.

Depurar macros

Descreve o que fazer quando ocorrem erros em suas macros.

Como gerenciar macros:

Descreve o Explorer macros e seus menus de contexto.

Salvar e exportando arquivos macros

Descreve como salvar e exportar arquivos macro no IDE de Macros.

Diferenças funcionalidade entre Macros do Visual Studio e Visual Studio

Descreve diferenças no modelo de extensibilidade, Document objeto, propriedades, operação item, o Find método, projetos, e Ferramentas Opções entre Visual Studio macros e Visual Studio.

Como referência com e componentes .NET Framework em macros:

Descreve como habilitar Visual Studio macros para referência componentes COM usando o utilitário TLBIMP.

HOW TO: identificador eventos de ambiente em macros

Discute o modelo EnvironmentEvents, o OnMacrosRuntimeReset evento e o OnStartupComplete evento.

Segurança macros e compartilhamento questões

Aborda as questões de segurança principal sobre macros: Proteção de propriedade intelectual, e prevenção de vírus e proteção.

Exemplos macros

Lista e descreve as macros amostras incluídas Visual Studio.


Automatizar ações Repetitive usando macros

Fornece uma visão geral sobre como usar macros para automatizar procedimentos ou seqüências repetidas de pressionamentos de teclas.

Ambiente de Desenvolvimento macros

Descreve todas as caixas de diálogo do IDE de Macros.

Macros

Fornece detalhes sobre o Macros objeto, que representa o Visual Studio Gravador de macro.

Mensagens de erro Macros do Visual Studio

Lista todas as mensagens de erro associadas a Visual Studio macros.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/a0003t62(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/bxk3af4y(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/hdf2d1z8(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/h9b001cb(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/hdf2d1z8(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/d5z86w25(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/hwastsaw(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/345xe6tb(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/0b27f9kz(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/cbyka18h(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/s2shw615(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/8h31zbch(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/fb30sxt3(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/envdte.macros(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/xx9w2f83(VS.80).aspx

Visual Studio 383

Como usar Add-ins para macros de controle:

Descreve como usar objeto o Visual Studio do modelo Macros de automação para macros de controle sendo registradas no IDE, incluindo pausar e reativar o gravador, escrever código para a macro sendo gravadas, e determinar se o gravador está funcionando no momento.

Consulte também

Introdução à extensibilidade de projeto O modelo de objeto está disponível simplesmente, adicionando uma referência para os conjuntos VSLangProj.dll, VSLangProj2.dll e VSLangProj80.dll a qualquer projeto. Para obter mais informações, consulte COMO: Adicionar ou remover referências no Visual Studio.Isso significa que o modelo de objeto está disponível para Macros, suplementos, e qualquer tipo de projeto que precisa para estender ou automatizar o IDE. Macros são gravadas no ambiente de desenvolvimento integrado macros usando Visual Basic. Do Visual Basic nos tópicos Os exemplos são gravados em e Visual C# idiomas. Para obter mais informações sobre como executar os exemplos, consulte Como compilar e executar objeto automação os exemplos código do modelo:. Add-ins pode ser gravados em qualquer um dos idiomas .NET,, Visual C++ incluindo Visual C#Visual Basic. e Visual J# Os tópicos de referência para e VSLangProj80 membros incluir a sintaxe para cada um desses idiomas. o VSLangProj, VSLangProj2 Para obter uma descrição dos tipos do projeto de automação e recursos de automação, consulte Criando Add-ins e assistentes.

VSLangProj, VSLangProj2 e Namespaces VSLangProj80 Esses espaços para nome contém todos os as classes, interfaces, e enumerações para Visual Basic, Visual C# e Visual J# projetos. Para obter uma lista completa dos objetos no espaço para nome, consulte Modelo de Objeto de Extensibilidade para projetos Visual Basic, Visual C# e Visual J#.

Possível erro usar conjuntos VSLangProj com assembly EnvDTE

Ocasionalmente se você criar um projeto que referencia um ou mais dos conjuntos VSLangProj e o EnvDTE conjunto, você pode obter o seguinte erro em tempo de execução:

": ": Unhandled Exception System.IO.FileNotFoundException Erro ao carregar arquivo EnvDTE, versão ' = 7.0.3300.0

Esse erro é devido a um conflito de resolução tipo Runtime. Ou seja, a versão do EnvDTE que é incluída no Visual Studio 2005 é 8.0.xx, mas referência de configuração do projeto está procurando por uma versão anterior desse conjunto, 7.0.xx versão. Para corrigir esse problema, você deve adicionar um redirecionamento de ligação para a versão mais recente EnvDTE ao arquivo de configuração (.config) do seu projeto. Isso permitirá Visual Studio para carregar a versão mais recente do EnvDTE e evitar que o erro ocorra.

Para fazer isso, adicione um " arquivo de configuração de aplicativos " ao seu projeto e substituí seu conteúdo pelo seguinte: <?xml version="1.0" encoding="utf-8" ?> <configuration> <runtime> <assemblyBinding xmlns="urn:schemas-microsoft- com:asm.v1" appliesTo="v2.0.50318"> <dependentAssembly> <assemblyIdentity name="EnvDTE" publicKeyToken= "b03f5f7f11d50a3a"/> <bindingRedirect oldVersion="7.0.3300.0"

http://msdnwiki.microsoft.com/pt-br/mtpswiki/1xw5w769(VS.80).aspx

Visual Studio 384

newVersion="8.0.0.0"/> </dependentAssembly> </assemblyBinding> </runtime> </configuration> Objeto VSProject2 Este objeto fornece acesso a outros objetos no modelo de extensibilidade. O objeto DTE é o objeto de nível superior no modelo Visual Studio de automação. No modelo de extensibilidade geral, um projeto é representado pelo objeto genérico Project. O Project objeto tem uma Object propriedade. O tipo da propriedade é determinado em tempo de execução pelo idioma do projeto. Na ou Visual J# projeto, a Object propriedade retorna um objeto do tipo VSProject2. a Visual Basic, Visual C# Como o tipo da propriedade Object é objeto, você deve convertido a referência ao digitar VSProject2. Em uma macro, a conversão seria como o seguinte se o primeiro projeto foram um Visual Basic projeto:

C# using EnvDTE; using EnvDTE80; using VSLangProj; using VSLangProj2; using VSLangProj80; EnvDTE.Project proj; VSLangProj80.VSproject2 vsproject; proj = DTE2.Solution.Projects.Item(1); vsproject = (VSLangProj80.VSProject2)proj;

Depois que você tiver uma referência para o VSProject2 item, você pode manipular do projeto Propriedades, configurações, arquivos, pastas, instruções importações, e referências.

Para obter mais informações, consulte Introdução ao objeto VSProject2.

Referências e objetos de referência A References propriedade, contida pelo objeto VSProject2, contém uma coleção de Reference3 objetos. O Reference3 objeto representa uma referência de projeto e é principalmente um objeto somente leitura que ofereça suporte um Remove método. O References objeto tem suporte para adicionar referências (. conjuntos .NET, outros projetos ActiveX,) e aumentando eventos (adicionando, removendo, e alterar referências) com,

O References objeto não contém as referências de um projeto da Web. Referências de um projeto da Web podem ser recuperadas por acessar a ProjectItems Propriedade da propriedade WebReferencesFolder.

Para obter mais informações e exemplos de código, consulte Reference e Reference3 objeto, References Coleção, References propriedade, e WebReferencesFolder propriedade.

Objeto importações

A Imports propriedade contida pelo objeto VSProject2 mantém uma coleção de Imports declarações que se aplicam a um projeto inteiro Visual Basic. Se uma instrução importações for adicionada a essa coleção, a instrução correspondente Imports (por exemplo, Imports VSLangProj) não precisa a ser adicionado ao arquivo de código. Este objeto suporta adicionando e removendo instruções importações e elevar eventos em resposta a adição e remoção instruções. Não há nenhum equivalente em um Visual C# projeto, e a VSLangProj80.VSProject2.Imports retorna Nothing propriedade ou null quando aplicado a um Visual C# projeto Para obter mais informações, consulte Imports.

Visual Studio 385

VSProjectItem e objetos BuildManager O VSProjectItem objeto é a contraparte item de projeto do objeto VSProject2. No modelo de extensibilidade geral, o objeto genérico ProjectItem representa um item de projeto. A Object propriedade é do tipo OBJECT, e em ou Visual C# projeto, o tipo da propriedade é VSProjectItem. um Visual Basic Projetando o objeto digite VSProjectItem teria esta aparência em uma macro:

C# using EnvDTE; using EnvDTE80; using VSLangProj; using VSLangProj2; using VSLangProj80; EnvDTE.Project proj; VSLangProj.VSProjectItem pi; Pi = (VSProject2)DTE2.Solution.Projects.Item(1).ProjectItems.Item(1). Object;

O VSProjectItem objeto contém propriedades que vincular ao item de projeto pai e projeto, e um método que força a execução de uma ferramenta personalizada nesse item. O BuildManager objeto trata saída ferramenta personalizada. Para obter mais informações, consulte RunCustomTool, VSProjectItem método, Introdução ao objeto BuildManager Objeto, e BuildManager Objeto.

Propriedade Properties Modelo de extensibilidade geral tem uma Properties propriedade em três objetos:

• Objeto Project As propriedades nesse objeto são equivalentes às propriedades encontradas na guia Common Properties da caixa de diálogo Property Pages no IDE do projeto.

• Objeto Configuration As propriedades nesse objeto são equivalentes às propriedades encontradas na guia Configuration Properties da caixa de diálogo Property Pages no IDE do projeto.

• Objeto ProjectItem As propriedades nesse objeto são equivalentes às propriedades encontradas na janela Properties quando um item de projeto está selecionado no Solution Explorer.

• Em cada caso a Properties propriedade é uma coleção de objetos do tipo Propriedade. Um Property objeto pode ser obtido a partir da coleção, especificando o da propriedade índice baseado em 1 ou seu nome. O conteúdo da coleção dependem do idioma. No caso de itens de projeto, o conteúdo também dependem das se o item é um arquivo ou uma pasta.

Modelo de Objeto de Extensibilidade para projetos Visual Basic, Visual C# e Visual J# Esses objetos, propriedades, métodos, e eventos são usados para automatizar tarefas no ambiente de desenvolvimento, criar novos tipos de projeto, e criar novo projeto tipos de item.

Nesta seção

Gráfico hierarquia VSLangProj (VSLangProj2 e VSLangProj80)

Ilustra as relações de objetos no espaço para nome VSLangProj.

Namespace VSLangProj (VSLangProj2 e VSLangProj80)

http://msdnwiki.microsoft.com/pt-br/mtpswiki/kabfb7a2(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/5ct3fxd1(VS.80).aspx

Visual Studio 386

Descreve espaço para nome contendo extensões do espaço para nome VSLangProj.

Visual Basic, Visual C# e exemplos de extensibilidade Project J# Visual

Fornece links para tópicos contendo exemplos Programação de extensibilidade.


Referência de automação e extensibilidade

Contém idioma tópicos de referência para o modelo de automação do ambiente de desenvolvimento integrado (IDE), incluindo depuração.

Introdução ao Extensibilidade do Projeto no Visual Basic e Visual C#

Descreve como controlar Visual Basic e Visual C# projetos e soluções usando seus objetos de automação.

Modelo de Objeto de Extensibilidade do Visual C++ Esta seção da documentação Visual C++ aborda quatro modelos de objeto que compõem o Visual C++ modelo de objeto extensibilidade.

O Visual C++ modelo de objeto extensibilidade é um conjunto de objetos COM, interfaces, e associados wrappers gerenciados que podem ser usados com qualquer linguagem compatível com ou o .NET Framework para automatizar ações que ocorrem no ambiente Visual Studio de desenvolvimento integrado (IDE).

Cada modelo inclui objetos que representa partes de um Visual C++ projeto predefinidos. Objetos podem ser manipulados com Visual C++ ou com outros idiomas suporte por Visual C++, tais como Visual C#. Propriedades podem ser lidas e conjunto, podem ser chamados, métodos e eventos podem ser tratados em qualquer linguagem compatível com o .NET Framework com ou. Cada modelo pode ser manipulado com Visual Basic macros ou através da Properties janela.

Nesta seção

Visual modelo código C++

Explica como manipular internos elementos, tais como uma classe definida ou função dentro de um Visual C++ projeto.

Modelo do Project C++ Visual

Explica o modelo que regula projetos e cria.

Visual modelo Assistente C++

Explica como oferecem suporte a Automação para assistentes de design.


Referência de automação e extensibilidade

Inclui informações de referência para os modelos de extensibilidade.

Automação e extensibilidade do Visual Studio

Bem-vindo ao Assistente suplemento, Assistente para Adicionar-in Visual Studio

Este painel apresenta ao assistente add-in. Para iniciar o assistente add-in, abra a New Project caixa, expanda Other Project Types, clique em Extensibility e clique duas vezes em qualquer Visual Studio Add-in ou Shared Add-in no painel

http://msdnwiki.microsoft.com/pt-br/mtpswiki/bbszzax7(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/1xt0ezx9(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/4eeya3de(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/t41260xs(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/2eydyk57(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/c2a19k26(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/1xt0ezx9(VS.80).aspx

Visual Studio 387

Templates. O assistente suplemento cria uma estrutura básica add-in que você pode complementar posteriormente. Para obter mais informações, consulte Criando Add-ins e assistentes.

Framework Back

Move para a página anterior do assistente do suplemento ou para a New Project caixa de diálogo se o foco estiver na primeira página.

Next

Mover para a próxima página do Assistente do suplemento.

Cancel

Cancelar o Assistente para Adicionar-in e a criação do suplemento.

Consulte também Tarefas Referência de automação e extensibilidade Os tópicos a seguir se relacionam ao automação e extensibilidade no Visual Studio para componentes compartilhados e específicos do idioma.

Nesta seção

EnvDTE

Os tipos e membros relacionadas à automação, extensibilidade, e a depuração para todos os Visual Studio idiomas.

EnvDTE80

Os tipos e membros, novo para Visual Studio 2005, relacionados ao automação, extensibilidade, e a depuração para todos os Visual Studio idiomas.

Extensibility

Contém a IDTExtensibility2 interface que hospedam métodos que manipulam eventos add-in.

VSLangProj

Tipos e membros que se relacionam com Visual Basic, Visual C# e Visual J# projeto de automação.

VSLangProj2

Tipos e membros que se relacionam com Visual Basic, Visual C# e Visual J# projeto de automação.

VSLangProj80

Tipos e membros, Novo, para Visual Studio 2005 que se relacionam com Visual Basic, Visual C# e Visual J# Projeto Automação.

VCCodeModel

Os tipos e membros relacionados ao Visual C++ código de automação. Inclui tipos e membros novos no Visual Studio 2005.

VCProject

Os tipos e membros relacionados ao Visual C++ projeto Automação. Inclui tipos e membros novos no Visual Studio 2005.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/envdte(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/0e105c68(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/extensibility(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/extensibility.idtextensibility2(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/vslangproj(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/vslangproj2(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/vslangproj80(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/microsoft.visualstudio.vccodemodel.vccodemodel(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/microsoft.visualstudio.vcprojectengine.vcproject(VS.80).aspx

Visual Studio 388

VCProjectEngine

Os tipos e membros relacionados ao Visual C++ projeto Automação. Inclui tipos e membros novos no Visual Studio 2005.

VsWizard

Os tipos e membros relacionadas à Visual C++ automação Assistente. Inclui tipos e membros novos no Visual Studio 2005.

Modelo de Objeto de Extensibilidade do Visual C++

Lista todos os objetos, coleções, interfaces, propriedades, métodos, eventos, e constantes relacionadas às montagens vários Visual C++.

http://msdnwiki.microsoft.com/pt-br/mtpswiki/microsoft.visualstudio.vcprojectengine.vcprojectengine(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/microsoft.visualstudio.vswizard.vswizard(VS.80).aspx

http://msdnwiki.microsoft.com/pt-br/mtpswiki/174179de(VS.80).aspx

Visual Studio 389

Visual Studio Comandos e opções

Visual comandos Studio permitem direta interação com o ambiente de desenvolvimento integrado por meio do teclado (IDE). Muitas caixas de diálogo, janelas, e comandos de menu no IDE têm um equivalente de linha de comando que você pode digitar na Janela de Comando, a Janela Immediate, ou o Localizar / comando caixa para exibir uma caixa de diálogo ou executar um comando.

Visual Studio comandos seguem determinadas regras sintaxe geral que são explicadas abaixo. O conjunto de comandos disponíveis inclui todos os comandos listados na Keyboard, Environment, Options Dialog Box e no, os Comandos guia, Personalizar caixa de diálogo Visual Studio () Aliases definidos pelo usuário, bem como e macros.

Criando a partir da linha de comando

Para obter informações sobre criação projetos no Visual Studio linguagens de programação a partir da linha de comando, e Criando a partir da linha de comando. Consulte Compilando a partir da linha de comando (Visual Basic), Criando de linha de comando visual (C#), Opções VCBUILD Visual C++ (,) Para obter informações sobre como configurar um arquivo de esquema XML MSBuild para criar projetos, consulte o Referência MSBuild.

Sintaxe comando Visual Studio

Visual comandos Studio podem ser inseridos na janela, Immedia janela te, ou CommandFind/Command na caixa. Em cada caso, o sinal maior. (>) é usado para indicar que um comando em vez de uma operação de pesquisa ou de depuração é a seguir

Para obter informações sobre a sintaxe de comando, consulte Visual Studio comandos com argumentos e Opções de linha de comando Devenv.

Muitos comandos podem ser gravados em um dos dois formatos, usando a sintaxe de comando completa, uma menor Formulário ou alias.

Nomes de comandos concluída

A sintaxe completa para comandos é baseada em caixa de diálogo listados Keyboard, Environment Options nome comando completo. Na maioria dos casos, a sintaxe completa reflete a colocação de comandos no sistema menu IDE. Concluir comando nomes compatíveis com as regras de sintaxe a seguir:

• Categorias de comando, como menus, e nomes de comandos são separadas por um ponto (.).

• Espaços e pontuação são removidos de todos os nomes de comando conforme exibido na barra de menus.

Por exemplo, o comando que exibe aparece Keyboard, Environment Options como um filho do comando File. o Nova caixa de diálogo do arquivo Para exibir esta caixa de diálogo, digite o seguinte comando na janela, Immedia janela te, ou CommandFind/Command caixa e pressione ENTER. >File.NewFile

A New File caixa de diálogo aparece, pronto para que você possa faça sua seleção.

Visual Studio 390

Aliases de comando

Você pode criar nomes curtos, ou aliases, para nomes comando completo para ajudá-lo a lembrar e digite os comandos mais rapidamente. O Visual Studio vem com um conjunto de aliases predefinidos. Por exemplo, o comando que exibe a New File caixa de diálogo tem o alias nf padrão. Para obter mais informações, consulte Predefinidas visual aliases de comando Studio.

Você também pode criar seus próprios aliases personalizados ou alterar aliases predefinidos, usando o alias comando. Por exemplo, você pode criar um alias para o comando Edit.MakeUpperCase digitando o seguinte: >alias upper Edit.MakeUpperCase

Na próxima vez em que você selecione texto no editor e inserir >upper na janela, Immedia janela te, ou CommandFind/Command caixa, o texto será exibido em letras maiúsculas. Você também pode criar aliases que incluem nomes de comandos e seus argumentos.

Para exibir uma lista de todos os aliases atuais, digite o seguinte comando na janela Command: >alias

Comandos com argumentos

Alguns comandos permitem que você para fornecer argumentos, tais como nomes de arquivo ou opções que executar um comando, sem exibir todas as caixas de diálogo ou outras interfaces de usuário. Por exemplo, o comando File.NewFile, digitado sem opções, exibe a New File caixa de diálogo. Você também pode criar um novo arquivo de um modelo, sem exibir a New File caixa de diálogo, incluindo a opção /t. O exemplo a seguir cria um novo arquivo de texto chamado MyText.txt, com base em modelo " Arquivo General\Text ", e abre-no Editor de Código fonte. >File.NewFile Mytext /t:"General\Text File" /e:"Source Code (text) Editor"

Observação

Argumentos comando devem ser inseridos na ordem especificada para o comando. Switches e seus argumentos podem ser colocados em qualquer ordem.

Comandos e argumentos compatíveis com a seguinte sintaxe:

• Comandos nomes e argumentos são separados por espaços

• Valores argumento que contenham espaços devem ser colocados entre aspas

• Use o circunflexo (^ caracteres para caracteres de escape)

• Abreviações argumento caractere único-podem ser combinadas. Por exemplo, você pode combinar as abreviações argumento único caractere para /case (/c. (/w) como /cw em vez de /c /w) e /word

Muitos switches nome comando têm nomes completo e curto que podem ser usados de forma intercambiável. Por exemplo, a /case opção de comando Edit.Find também pode ser gravada /c. Para obter uma lista completa, consulte Visual Studio comandos com argumentos.

Escape caracteres

Um caractere de interpolação (^) em uma linha de comando significa que o caractere imediatamente após ele é interpretada literalmente, em vez de como um

Visual Studio 391

caractere de controle. Isso pode ser usado para incorporar aspas normais ("), espaços, barras à esquerda, carets, ou quaisquer outros caracteres literais em um valor parâmetro ou opção, com exceção da opção nomes. Por exemplo, >Edit.Find ^^t /regex

Uma interpolação funciona da mesma se ele está dentro ou fora aspas. Se uma interpolação for o último caractere na linha, ele será ignorado.

Conclusão Automática para comandos

A Command janela, Immedia janela te, e Find/Command Caixa fornecem conclusão automática quando você insere nomes de comandos e aliases. A lista de conclusão automático exibe todos os possíveis correspondentes nomes de comandos e aliases, se o comando está disponível no momento ou não. Se você digitar ou selecionar um comando disponível, a barra de status exibe a mensagem, O comando " não está disponível " e o comando será ignorado.

Nomes de comandos internacionais

Em versões localizadas do IDE, nomes de comandos podem ser inseridos no idioma nativo do IDE ou no inglês. Por exemplo, você pode digitar no francês IDE para executar uma File.NewFile ou Fichier.NouveauFichier o mesmo comando.

Nomes de macro são semelhantes aos nomes de comandos. Embora você pode salvar macros usando um nome localizado, para melhor compatibilidade entre inglês e versões localizadas do Visual Studio, é melhor para salvar macros usando nomes em inglês. Isso ocorre porque todas as versões localizadas do IDE entender inglês comandos, mas nem todas as versões localizadas do IDE entende localizado um idioma diferente.

Janela de Comando A Command janela é usada para executar comandos ou aliases diretamente no ambiente Visual Studio de desenvolvimento integrado (IDE). Você pode executar os comandos de menu e comandos que não aparecem em qualquer menu. Para exibir a Command janela, escolha Other Windows No menu View, e selecione Command Window.

Esta seção explica os comandos e aliases disponíveis a partir da Command janela.

Predefinidas visual aliases de comando Studio

Contém uma lista do availabe aliases comando predefinidas com Visual Studio.

Visual Studio comandos com argumentos

Contém informações sobre os Visual Studio comandos que obtém argumentos.

Exibindo os valores de variáveis Para verificar o valor de uma variável varA, use o Comando Imprimir: >Debug.Print varA

O ponto de interrogação (?) é um alias para Debug.Print, para este comando também pode ser gravado: >? varA

As duas versões desse comando retornará o valor da variável varA.

Visual Studio 392

Inserir comandos O maior que Símbolo. aparece na extremidade esquerda da janela de comando como um prompt para novas linhas (>) Use as teclas SETA PARA CIMA e SETA PARA BAIXO para rolar pela comandos emitidos anteriormente.

Tarefa Solução Exemplo

Avaliar uma expressão. Preceda a expressão com um ponto de interrogação (?).

? myvar

Alterne para uma janela imediata. Inserir immed na janela sem o maior que (>) sinal

immed

Alternar novamente para a janela de comando a partir de uma janela imediata.

Inserir cmd na janela. >cmd

Os seguintes atalhos ajudam a navegar enquanto no modo de comando.

Ação Local do cursor KeyBinding

Alternar entre a lista de comandos inseridos anteriormente.

Linha de entrada Seta para baixo e para baixo

Rola para cima a janela. Conteúdo da janela de comando

CTRL+SETA PARA CIMA

Role para baixo a janela. Conteúdo da janela de comando

SETA ABAIXO ou CTRL+SETA PARA BAIXO

Dica

Você pode copiar todos ou parte de um comando anterior para a linha de entrada, rolagem a ele, realçando todo ou parte dele, e em seguida, pressionando ENTER.

Modo marcar Quando você clica em qualquer linha anterior na janela Command, no você alternar automaticamente no modo marcar. Isso permite que você para selecionar, editar e copiar texto de comandos anteriores à medida que você faria em qualquer editor de texto, e colá-los na linha atual.

O igual (=) sinal A janela utilizada para digitar o EvaluateStatement Comando determina se um sinal de igual (=) é interpretado como um operador de comparação ou como um operador de atribuição.

Na janela Command, um sinal de igual (=) é interpretado como um operador de comparação. Você não pode usar operadores de atribuição na janela Command. Caso, por exemplo, se os valores de variáveis varA e varB são diferente, e o comando >Debug.EvaluateStatement(varA=varB)

Visual Studio 393

Retornará um valor de False.

Na janela Immediate, por outro lado, um sinal de igual (=) é interpretado como um operador de atribuição. Portanto, por exemplo, o comando >Debug.EvaluateStatement(varA=varB)

irá atribuir a variável varA o valor da variável varB.

Parâmetros, opções, e valores Alguns Visual Studio comandos comandos tem necessárias e argumentos opcionais, alterna e valores. Certas regras se aplicam ao lidar com tais comandos. O seguinte é um exemplo de um comando Rich para esclarecer a terminologia. Edit.ReplaceInFiles /case /pattern:regex var[1-3]+ oldpar

Neste exemplo,

• é Edit.ReplaceInFiles o comando

• e /case/pattern:regex são opções (exibirá o caractere de barra [/])

• é regex o valor da opção /pattern; a /case opção não tem valor

• e var[1-3]+oldpar são parâmetros

Observação

Qualquer comando, parâmetro, opção, ou valor que contém espaços deve ter aspas duplas nos dois lados.

A posição do opções e parâmetros pode ser interchanged livremente na linha de comando com a exceção do comando Shell, que requer suas opções e parâmetros em uma ordem específica.

Quase cada opção suporte de um comando tem duas formas: Um formulário curto (um caractere) e uma forma longa. Várias opções de forma curta podem ser combinadas em um grupo. Por exemplo, /p /g /m pode ser expresso como alternativa como /pgm.

Se opções curta são combinados em um grupo e considerando um valor, esse valor se aplicará a cada opção. Por exemplo, /pgm:123 equivale a /p:123 /g:123 /m:123. Um erro ocorre se qualquer uma das opções no grupo não aceita um valor.

Escape caracteres Um caractere de interpolação (^) em uma linha de comando significa que o caractere imediatamente após ele é interpretada literalmente, em vez de como um caractere de controle. Isso pode ser usado para incorporar aspas normais ("), espaços, barras à esquerda, carets, ou quaisquer outros caracteres literais em um valor parâmetro ou opção, com exceção da opção nomes. Por exemplo, >Edit.Find ^^t /regex


Janela Immediate A Immediate janela é usada para depuração e avaliar expressões, execute instruções, imprimir variável valores, e assim por diante. Ele permite que você para

Visual Studio 394

inserir expressões para ser avaliada ou executados pelo idioma de desenvolvimento durante a depuração. Para exibir a Immediate janela, abra um projeto para edição, escolha Windows a partir do Debug Menu e selecione Immediate.

Você pode usar esta janela para emitir comandos individuais Visual Studio. Os comandos disponíveis incluem EvaluateStatement, que pode ser usada para atribuir valores a variáveis. A Immediate janela também suporta IntelliSense.

Esta seção contém informações sobre os comandos disponíveis a partir da Immediate janela.

Comandos da janela Imediata

Contém links para tópicos que descrevem os comandos disponíveis a partir da Immediate janela.

Exibindo os valores de variáveis Esta janela pode ser especialmente útil quando estiver depurando um aplicativo. Por exemplo, para verificar o valor de uma variável myVar, você pode usar o Comando Imprimir: >Debug.Print varA

O ponto de interrogação (?) é um alias para Debug.Print, para este comando também pode ser gravado: >? varA

As duas versões desse comando retornará o valor da variável varA.

Observação

Para emitir um Visual Studio Comando na janela Immediate, você deve preceda o comando com um maior sinal que (>). Para inserir vários comandos, alternar para a Command janela.

Inserir comandos Você deve digitar o maior que entrar (>) ao emitir Visual Studio comandos na janela Immediate. Use as teclas SETA PARA CIMA e SETA PARA BAIXO para rolar pela comandos emitidos anteriormente.

Tarefa Solução Exemplo

Avaliar uma expressão. Preceda a expressão com um ponto de interrogação (?).

? a+b

Temporariamente entrar no modo Comando enquanto no modo Immediate (para executar um único comando).

Digite o comando, prefacing-lo com um maior sinal que (>).

>alias

Alternar para a janela de comando. Inserir cmd na janela, prefacing-lo com um maior sinal que (>).

>cmd

Alternar de volta para a janela Imediata. Inserir immed na janela sem o maior que (>) sinal.

immed

Modo marcar

Visual Studio 395

Quando você clica em qualquer linha anterior na janela Immediate, no você alternar automaticamente no modo marcar. Isso permite que você para selecionar, editar e copiar texto de comandos anteriores à medida que você faria em qualquer editor de texto, e colá-los na linha atual.

O igual (=) sinal A janela utilizada para digitar o EvaluateStatement Comando determina se um sinal de igual (=) é interpretado como um operador de comparação ou como um operador de atribuição.

Na janela Immediate, um sinal de igual (=) é interpretado como um operador de atribuição. Portanto, por exemplo, o comando >Debug.EvaluateStatement(varA=varB)

irá atribuir a variável varA o valor da variável varB.

Na janela Command, por outro lado, um sinal de igual (=) é interpretado como um operador de comparação. Não use operações de atribuição na janela Command. Caso, por exemplo, se os valores de variáveis varA e varB são diferente, e o comando >Debug.EvaluateStatement(varA=varB)

Retornará um valor de False.

Localizar / comando caixa A Find/Command caixa permite que você a localizar e substituir texto, e para executar comandos. Para emitir comandos individuais Visual Studio, preceda-los com um caractere maior que (>).

A Find/Command caixa mantém os itens inseridos últimas 20 e exibe-os em uma lista drop-down. Você pode navegar através da lista usando as teclas SETA. A Find/Command caixa está localizada em ferramentas padrão na maioria dos Visual Studio 2005 idiomas de programação.

Localizar / comando caixa

Para ir para a Find/Command caixa, o clique com o mouse ou pressione CTRL + /.

Localizar e substituir Por padrão, quando você digitar texto na caixa Find/Command e pressione ENTER, ele procura o texto no documento atual ou janela usando as opções especificadas na pesquisa e substituição a Localizar e Substituir janela. Para obter mais informações, consulte Localizando e substituindo.

Você pode usar determinadas combinações de teclas com a caixa Localizar / comando.

Para Na caixa Comando

Localizar uma seqüência Digite a seqüência e pressione ENTER

Visual Studio 396

Localizar a próxima ocorrência da seqüência Pressione ENTER

Pesquisar a índice da Ajuda Digite a seqüência e pressione F1

Navegue até uma linha de código específica Digite o número da linha e pressione CTRL + G

Localizar um objeto Digite a seqüência e pressione F2

Ao procurar na caixa Find/Command, a janela Localizar resultados 1 aparecerá, exibindo as definições de pesquisa atual. Se, por exemplo, a última vez você pesquisados do Rápido Localizar, Localizar e Substituir janela, você selecionado a Match case opção, será exibida a Find Results 1 janela Find "mybutton", Match case, Current document

Inserir comandos Para usar a Find/Command caixa para emitir um único Visual Studio Comando ou alias em vez de procurar por texto, digite o Visual Studio comando, exibirá um símbolo maior que (>). Por exemplo: >File.NewFile c:\temp\MyFile /t:"General\Text File"

Como alternativa, você também pode usar a janela de comando para inserir e executar um ou vários comandos. Alguns comandos ou aliases podem ser inseridos e executados por si; outros ter necessário argumentos em sua sintaxe. Para obter uma lista de comandos, consulte Visual Studio Comandos e opções. Para obter uma lista de comandos que possuem argumentos, consulte Visual Studio comandos com argumentos.

Escape caracteres Um caractere de interpolação (^) em uma linha de comando significa que o caractere imediatamente após ele é interpretada literalmente, em vez de como um caractere de controle. Isso pode ser usado para incorporar aspas normais ("), espaços, barras à esquerda, carets, ou quaisquer outros caracteres literais em um valor parâmetro ou opção, com exceção da opção nomes. Por exemplo, >Edit.Find ^^t /regex


Consulte

Comandos guia, Personalizar caixa de diálogo Visual Studio () A Commands guia permite que você para adicionar e remover comandos nas barras de ferramentas, e alterar as imagens usadas para botões da barra de ferramentas. Selecione Customize no menu Tools para exibir a Customize caixa de diálogo e escolha Commands.

Observação

As opções disponíveis nas caixas de diálogo e os nomes e locais dos comandos de menu que você vê

Visual Studio 397

podem diferir do que é descrito na Ajuda, dependendo de suas configurações ativas ou da edição. Para alterar as configurações, escolha Import and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual Studio.

Categorias

Especifica o conjunto de comandos que são exibidos na caixa Commands de listagem. As categorias de comandos são baseadas em títulos menu fornecidos pela ferramentas e designers que o ambiente atualmente suporta. Esta lista de títulos é dinâmica, permitindo que a ordem das categorias e títulos menu para alterar, dependendo da quais ferramentas e designers estão disponíveis, e seus menus se tiver sido personalizados.

Observação

Não é possível para dois menus em designers diferentes para compartilhar o mesmo título. Em tais casos, o título menu aparecerá duas vezes, oferecendo dois conjuntos comando diferente.

Comandos

Exibe os comandos e imagens comando baseadas na categoria que você selecionou. Você pode arrastar um comando para a barra de ferramentas que você deseja personalizar.

Modificar seleção

Exibe uma lista de comandos você pode usar para personalizar a exibição do botão na barra de ferramentas. Por exemplo, poderá alterar as teclas Imagem ou acelerador, ou especificar se deseja exibir texto em vez de uma imagem para o comando. Este botão estará disponível depois que você selecionar um botão de comando em uma barra de ferramentas que deseja personalizar.

Reorganizar Comandos

Exibe a Rearrange Commands caixa de diálogo, para que você possa modificar menus.

Teclado

Exibe o teclado, Ambiente, caixa de diálogo Opções, para que você pode especificar combinações de teclas de atalho para comandos.