Apostila Visual Studio - PT-BR

Í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 1
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 2
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 3
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 4
Visual Studio 5
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 6
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 7
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 8
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 9
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 10
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 11
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 12
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 13
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 14
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 15
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

projeto a ser desacoplado.
Control.
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 16
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
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 17
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 18
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 19
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 20
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 21
Control.
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 22
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 23
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 24
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 25
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 26
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 Especifica que o item não se encontra sob controle de origem.

controlado
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 27
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 28
Caixa de diálogo Access
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 29
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 30
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 31
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 Especifica que o Visual Studio deve emitir um prompt para check-outs
checkouts 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 32
Recupera a versão mais recente de todos os itens quando você abre uma
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 Especifica que o Visual Studio deve fazer check-out automaticamente em uma
automatically operação de salvar.
Save as Especifica que o Visual Studio deve apresentar um prompt Save as em uma
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 33
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
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 34
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.

clique em Source Control e em seguida clique em Undo Checkout.
Observação
Solution Explorer.
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 35
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 36
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 37
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
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
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 38
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 39
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 Salvar um subconjunto ou todas as suas configurações existentes para

ambiente selecionada que você pode usar essas configurações em outro computador.
Importar configurações de Aplica as configurações em um arquivo você tiver recebido. Substitui

ambiente selecionada existentes configurações com os do arquivo importado.
Redefinir todas as Permite que você se reverter as configurações de volta para uma das
configurações 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 40
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
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.
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
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 41
Setting file name Digite um nome personalizado para as configurações atuais.
Store my settings file in Especifica o diretório padrão no qual as configurações atuais serão salvos.
this directory 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
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
• 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
Para obter mais informações sobre coleções configurações predefinidas,
Visual Studio 42
<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 43
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 44
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 45
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 46
<?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
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 47
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
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 48
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.

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 49
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 50
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
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 51
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
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
de implantação.

TempConvertClient1WebSetup, aponte para Add e depois clique em
Project Output.
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.
Implantar o aplicativo da Web, copiando o projeto
1. No Solution Explorer, selecione o projeto TempConvertClient1.
Visual Studio 52
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 53
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 54
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 55
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 56
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 57
• 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
Studio.
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
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
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 58
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
Studio.
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 59
// 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 60
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 61
Observação
Studio.
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.
• 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 62
{ 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 63
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 64
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
Studio.
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 65
A primeira etapa consiste em criar o projeto de aplicativo. Você usará este projeto
para criar o aplicativo que hospeda o controle personalizado.
• 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 66
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:
C#
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 67
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 68
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 69
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 70
void StopMarquee();
// This method specifies the refresh rate for the animation,
// in milliseconds.
int UpdatePeriod
{ get; set; } }

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 71
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 72
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
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 {
Visual Studio 73
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 74
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 75
// 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 76
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 77
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:
C#
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 78
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 79
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 80
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
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 81
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 82
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 83
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
Studio.
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 84
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 85
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 86
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 87
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
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 88
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 89
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 90
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 91
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.
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 92
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 93
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 94
// 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 95
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 96
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 97
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 98
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 99
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
Studio.
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 100

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 101

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 102

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 103

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.
Visual Studio 104

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.
seguir:
• 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 105

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 106

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 107

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 108

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.
Visual Studio 109

CMyDhtmlDlg dlg; dlg.DoModal( );

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 110

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.
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 111

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;

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 112

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 113

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 Uma introdução ao criar páginas da Web ASP.NET no
Web básica no Visual Web Developer Visual Studio.
Passo-a-passo: Acesso a dados básico em Uma introdução ao exibir dados em uma página da Web
páginas da Web usando os controles da fonte de dados e o GridView
controle.
Passo a passo: Ligação de dados em um Uma introdução ao criar um componente de camada

objeto corporativo personalizado intermediária que torna dados disponível para páginas da
Web.
Passo-a-passo: Depuração de Páginas da Uma introdução ao usar o depurador Visual Studio com
Web no Visual Web Developer páginas da Web.
Passo-a-passo: Criando e Usando Páginas Uma introdução ao usar páginas mestras ASP.NET para
Mestras do ASP.NET no Visual Web definir um layout geral para páginas da Web.
Developer
Passo-a-passo: Personalizando um site Uma introdução ao definir um aparência consistente para

usando temas no Visual Studio suas páginas da Web.
Passo-a-passo: Criando uma página do Uma introdução ao criar uma página da Web que usa Partes
Web Parts no Visual Web Developer 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 Uma introdução a adicionar segurança logon em um site da
associação e logon de usuário (Visual Web.
Studio)
Passo a passo: Criando e usando um Uma introdução ao criar um serviço da Web ASP.NET e
serviço da Web do ASP.NET no Visual consumindo-lo de uma página da Web.
Web Developer
Visual Studio 114

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 115

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 116

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 117

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 118

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 119

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 120

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 121

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 122

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 123

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 124

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.
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 125

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 126

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 127

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 128

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 129

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 130

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 131

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 132

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 133

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 134

5. Na lista Language, clique na linguagem de programação que você preferir
trabalhar.
6. Clique em OK.
Default.aspx.
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 135

<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 136

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 137

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 138

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 139

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 140

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 141

linguagens, consulte Compartilhada pastas código em sites da Web do
ASP.NET.
6. Clique em OK.
Default.aspx.
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 142

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 143

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 144

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 145

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 146

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 147

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 148

Default.aspx.
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
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 149

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 150

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 151

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 152

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 153

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 154

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
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 155

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 156

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 157

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 158

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.
Default.aspx.
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 159

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 160

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 161

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 162

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 163

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 164

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 165

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 166

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 167

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 168

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.

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 169

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 170

<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

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 171

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

Visual Studio 172

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 173

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 174

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 175

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
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 176

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 177

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 178

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.
Visual Studio 179

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
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 180

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 181

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
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 182

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.
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 183

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.
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 184

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

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 185

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.
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.
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 186

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 187

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 188

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 189

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 190

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 191

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 192

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 193

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

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 194

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 195

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 196

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.
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
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 197

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.
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 198

• Iniciar (com depuração)
• Iniciar sem depuração
• Modo de Exibição no navegador
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
e outras configurações. Para obter mais informações, consulte HOW TO: definir
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:.
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
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
Para interromper a execução do XML Web Services e retornar ao editor de

Visual Studio 199

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
Gerenciado.
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
de implantação.

TempConvert1WebSetup, aponte para Add, e clique Project Output.
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
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.
Para implantar o XML Web Services, copiando o projeto
1. No Solution Explorer, selecione o projeto TempConvert1.
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 200

5. Clique Copy Web Site para copiar o site.
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:
Visual Studio 201

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#.
seguir:
• Criar um serviço XML da Web usando o ASP.NET Web Service modelo de
projeto.
• Depurar o serviço da Web XML.
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++
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 202

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 203

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
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
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.
informações, consulte Preparação da Depuração: Web Services XML (C++).
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.
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 204

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.
Para interromper executando o serviço XML da Web e retornar ao editor de

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
de implantaçã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.
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 205

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.
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.
Visual C#
• 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 206

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.
seguir:
• Criar um serviço XML da Web usando o modelo do projeto Serviço da Web
Server ATL.
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
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 207

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 208

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
de implantação.
4. No painel esquerdo da File System Editor, selecione Web Application

Folder. Para obter mais informações, consulte Editor do sistema de arquivos.
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.
TempConvert4.pdb.
7. Clique em OK.
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.
TempConvert4Isapi.pdb.
10. Clique em OK.
Visual Studio 209

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
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.
Visual C#
• 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 210

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++.
seguir:
• 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 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

caixa de diálogo.
2. Expanda o Visual C++ nó, e selecione CLR.
3. Clique no CLR Console Application ícone.
4. Alterar o nome do projeto para TempConvertClient3.
Visual Studio 211

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.
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.
1. No Solution Explorer, localize TempConvertClient3.cpp na pasta Source
Files e abra este arquivo para edição.
Visual Studio 212

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.
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 213

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
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 214

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++.
seguir:
• 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 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

caixa de diálogo.
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 215

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.
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 216

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.
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 217

"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
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 218

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
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 219

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 220
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 221

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 222

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 223

[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 224

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 225

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 226

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 227

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 228

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 229

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 230

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 231

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 232

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 233
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 234

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 235

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 236

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

projeto a ser ligado.
Control.
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 237

Para desacoplar uma solução ou projeto do controle de origem
projeto a ser desacoplado.
Control.
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
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 238
8. Clique em OK.
Para desconectar uma solução ou projeto de controle de código fonte
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 239

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 240

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 241

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 242

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.
Control.
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 243

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 244

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 245

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 246

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 247

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.

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 248

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 Especifica que o item não se encontra sob controle de origem.

controlado
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.

clique em Source Control depois em Check In.
Visual Studio 249

Observação
Solution Explorer.
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

Source Control, depois clique em Check Out For Edit.
Visual Studio 250

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.

Source Control, depois em Get.
Visual Studio 251

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 252
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 253

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
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 Especifica que o Visual Studio deve emitir um prompt para check-outs
checkouts 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
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 254

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
Check out Especifica que o Visual Studio deve fazer check-out automaticamente em uma
automatically operação de salvar.
Save as Especifica que o Visual Studio deve apresentar um prompt Save as em uma
Configurações de ambiente controle de origem

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 255

solução ou projeto do controle de origem, desmarcar esta opção pode
melhorar o desempenho.
Configurações plug-in
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 256

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.

clique em Source Control e em seguida clique em Undo Checkout.
Observação
Solution Explorer.
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 257

Visual Studio 258
por diante.
máquina
individuais
Visual Studio.
selecionadas.
Visual Studio 259

páginas.
• Favoritos

Visual Studio 260


um colega na.
Observação
amarelo e preto.
Visual Studio 261

e clique em Next.
Observação

computadores.
Visual Studio 262

9. Clique em OK.


Opção Descrição


Export Settings.
Visual Studio 263

Observação
Nomeie O arquivo de configurações, importar e exportar configurações

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

configurações
Settings.
Visual Studio 264



Description

Description
Visual Studio 265

Details
Visual Studio 266

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 267

• 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 Itens solução
compilações da 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 268

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 269

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

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 270

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 271

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

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 272

Para desativar os estilos visuais do Windows XP
em Properties.
3. Desmarque a caixa de seleção Enable XP visual styles.
Para ativar os estilos visuais do Windows XP

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

3. Marque a caixa de seleção Make single instance application.
Para criar um aplicativo de múltiplas instâncias

3. Desmarque a caixa de seleção Make single instance application.
Visual Studio 273

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)

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

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 274

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

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 275

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 276

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 277

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 278

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

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

Visual Studio 279

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

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 280

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
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

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 281

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

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

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 282

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
Visual Studio 283

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 284

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 285

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

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

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 286

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

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 287

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

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 288

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

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 289

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 290

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

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

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 291

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

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 292

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 293

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 294

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 295

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 296

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,
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 297

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

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

Visual Studio 298

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

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 299

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

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 300

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 Os arquivos são armazenados em um URL Arquivos projeto são

arquivos durante o especificado em um computador com Serviços de armazenados no
desenvolvimento Informações da Internet (IIS) instalado. O projeto computador local.
também mantém um cache temporário de arquivos
em computadores cliente para trabalhar off-line.
Criar modelo ao Código de aplicativo é compilado como uma DLL e Código é compilado e
desenvolver executar no servidor. Resultados são visto no executado no computador
computador cliente. cliente.
Método de O projeto é implantado em um servidor Web. Arquivos de projeto são

implantação instalados no computador
cliente com arquivos de
suporte necessários.
Carga de trabalho Computadores cliente executar o aplicativo O aplicativo é executado

remotamente com um navegador da Web. localmente em o
Processamento é feito principalmente no servidor. computador cliente.
Visual Studio 301

Atualizar Alterações de aplicativo são feitas no nível do As atualizações de
servidor sem instalação dos arquivos de suporte em aplicativos são instalados
computadores clientes. em computadores cliente.
Movendo arquivos O comando Copy Project é usado para mover Fisicamente arquivos
projeto arquivos para o URL especificado. 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 302

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 303

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 304

Itens de projeto locais
Extensão de
Item de projeto arquivo Finalidade do item de projeto
Windows Form .vb ou .cs ou Um formulário para criar aplicativos baseados no Windows.
.jsl ou .java
Explorer Form .vb ou .cs ou Um formulário do Explorer com modo de exibição de árvore e
.jsl ou .java controles de navegação.
MDI Parent Form .vb ou .cs ou Um formulário para um aplicativo de interface de documentos
.jsl ou .java múltiplos.
About Box .vb ou .cs ou Um formulário de caixa de diálogo About para aplicativos baseados
.jsl ou .java no Windows
Login Form .vb ou .cs ou Um formulário de logon para coletar um nome de usuário e senha.
.jsl ou .java
Splash Screen .vb ou .cs ou Um formulário pré-configurado para ser usado como tela inicial.
.jsl ou .java
Dialog .vb ou .cs ou Um diálogo para aplicativos baseados no Windows.

.jsl ou .java
Class .vb ou .cs ou Um arquivo de código que contém uma declaração de classe. Para
.jsl ou .java mais informações, consulte Classes no Common Type System.
Interface .vb ou .cs ou Uma nova interface.

.jsl ou .java
Module (Visual .vb Um arquivo para armazenar grupos de funções.

Basic somente)
Component Class .vb ou .cs ou Uma classe para criar componentes usando o visual designer. Para
.jsl ou .java mais informações, consulte Classes de componente.
User Control .vb ou .cs ou Uma classe para criar um controle de Windows Form usando o
.jsl ou .java visual designer.
Windows Service .vb ou .cs ou Uma classe para criar serviços do Windows. Para mais informações,
.jsl ou .java 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 305

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 Um arquivo de código em branco.

.jsl ou .java
Custom Control .vb ou .cs ou Uma classe para criar um controle de Windows Forms de usuário.
.jsl ou .java 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 Um novo formulário baseado em um formulário existente. Para
.jsl ou .java mais informações, consulte Herança visual do Windows Forms.
Inherited User .vb ou .cs ou Um novo controle baseado em um controle Windows Forms
Control .jsl ou .java existente. Para mais informações, consulte COMO: Herdar de
controles Windows Forms existentes.
Web Custom .vb ou .cs ou Uma classe para criar um controle de servidor ASP.NET. Para mais
Control .jsl ou .java 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 .vb ou .cs Uma classe para uso com componentes transacionais.
Component
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 Uma classe para ser chamada no momento da instalação. Para mais
.jsl ou .java informações, consulte Usando componentes de instalação.
Visual Studio 306

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 .vb ou .cs ou Um arquivo contendo informações de assembly gerais. Para mais
Information File .jsl informações, consulte Assemblies na Common Language Runtime.
Application .config Um arquivo usado para definir configurações de aplicativo. Para

Configuration File mais informações, consulte Arquivos de configuração.
Debugger .vb ou .cs ou Um simples visualizador depurador

Visualizer .jsl ou .java
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 .wsf Um arquivo contendo script que é executado como um programa do
Host Windows. Para mais informações, consulte Usando arquivos de
script do Windows (.wsf).
Itens de projeto da Web
Extensão de
Item de projeto arquivo Finalidade do item de projeto
Web Form Dois arquivos: .aspx, Um formulário para criar aplicativos da Web.
e .vb para Visual
Basic ou .cs para
Visual C# ou .jsl
Visual Studio 307

para Visual J#
Master Page .master Uma página mestre para aplicativos da Web.
Web User .ascx Um controle de servidor do ASP.NET criado usando o visual

Control 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: Um componente que fornece a capacidade de trocar mensagens
.asmx, e .vb para interoperáveis usando protocolos padrões, tais como HTTP,
Visual Basic ou .cs XML, XSD, SOAP e WSDL. Para mais informações, consulte
para Visual C# ou Criando XML Web services em código gerenciado.
.jsl para Visual J#
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 .asax Às vezes chamado de arquivo asax, esse arquivo permite que
Application você escreva código para manipular eventos globais a nível de
Class 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 .config O ASP.NET usa este arquivo para definir as configurações da

Configuration Web para um projeto da Web. O nome do arquivo é Web.config,
File 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 .resx Um arquivo usado para editar e definir recursos de aplicativo.

Resource File 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 308

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 .ashx Uma página para implementar um manipulador genérico

Handler
Site Map .sitemap Um arquivo usado para criar um mapa do site.
Mobile Web .aspx Um formulário para criar aplicativos da Web móveis. Para mais
Form informações, consulte Criando aplicativos da Web do ASP.NET
para dispositivos móveis.
Mobile Web .ascx Um controle de servidor ASP.NET criado usando o visual

User Control 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 .config O ASP.NET usa este arquivo para definir as configurações de
Configuration um projeto da Web para dispositivos móveis. O nome do
File 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 .wsf Um arquivo de código vazio usado para scripts do Windows.
Host 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 309

Module (Visual .vb Um arquivo para armazenar grupos de funções.
Basic somente)
Component .vb ou .cs Uma classe para criar componentes usando o visual designer.
Class
Data Form .aspx (.vb ou .cs Um formulário de dados para aplicativos da Web.
Wizard para projetos locais)
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 .vb ou .cs ou .jsl Uma classe para criar um controle de servidor do ASP.NET.
Control 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 .disco Um arquivo opcional que atua como um mecanismo de

Discovery File 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.
Usado para criar

Modelo de
Visual Studio 310

projeto
Modelo Biblioteca Classes reutilizáveis ou componentes que podem ser compartilhados com outros
de classe 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 Aplicativo de linha de comando.

Aplicação de
console
Modelo do Projeto Um projeto vazio. O modelo cria a estrutura de arquivo necessário para armazenar
vazio informações de aplicativo; quaisquer referências, arquivos, ou componentes devem
ser adicionados manualmente.
Modelo de Controle personalizado que pode ser usado em páginas de formuláiros Web.
Biblioteca de
controle da Web Observação Visual Basic
Esse tipo de projeto é parecido com o projeto ActiveX Control no Visual Basic
6.0.
Modelo de Aplicativo Windows autônomos tradicional ou um rico front-end para aplicativo

aplicativos do Web distribuído. Para mais informações, consulte Criando aplicativos Windows.
Windows
Observação Visual Basic
Isso substitui o modelo de projeto Standard EXE no Visual Basic 6.0.
Modelo de Controle personalizado para usar em formulários Windows. Para mais informações,
Biblioteca de consulte Controle de criação de formulários do Windows.
controle do
Windows
Modelo de serviço Interface de aplicativos que executam por muito tempo e não têm uma interface de
do Windows 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 311

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 312

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 313

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 314

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 315

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 316

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 317

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 318

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>
size=4096" />
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 319

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#
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 320

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 321

Visual Studio 322
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.
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.

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.
Visual Studio 323

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.
Informações sobre como configurações funcionam no IDE, importar e
exportar configurações, e alterar basear configurações.
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.
Visual Studio 324

• 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
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
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.
Visual Studio 325

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 Lista links para tópicos que foram projetados para ajudá-lo rapidamente tornar
Started 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 326

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
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 Limita a lista para tópicos associados com qualquer elemento de interface do usuário
elements 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 327

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 328

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.
Consulte também
Visual Studio
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 Adicionando chaves Accelerator e

para ferramentas externas 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.
Visual Studio 329

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
Visual Studio 330

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.
Consulte também
Visual Studio
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
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
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.
Consulte também
Visual Studio
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 331
Observação
Para alterar o padrão UI exibida quando você inicia o Visual Studio

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.
Consulte também
Visual Studio

Nesta seção
Referência
Importar e exportar configurações, Ambiente, caixa de diálogo Opções

por diante.
Visual Studio 332
máquina
individuais
Visual Studio.
selecionadas.
Visual Studio 333

páginas.
• Favoritos
Consulte também
Outros recursos
Consulte também
Nesta seção
Visual Studio 334

Referência
Importar e exportar configurações, Ambiente, caixa de diálogo Opções

um colega na.
Observação
amarelo e preto.
Visual Studio 335

e clique em Next.
Observação

computadores.
Visual Studio 336

14. Clique em OK.
Consulte também
Consulte também
Opção Descrição


Export Settings.
Visual Studio 337

Observação
Consulte também
Conceitos
Nomeie O arquivo de configurações, importar e exportar
Export Settings.
Consulte também
Conceitos
Salvar configurações atuais, importar e Assistente para
exportação configurações
Settings.
Visual Studio 338


Consulte também
Description
Consulte também
Description
Visual Studio 339

Consulte também
Details
Consulte também
Visual Studio

um colega na.
Observação
amarelo e preto.
Visual Studio 340

e clique em Next.
Observação
computadores.
Visual Studio 341

4. Clique em OK.
Consulte também
Visual Studio

Consulte também
Visual Studio

Visual Studio 342

Consulte também
Visual Studio
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 Janelas de documento são colocadas lado a lado-em painéis com guias. O IDE usa
guias 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 343

• 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 344
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
Studio.
Visual Studio 345

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
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 346

• 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 347

Para ativar AutoOcultar para janelas de ferramentas
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 348

• 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
Visual Studio 349

página Ajuda foi gravada com configurações Visual C# em mente. Para exibir ou alterar as configurações,
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
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 350

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 351

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 352

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 353

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 354

• 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 355

• 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.
Visual Studio 356

• 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 357

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 358

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 359

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 360

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 361

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 362

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 363

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 364

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 365

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 Alteração de nome
agora) membro
genProxyLanguage enum genProxyManagedCpp Alteração de nome
(genProxyManaged agora) membro
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 & Parâmetro digite
SET) alteração
VCCLCompiler ExceptionHandling (GET & SET) Parâmetro digite
alteração
VCLinkerTool LinkTimeCodeGeneration (GET & SET) Parâmetro digite
alteração
VCProjectConfigurationProperties WholeProgramOptimization (GET & Parâmetro digite
SET) 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 366

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 Alteração de nome de
agora) parâmetro
StyleSheetFile (PropertySheetFile agora) Alteração de nome de
parâmetro
AppliedStyleSheets Alteração de nome de
(InheritedPropertySheets agora) parâmetro
ManagedExtensions Parâmetro digite
alteração
StyleSheetDirectory Alteração de nome de
(PropertySheetDirectory agora) parâmetro
PropertySheet (get) Alteração de nome de
parâmetro
VCXMLDataGeneratorTool GeneratedProxyLanguage (GET & SET) Alteração de nome
(now Namespace) membro
Visual Studio 367

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 368

- 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 369

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 370

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 371

• 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 372

• 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 373

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 Funcional grupos de automação
automação
Como criar Add-ins Como criar um add-in:
Como referência espaço para nome EnvDTE e obter uma Referência conjuntos de automação e o
instância do objeto DTE objeto DTE2
Registrar um suplemento Add-in de registro
Como limitar o acesso a arquivo de Registro Xml.AddIn do Add-in de segurança
seu projeto
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 374

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 Adicionando assistentes para a Adicionar
diálogo e como elas afetam Item e novas caixas de diálogo Project
usando arquivos VSDir
Como criar uma nova instância de Visual Studio forma Como criar e anexar a outra instância do
programática ou anexar a uma instância específica de Visual Visual Studio:
Studio que já está executando
Como atualizar projetos de automação das versões Migrando e atualizando Add-ins do Visual
anteriores do Visual Studio para Visual Studio 2005. 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 375

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.
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.
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 Controlar a solução e seus projetos
projetos na solução.
Como programaticamente Como criar soluções e configurações construir Project:
criar solução e projeto
configurações de
Visual Studio 376

compilação.
Lidando com projetos que Unmodeled Overview de projetos
não oferecerem suporte o
Visual Studio modelo de
automação.
Trabalhando com os Trabalhar com itens Solution e itens Miscellaneous
projetos — virtuais itens
Solution e itens
Miscellaneous projetos.
Salvando solução e projeto Persisting informações nos projetos e soluções
variável valores entre
sessões IDE (ambiente) de
desenvolvimento
integrado.
Manipular Solution HOW TO: controle Solution Explorer
Explorer.
Controlando Visual Basic, Introdução à extensibilidade de projeto
Visual C#,. e Visual J#
projetos
Controle Visual C++ e
Projetos. 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 alterar características da janela:
como sua altura, largura, e assim por diante.
Manipular código fonte e texto no editor do código. Como controlar o editor de código (Visual
Basic):
Visual Studio 377

Automatizar operações de pesquisa e substituição no Editor Como pesquisar e substituir automatizar
do código. texto:
Manipular Solution Explorer e seu conteúdo. HOW TO: controle Solution Explorer
Usando o Visual Studio modelo de código para descobrir Descobrir Código com o modelo de código
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 Controlar configurações opções ferramentas
menu Tools.
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 HOW TO: Manipulate modos de exibição
ferramentas usando o UIHierarchy objeto. 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 378

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
(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 379

("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.
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
Visual Studio 380

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.
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.
Visual Studio 381

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.
Visual Studio 382

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"
Visual Studio 383

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 384

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)
Visual Studio 385

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.
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
Visual Studio 386

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
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
Visual Studio 387

VCProjectEngine
Os tipos e membros relacionados ao Visual C++ projeto Automação. Inclui
VsWizard
Os tipos e membros relacionadas à Visual C++ automação Assistente. Inclui
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++.
Visual Studio 388

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 389

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 390

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 391

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 immed
que (>) sinal
Alternar novamente para a janela de comando a Inserir cmd na janela. >cmd

partir de uma janela imediata.
Os seguintes atalhos ajudam a navegar enquanto no modo de comando.
Ação Local do cursor KeyBinding
Alternar entre a lista de comandos Linha de entrada Seta para baixo e para baixo
inseridos anteriormente.
Rola para cima a janela. Conteúdo da janela de CTRL+SETA PARA CIMA

comando
Role para baixo a janela. Conteúdo da janela de SETA ABAIXO ou CTRL+SETA

comando 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 392

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
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
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 393

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 ? a+b

ponto de interrogação (?).
Temporariamente entrar no modo Comando enquanto no Digite o comando, prefacing-lo >alias

modo Immediate (para executar um único comando). com um maior sinal que (>).
Alternar para a janela de comando. Inserir cmd na janela, prefacing-lo >cmd

com um maior sinal que (>).
Alternar de volta para a janela Imediata. Inserir immed na janela sem o immed
maior que (>) sinal.
Modo marcar
Visual Studio 394

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
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
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 395

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
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
Visual Studio 396

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.
Visual Studio 397

Apostila Visual Studio - PT-BR

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apostila Visual Studio - PT-BR

Uploaded by

Copyright:

Available Formats

ÍNDICE

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

Sem sair do ambiente de desenvolvimento, você pode gerenciar seus projetos

Introdução ao controle de origem

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

Manipulação de arquivo pelo controle de origem

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

Como Controle de Origem Trata Soluções e Projetos

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

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

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

Terminologia de controle de origem

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

Execução de Tarefas de Controle de Origem

COMO: Adicionar um projeto ao controle de origem

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

Para adicionar os projetos selecionados ao controle de origem

COMO: acoplar ou desacoplar uma solução ou projeto

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

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

COMO: alterar o local da pasta de trabalho

Para alterar o local da pasta de trabalho

Como conectar ou desconectar uma solução ou um projeto

COMO: copiar um item sob controle de origem

Para copiar um projeto sob controle de origem

Para copiar um arquivo sob controle de origem

COMO: excluir um item controlado por origem

Para excluir um item controlado por origem

Como desativar a criação da pasta <solutionname>.root

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

COMO: Ativar Check-ins automáticos

Para ativar checkins automáticos

COMO: desativar check-outs automáticos

COMO: ativar ou desativar controle de origem

Para desativar completamente o controle de origem

COMO: excluir um arquivo de controle de origem

Para excluir um arquivo do controle de origem

COMO: mover uma raiz de ligação de projeto

Para mover uma raiz de ligação de projeto

COMO: mover um item controlado por fonte

Para mover um item controlado por origem

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

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

Para abrir um projeto da Web do controle de origem

COMO: Renomear um item controlado por origem

Para renomear um item de origem controlada

COMO: definir opções de plug-in

Para definir opções de plug-in

Como: Trocar plug-ins de controle de origem:

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

COMO: exibir uma lista de arquivos com check-out

Para exibir uma lista de arquivos modificados

Referência a Interface do Usuário do controle de origem

Acesso à caixa de diálogo

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

Caixa de diálogo Check In (Controle de Código Fonte)

Check-out para a caixa de diálogo Edit (controle de origem)

Caixa de diálogo Get (controle de origem)

Janela de check-ins pendentes

Caixa de diálogo de acesso

Guias de plug-in para controle de origem (caixa de diálogo Options)

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

Lista de elementos de interface do usuário, Environment