Você está na página 1de 397

Í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


1. No Visual Studio, abra o Solution Explorer e selecione uma solução ou
projeto a ser desacoplado.
2. No menu File, clique em Source Control, depois em Change Source
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
1. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem
desconectados.
2. No menu File, clique em Source Control e depois em Change Source
Control.
3. Na caixa de diálogo Change Source Control, clique em Disconnect.
4. Clique em OK.

COMO: copiar um item sob controle de origem


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

Observação

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

Para copiar um projeto sob controle de origem


1. No Visual Studio, abra o Solution Explorer.
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


1. No Visual Studio, abra o Solution Explorer.
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


1. No Visual Studio, no menu Tools, clique em Options.
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
1. No Visual Studio, no menu Tools, clique em Options.
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
1. No Visual Studio, no menu Tools, clique em Options.
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


1. No Visual Studio, no menu Tools, clique em Options.
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
2. No menu File, clique em Source Control, depois em Change Source
Control.
3. Na caixa de diálogo Change Source Control, clique em Unbind.
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


1. No Visual Studio, abra o Solution Explorer.
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


1. No Visual Studio, no menu File, clique em Open.
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


1. No Visual Studio, abra o Solution Explorer.
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


1. No Visual Studio, no menu Tools, clique em Options.
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
Acesso à caixa de diálogo
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
No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em
Source Control, depois clique em Check Out For Edit.

Observação

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

Verificar saída
Faz check-out de todos os itens selecionados.
Colunas
Identifica as colunas para exibição e a ordem na qual elas são exibidas.
Comentários
Especifica um comentário para associar à operação de check-out.
Não caixa diálogo Show Check Out quando check-out itens
Impede que a caixa de diálogo seja exibida durante operações de check-out.
Exibir simples
Exibe os itens do check-out em progresso como listas simples sob sua
conexão de controle de origem.
Editar
Permite que você modifique um item sem fazer seu check-out. O botão Edit
aparece somente se você tiver o Visual Studio configurado para dar suporte à
edição de arquivos com check-in.
Nome
Exibe os nomes dos itens disponíveis para check-out. Os itens que estão
selecionados aparecem com caixas de seleção ao seu lado. Se você não
desejar fazer check-out de um item específico, desmarque sua caixa de
seleção.
Opções
Exibe opções de check-out específicas do plug-in de controle de origem
quando a seta à direita do botão é clicada.
Classificação
Altera a ordem de classificação das colunas exibidas.
Exibir árvore
Exibe a hierarquia de pastas e arquivos para o item do check-out em
progresso.

Caixa de diálogo Get (controle de origem)


Recupera uma cópia somente para leitura do item selecionado do banco de dados
para sua pasta de trabalho, ou outra pasta que você especificar.

Visual Studio 29
Acesso à caixa de diálogo
No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em
Source Control, depois em Get.

Observação

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

Ação
Especifica a ação a ser executada nos itens a ser recuperados.
Colunas
Identifica colunas para exibição e a ordem na qual elas são exibidas.
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
Altera a ordem de classificação das colunas exibidas.
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
Especifica um comentário a ser associado com a operação de check-in.
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
Altera a ordem de classificação das colunas exibidas.
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
solução ou projeto.
Manter itens check-out ao verificar na
Especifica que itens em processo de check-in devem permanecer com check-
out para você. Se você desejar alterar esta opção para um check-in
específico, clique na seta de Options na caixa de diálogo Check In, e
desmarque a opção Keep Checked Out.
Redefinir
Redefine confirmações.
Salvar
Especifica a maneira com que itens devem ser manipulados quando você os
salva. As opções possíveis são:

Opção Descrição

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

Check out 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
operação de salvar.

Configurações de ambiente controle de origem


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

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


Avançadas
Permite que você defina opções adicionais para usar o plug-in de controle de
origem . O botão Advanced só está disponível quando um plug-in de
controle de origem válido está instalado no computador local. As
configurações avançadas são específicas para o plug-in.
Identificação de logon
Especifica o nome de usuário para efetuar logon no plug-in de controle de
origem. Se seu plug-in der suporte, esse nome será colocado
automaticamente na caixa de diálogo de logon usada pelo plug-in de controle
de origem para acessar o servidor. Para ativar essa opção, desative logons
de usuário automáticos do seu plug-in de controle de origem, e reinicie o
Visual Studio.

Observação

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

Visual Studio 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
Especifica o nome do plug-in de controle de origem para o qual você está
fazendo configurações.

Caixa de diálogo Source Control


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

Acesso à caixa de diálogo


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.

Acesso à caixa de diálogo


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

Observação

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

Columns
Identifica as colunas a serem exibidas e a ordem na qual elas são exibidas.
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
Altera a ordem de classificação das colunas de exibição.
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
1. No menu Tools, escolha Import and Export Settings.
2. Na Welcome to the Import and Export Settings Wizard Página, clique
em Export selected environment settings e clique em Next.
3. No Which settings do you want to export?, selecione as categorias você
pretende exportar e, em seguida, clique em Next Configurações.

Observação

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

4. No What do you want to name your settings file, digite um nome para o
arquivo de configurações.
5. Se você gostaria de salvar o arquivo em um local diferente, clique Browse
ou digite um novo caminho para Store my settings file in this directory.
6. Clique em Finish.
7. Na página Export Complete, examine os erros associados à exportação as
configurações com Details.
Importar um arquivo.vssettings
Após ter criado um arquivo.vssettings, você pode usar esse arquivo em outros
computadores ao importar esse arquivo para outra instalação do Visual Studio.
Você também pode importar arquivos de configuração criados por outros usuários e
aplicar essas configurações para o Visual Studio.
Se você está importando o arquivo configurações contém todas as categorias
configurações possíveis, importar esse arquivo completamente substitui as
configurações existentes. Importar o arquivo se um arquivo de configurações

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

6. Clique em Finish.
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.
2. Na pasta Environment, escolha Import and Export Settings.
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
Use esta página do Assistente para configurações a importação e exportação para
especificar o nome e local do arquivo que irá conter as configurações exportadas.
Você pode acessar este assistente a partir do Tools menu clicando Import and
Export Settings.
COMO: Compartilhar configurações entre computadores
What do you want to name your settings file?
Digite um nome personalizado para as configurações exportadas.
Store my settings file in this directory.
Especifica o diretório padrão no qual as configurações exportadas serão
salvos. Clique Browse para especificar uma pasta personalizada.

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


configurações
Use esta página do Assistente para configurações a importação e exportação para
salvar as configurações ativos antes de importar novas configurações. Você pode
acessar este assistente a partir do Tools menu clicando Import and Export
Settings.
COMO: Compartilhar configurações entre computadores
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
Use esta página do Assistente para configurações a importação e exportação para
especificar a coleção Configurações você pretende importar. Você pode acessar este
assistente a partir do Tools menu clicando Import and Export Settings.
• COMO: Compartilhar configurações entre computadores
Which settings do you want to import?
Selecione uma coleção na lista, ou clique Browse para localizar uma coleção
diferente para importar.
Description
Exibe informações sobre a coleção configurações que são otimizadas para.
Somente disponível para Default Settings.

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


Assistente configurações exportação
Use esta página do assistente Importar e exportar configurações para especificar
uma coleção configurações predefinidos ou uma coleção configurações
personalizadas você deseja importar para uso no IDE. Você pode acessar este
assistente a partir do Tools menu clicando Import and Export Settings.
• Como: Alterar configurações selecionadas
Which collection of settings do you want to import?
Lista as coleções configurações disponíveis. Clique Browse para navegar
para uma coleção configurações que não aparece na lista.
Description
Exibe informações sobre a coleção configurações que são otimizadas para.
Para obter mais informações sobre coleções configurações predefinidas,
consulte Configurações do Visual Studio.

Visual Studio 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
informações, consulte COMO: Implantar Serviços da Web XML no Código
Gerenciado.
7. Clique em OK.
8. No Solution Explorer, clique com o botão direito do mouse no
projetoTempConvert1WebSetup, e no menu de atalho, clique Build.
Isso cria um arquivo do Windows Installer no diretório de projeto local.
Executar este arquivo instala o aplicativo da Web.
Para implantar o XML Web Services, copiando o projeto
1. No Solution Explorer, selecione o projeto TempConvert1.
2. No menu Project, clique em Copy Web Site.
3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de
diálogo Open Web Site. Navegue para a localidade para a qual você deseja
copiar o projeto.

Visual Studio 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
Visual Basic ou Visual C#
Criando um projeto cliente de XML Web Services
Nesta explicação passo a passo, você vai criar um aplicativo simples da Web que
acessa o XML Web Services TempConvert1, que foi o nome dado ao XML Web
Services criado no Explicação Passo a Passo: Criando um XML Web Services usando
Visual Basic ou Visual C#.

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

Visual Studio 48
1. No menu File, escolha New Web Site.
2. Na caixa de diálogo New Web Site, selecione o ícone ASP.NET Web Site.
3. Digite o endereço do servidor Web no qual você irá desenvolver o aplicativo
da Web e especifique TempConvertClient1 como o nome do diretório, tal
como " http://MyServer/TempConvertClient1 ". Por padrão, o projeto usa sua
máquina local, " http://localhost ".

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

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

4. Clique em OK para criar o projeto.


5. No Solution Explorer, clique com o botão direito do mouse em
Default.aspx e escolha View Designer para abrir o designer.
6. Da guia Web Forms da Toolbox, arraste uma Text Box, uma Label e um
Button para a superfície de design de Default.aspx e organize-os ao seu
gosto.
7. Clique com o botão direito do mouse no botão adicionado, Button1, e clique
em Properties no menu de atalho. Na janela Properties, defina a
propriedade Text como Convert.
8. Clique com o botão direito do mouse no rótulo adicionado, Label1, e clique
em Properties no menu de atalho. Na janela Properties, desmarque a
propriedade Text para fazer deste um rótulo em branco.
Adicionando uma referência da Web
Descoberta de XML Web Services é o processo pelo qual um cliente localiza um XML
Web Services e obtém sua descrição de serviço. O processo de descoberta de XML
Web Services no Visual Studio envolve interrogar um site da Web seguindo um
algoritmo predeterminado. A meta do processo é localizar a descrição de serviço,
que é um documento XML que usa o WSDL (Web Services Description Language).
Para obter mais informações, consulte Descoberta de XML Web Service.
A descrição de serviço descreve quais serviços estão disponíveis e como interagir
com os serviços. Sem uma descrição de serviço, é impossível interagir com um XML
Web Services programaticamente. Para obter mais informações, consulte Descrição
de XML Web Service.
Seu aplicativo deve ter um meio para se comunicar com o XML Web Services e para
localizá-lo em tempo de execução. Adicionar uma referência da Web ao seu projeto
para o XML Web Services faz isso por gerar uma classe proxy que interfaceia com o
XML Web Services e fornece uma representação local do XML Web Services. Para

Visual Studio 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
automaticamente criou essas configurações e definiu as opções padrão apropriadas
e outras configurações. Para obter mais informações, consulte Configurações Debug
e Release.
Nesta explicação passo a passo, você colocará um ponto de interrupção no evento
Button1_Click e usará o método Start (with debugging). Para obter mais
informações, consulte Depurando XML Web Services em Código Gerenciado.
Antes da depuração, verifique as configurações de depuração. Para obter mais
informações, consulte Preparação de Depuração: Aplicativos ASP.NET.
Usar um ponto de interrupção e iniciar o aplicativo da Web com depuração
1. No menu Debug, clique em New Breakpoint e em seguida escolha Break
At Function.
Digite Button1_Click na caixa Function e clique em OK para colocar um
ponto de interrupção no manipulador de eventos Button1_Click. Para obter
mais informações, consulte Visão geral sobre pontos de interrupção.
2. No menu Debug, clique em Start, depois clique em Ok na janela
Debugging Not Enabled para iniciar a depuração.
Este comando instrui o Visual Studio a executar o aplicativo da Web no
depurador. O Visual Studio compila o projeto e o implanta no servidor de
desenvolvimento designado. Após a conclusão, o navegador padrão inicia e
navega para o arquivo .aspx no servidor implantação.
3. Depois que a página é exibida no navegador, digite o número 212 na caixa
de texto e depois clique no botão Convert.
Quando o processamento atinge o manipulador de eventos Button1_Click, o
processamento pára. O depurador do Visual Studio realça a linha que contém
o ponto de interrupção e, enquanto interrompido, você poderá executar uma

Visual Studio 51
variedade de tarefas. Para obter mais informações, consulte Usando o
Depurador e Ferramentas de Depuração para Inspeção de seu Programa.
4. No menu Debug, clique em Continue para continuar o processamento.
5. O XML Web Services responde retornando o valor convertido e o aplicativo
define o texto do Label1 para 100.
Para interromper a execução do aplicativo da Web e retornar ao editor de
código, no menu Debug, clique em Stop Debugging.
6. No menu Debug, clique em Clear All Breakpoints.
Implantando o cliente
Para tornar seu aplicativo da Web disponível para outros, você deve implantá-lo em
um servidor Web que seja acessível para os clientes que você deseja dar suporte.
Para implantar o aplicativo da Web em um servidor que não seja o servidor de
desenvolvimento, você pode adicionar um Web Setup Project ou copiar os arquivos
necessários para o servidor de destino. Nesta explicação passo a passo, você pode
escolher como implantar este aplicativo da Web. Para obter mais informações,
consulte Implantando Aplicativos e Componentes.
Implantar o aplicativo da Web usando um Web Setup Project
1. No menu File, aponte para Add e depois clique em New Project.
2. Selecione o nó Other e depois o nó Setup and Deployment Projects e
depois clique em Web Setup Project.
3. Na caixa Name, digite TempConvertClient1WebSetup e depois clique em
OK.

Observação
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
TempConvertClient1WebSetup, aponte para Add e depois clique em
Project Output.
6. Na caixa de diálogo Add Project Output Group, selecione Content Files.
Para obter mais informações, consulte Adicionando e Removendo Saídas de
Projetos no File System Editor.
o O grupo Content Files consiste nos arquivos restantes para o aplicativo
da Web, tais como WebForm1.aspx e Web.config.
7. Clique em OK.
8. No Solution Explorer, clique com o botão direito do mouse no projeto
TempConvertClient1WebSetup e, no menu de atalho, clique em Build.
Isso cria um arquivo do Windows Installer no diretório do projeto local.
Executar este arquivo instala o aplicativo da Web.
Implantar o aplicativo da Web, copiando o projeto
1. No Solution Explorer, selecione o projeto TempConvertClient1.
2. No menu Project, clique em Copy Web Site.

Visual Studio 52
3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de
diálogo Open Web Site. Navegue para a localidade que você deseja copiar o
projeto.
4. No painel Source Web Site, selecione os arquivos para copiar e mova-os para
o painel Remote Web Site, clicando no ícone da seta direita.
5. Clique em Copy Web Site para copiar o site da Web.

Um componente com Visual C# Walkthrough: criação


Componentes forneça reutilizáveis código sob a forma de objetos. É conhecido
como um aplicativo que usa código é um componente,, criando objetos e chamar
suas propriedades e métodos, um Cliente. Um cliente pode ou não pode estar no
mesmo conjunto como um componente ele usa.
Os seguintes procedimentos criar no entre si, de forma a ordem na qual você
realizá-las é importante.

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

Criando o projeto
Para criar a biblioteca de classes CDemoLib e o componente CDemo
1. No menu File, selecione New e Project Para abrir caixa New Project de
diálogo. Selecione o Class Library modelo de projeto a partir da lista de
Visual C# tipos de projeto, e digite CDemoLib na caixa Name.

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

2. No Solution Explorer, clique com o botão direito do mouse CDemoLib e


selecione Properties a partir do menu de atalho. Observe que a Default
namespace caixa contém CDemoLib.
A raiz é usado para qualificar os nomes dos componentes no conjunto. Por
exemplo, se dois conjuntos de módulos (assemblies) fornecer componentes
nomeado CDemo, você pode especificar seu CDemo componente usando
CDemoLib.CDemo
Feche a caixa de diálogo.
3. A partir do Project menu, escolha Add Component.
4. Na caixa Add New Item de diálogo, selecione Component Class e digite
CDemo.cs na caixa Name. Clique Add para crate o componente.
Um componente denominado CDemo é adicionado à sua biblioteca de classe.
5. No Solution Explorer, clique com o botão direito do mouse CDemo.cs e
escolha View Code a partir do menu de atalho. Abre o editor de código.

Visual Studio 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
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
A primeira etapa é para criar o projeto e configurar o formulário.
Para criar o projeto
1. Criar um projeto chamado " SmartTagsExample " aplicativo baseado no
Windows. Para obter detalhes, consulte Como: Criar um projeto de aplicativos
Windows.
2. Selecione o formulário no Windows Forms Designer.
Usando marcas inteligentes
Marcas inteligentes estão sempre em tempo de criação em controles que oferecem-
los disponíveis.
Para usar marcas inteligentes
1. Arraste até o formulário. de um TabControl a Toolbox Observe o glifo de
marca inteligente ( . o TabControl) que aparece na parte lateral do
2. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o
glifo, selecione o Add Tab item. Observar se uma nova página guia foi
adicionado ao TabControl.
3. Arraste um TableLayoutPanel controle de até seu formulário. o Toolbox
4. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o
glifo, selecione o Add Column item. Observar que uma nova coluna será
adicionada para o TableLayoutPanel controle.
5. Arraste um SplitContainer controle de até seu formulário. o Toolbox
6. Clique o glifo de marca inteligente. No menu de atalho que aparece ao lado o
glifo, selecione o Horizontal splitter orientation item. Observar que a
SplitContainer barra divisora do controle agora é orientado horizontalmente.

Coleções dos tipos padrão com o


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

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

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
Tarefas ilustradas nesta explicação passo a passo incluem:
• 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
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
A primeira etapa consiste em criar o projeto de aplicativo. Você usará este projeto
para criar o aplicativo que hospeda o controle personalizado.
Para criar o projeto
• Criar um projeto do Aplicativo do Windows chamado " DebuggingExample ".
Para obter detalhes, consulte Como: Criar um projeto de aplicativos Windows.
Criar um Projeto Biblioteca de Controle
A próxima etapa é para criar o projeto Biblioteca de Controle e configurar o controle
personalizado.
Para criar o projeto Biblioteca de Controle
1. Adicione um Windows Control Library projeto para a solução. Para obter
detalhes, consulte Caixa de diálogo Add New Project. Nome do projeto "
DebugControlLibrary ".
2. Adicionar um novo UserControl item para o projeto DebugControlLibrary.
Para obter detalhes, consulte Como: Adicionar novos itens de projeto. Dê o
novo arquivo de origem uma nome de base de " DebugControl ".
3. Usando a Solution Explorer, exclusão, excluindo o arquivo com um nome
de base de código padrão do projeto controlar " " UserControl1. Para obter
detalhes, consulte COMO: Remover, excluir, e excluir itens.
4. Compilar uma solução.
Ponto de Verificação
Neste ponto, você será capaz para ver o controle personalizado no Toolbox.
Para verificar o seu andamento
• Localizar o nova guia chamada DebugControlLibrary Components e clique
para selecioná-lo. Ao ser aberto, você verá seu controle listados como
DebugControl com o ícone padrão ao lado dela.
Adicionar uma propriedade ao seu controle personalizado
Para demonstrar que o controle personalizado na código sendo executado em
tempo de criação, será adicionar uma propriedade e definir um ponto de
interrupção no código que implementa a propriedade.
Para adicionar uma propriedade ao seu controle personalizado
1. Aberto DebugControl no Code Editor. Adicione o seguinte código para a
definição de classe:
C#
private string demoStringValue = null;
[Browsable(true)]
public string DemoString
{ get

Visual Studio 62
{ return this.demoStringValue; }
set { demoStringValue = value; } }

2. Compilar uma solução.


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.
Tarefas ilustradas nesta explicação passo a passo incluem:
• 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
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.

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.
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.
Para criar o projeto
• Criar um projeto do Aplicativo do Windows chamado " MarqueeControlTest ".
Para obter mais informações, consulte Como: Criar um projeto de aplicativos
Windows.
Criar um Projeto Biblioteca de Controle
A próxima etapa consiste em criar o projeto Biblioteca de Controle. Você criará um
novo controle personalizado e seu designer personalizado correspondente.
Para criar o projeto Biblioteca de Controle
1. Adicione um projeto Biblioteca de Controle do Windows para a solução. Para
obter mais informações, consulte Caixa de diálogo Add New Project. Nome do
projeto " MarqueeControlLibrary ".
2. Usando Solution Explorer, Excluir controle padrão do projeto, excluir o
arquivo de origem nomeado " UserControl1.cs " ou " UserControl1.vb ",
acordo com o idioma de escolha. Para obter mais informações, consulte
COMO: Remover, excluir, e excluir itens.
3. Adicionar um novo UserControl item para o MarqueeControlLibrary
projeto. Dar o novo arquivo de origem uma nome de base de "
MarqueeControl ".
4. Usando Solution Explorer, criar uma nova pasta no projeto
MarqueeControlLibrary. Para obter mais informações, consulte Como:
Adicionar novos itens de projeto.Nomeie a nova pasta " Design ".
5. Clique com o botão direito do mouse na Design pasta e adicionar uma nova
classe. Fornecer o arquivo de origem uma nome de base de "
MarqueeControlRootDesigner ".
6. Será necessário para usar tipos de montagem System.Design, então
adicionar essa referência para o MarqueeControlTest projeto. Para obter
mais informações, consulte COMO: Adicionar e remover referências no Visual
Studio (C#, J#).
Referência a Project controle personalizado
Você usará o MarqueeControlTest projeto para testar o controle personalizado. O
projeto teste tornará conhecer o controle personalizado quando você adiciona uma
referência ao conjunto MarqueeControlLibrary Projeto.
Para fazer referência o projeto de controle personalizado
• No projeto MarqueeControlTest, adicione uma referência ao conjunto
MarqueeControlLibrary Projeto. Certifique-se de usar a Projects guia na caixa
Add Reference de diálogo em vez de referência montagem
MarqueeControlLibrary diretamente.
Definir um controle personalizado e seus designer personalizado
O controle personalizado será derivar a partir da UserControl classe. Isso permite
que o controle para conter outros controles, e ele fornece o controle uma grande
quantidade de funcionalidade padrão.
O controle personalizado não terá um designer personalizado associado. Isso
permite que você para criar uma experiência design exclusivo adequado
especificamente para o controle personalizado.

Visual Studio 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#
using System; using System.Collections; using System.ComponentModel; using
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; } }

4. Adicionar um novo UserControl item para o MarqueeControlLibrary


projeto. Dar o novo arquivo de origem uma nome de base de " MarqueeText
".
5. Arraste um BackgroundWorker componente de até seu MarqueeText
controle. o Toolbox Esse componente permitirá que o MarqueeText controle
para atualizar próprio assincronamente.
6. Na janela Propriedades, defina as BackgroundWorker propriedades para
true e WorkerSupportsCancellation do componente
WorkerReportsProgess. Essas configurações permitem que o
BackgroundWorker Componente para aumentar o ProgressChanged evento
periodicamente e para cancelar Atualizações assíncronas. Para obter mais
informações, consulte Componente BackgroundWorker.
7. Abrir o MarqueeText arquivo de origem no Code Editor. Na parte superior do
arquivo, importar os espaços para nome a seguir:
C#
using System; using System.ComponentModel; using System.ComponentModel.Design; using
System.Diagnostics; using System.Drawing; using System.Threading; using
System.Windows.Forms; using System.Windows.Forms.Design;

8. Alterar da declaração do MarqueeText para herdar de Label e para implementar


a IMarqueeWidget interface:
C#
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]
public class MarqueeText : Label, IMarqueeWidget {

9. Declare as variáveis que correspondem às propriedades expostos, instância e


inicializar-los no construtor. O isLit campo determina se o texto está para ser
pintura com a cor determinado pela LightColor propriedade.
C#
// When isLit is true, the text is painted in the light color; // When isLit is false, the text is painted
in the dark color. // This value changes whenever the BackgroundWorker component // raises the
ProgressChanged event. private bool isLit = true; // These fields back the public properties. private
int updatePeriodValue = 50; private Color lightColorValue; private Color darkColorValue; // These
brushes are used to paint the light and dark // colors of the text. private Brush lightBrush; private
Brush darkBrush; // This component updates the control asynchronously. private
BackgroundWorker backgroundWorker1; public MarqueeText() { // This call is required by the
Windows.Forms Form Designer. InitializeComponent(); // Initialize light and dark colors // to the
control's default values. this.lightColorValue = this.ForeColor; this.darkColorValue =
this.BackColor; this.lightBrush = new SolidBrush(this.lightColorValue); this.darkBrush = new
SolidBrush(this.darkColorValue); }

10. Implementa a IMarqueeWidget interface.

Visual Studio 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
1. Adicionar um novo UserControl item para o MarqueeControlLibrary
projeto. Dar o novo arquivo de origem uma nome de base de "
MarqueeBorder ".
2. Arraste um BackgroundWorker componente de até seu MarqueeBorder
controle. o Toolbox Esse componente permitirá que o MarqueeBorder controle
para atualizar próprio assincronamente.
3. Na janela Propriedades, defina as BackgroundWorker propriedades para
true e WorkerSupportsCancellation do componente
WorkerReportsProgess. Essas configurações permitem que o
BackgroundWorker Componente para aumentar o ProgressChanged
evento periodicamente e para cancelar Atualizações assíncronas. Para obter
mais informações, consulte Componente BackgroundWorker.
4. Abrir o MarqueeBorder arquivo de origem no Code Editor. Na parte superior do
arquivo, importar os espaços para nome a seguir:
C#
using System; using System.ComponentModel; using System.ComponentModel.Design; using
System.Diagnostics; using System.Drawing; using System.Drawing.Design; using
System.Threading; using System.Windows.Forms; using System.Windows.Forms.Design;

5. Alterar da declaração da MarqueeBorder Herdar do Panel e para implementar a


IMarqueeWidget interface.

C#
[Designer(typeof(MarqueeControlLibrary.Design.MarqueeBorderDesigner ))]
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]
public class MarqueeBorder : Panel, IMarqueeWidget {

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#
using System; using System.Collections; using System.ComponentModel; using
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
1. Adicionar um novo UserControl item para o MarqueeControlLibrary
projeto. Dar o novo arquivo de origem uma nome de base de "
LightShapeSelectionControl ".
2. Arraste dois Panel controles da Toolbox. até a LightShapeSelectionControl
Nome-los squarePanel e circlePanel. Organizá-los lado a lado. Definir a Size
propriedade de ambos os Panel controles para (60, 60). Defina a Location
propriedade do controle squarePanel para (8, 10). Defina a Location
propriedade do controle circlePanel para (80, 10). Finalmente, defina a Size
propriedade do (150, 80). para o LightShapeSelectionControl
3. Abrir o LightShapeSelectionControl arquivo de origem no Code Editor.
4. Implementar Click manipuladores de eventos para e circlePanel controles. o
squarePanel Esses métodos chamar CloseDropDown para encerrar a sessão de
edição personalizada UITypeEditor.

Visual Studio 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.
5. Compilar uma solução.
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
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
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)

9. No menu File, clique Save All para salvar o projeto.


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.
4. No menu File, clique Save All para salvar o projeto.
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
clique em View Code.
2. Localize a public class instrução. Observe que o controle herdado
ctlClockLib.ctlClock. Sob o Brace abertura digite o seguinte código. ({) instrução,

[C#]
private DateTime dteAlarmTime; private bool blnAlarmSet; // These properties will be declared as
public to allow future // developers to access them. public DateTime AlarmTime { get { return
dteAlarmTime; } set { dteAlarmTime = value; } } public bool AlarmSet { get { return blnAlarmSet;
} set { blnAlarmSet = value; } }
Adicionando a interface gráfica do controle
O controle herdado tem uma interface visual que é idêntica ao controle ela herda
da. Ele possui os mesmos controles constituintes como seu controle pai, mas não
as propriedades dos controles constituintes estará disponível a menos que eles
foram especificamente expostos. Você pode adicionar para a interface gráfica de
um controle composto herdadas da mesma maneira ao deseja incluir em qualquer
controle composto. Para continuar adicionando ao alarme o relógio na interface
visual, você adicionará um controle rótulo que será memória flash quando o alarme
é sounding.
Para adicionar o controle rótulo
1. No Solution Explorer, clique com o botão direito do mouse ctlAlarmClock e
clique em View Designer.
O designer para ctlAlarmClock abre na janela principal.
2. Clique na parte de exibição do controle, e exibir a janela Propriedades.

Observação
Enquanto todas as propriedades são exibida, eles são esmaecidos. Isso indica que essas propriedades são
nativo para lblDisplay e não pode ser modificado ou acessado na janela Propriedades. Por padrão,
controles contido em um controle composto são private, e suas propriedades não estão acessíveis por
qualquer meio.
Observação
Se você quiser que os subseqüentes usuários de seu controle composto para ter acesso a seus controles

Visual Studio 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; }

5. No menu File, clique Save All para salvar o projeto.


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.
As caixas de diálogo e comandos de menu que você vê podem ser diferentes das descritas em Help
(Ajuda) dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import
and Export Settings No menu Tools. Para obter mais informações, consulte Configurações do Visual
Studio.
Para criar o formulário
1. Criar um novo Windows Application projeto.
2. Nome do aplicativo Calculations e renomeie Form1.cs como frmCalculations.cs.
Quando Visual Studio solicita que você para renomear o Form1 elemento de
código, clique em Yes.
Este formulário servirá como a interface do usuário principal para seu
aplicativo.

Visual Studio 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
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
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.
8. No menu File, optar Save All por salvar o projeto.

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.
3. No menu File, optar Save All por salvar o projeto.
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.
Durante o curso desta explicação passo a passo, você irá realizar as atividades a
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
A New Project caixa de diálogo será exibida.
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;

9. No menu Build, clique em Build Solution.


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
6. Clique em Finish.
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.
5. No menu Build, clique em Build Solution.
6. No menu Debug, clique em Start Without Debugging.
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.
2. No menu de atalho, clique em Add, e clique em Add Resource
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
7. Clique em Finish.
8. No modo de exibição de recursos, sob o nó HTML, clique duas vezes no
IDR_HTML_MYDHTMLDLG item e clique na guia HTML no painel do projeto para
editar o arquivo HTML associado.
9. Substituir o texto existente (que deve ser semelhante TODO: Place controls here).
com This is the text content of my DHTML dialog box
Como com o diálogo Host de controle implementado anteriormente, esta caixa de
diálogo será exibida quando o usuário pressiona um botão (DHTML Dialog.) no
formulário principal do aplicativo
Para exibir a caixa de diálogo DHTML
1. Do IDD_MYPROJECT_FORM no modo de exibição de recursos, exibir o
formulário principal clicando duas vezes (localizada sob o nó de diálogo do
arquivo de recurso para a MyProject Solução).
2. Clique duas vezes no DHTML Dialog botão, adicionada anteriormente.
3. Adicione o seguinte código para a função do manipulador:

Visual Studio 109


CMyDhtmlDlg dlg; dlg.DoModal( );

4. Adicione o código a seguir após a última #include Instrução no arquivo de


origem atual:
#include "MyDhtmlDlg.h"

Isso inclui o arquivo.h da classe implementação caixa de diálogo DHTML.


5. No menu Build, clique em Build Solution.
6. No menu Debug, clique em Start Without Debugging.
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
A New Project caixa de diálogo será exibida.
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.
2. No menu de atalho, clique em Add, e clique em Add Resource
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
6. Clique em Finish.
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.
6. Clique em Finish.
7. Clique com o botão direito do mouse no segundo Edit control Controle.
8. Adicionar outra variável (chamada m_Password de categoria Value).
9. Clique duas vezes no OK botão no formulário Caixa de diálogo.
10. Adicione o seguinte código para a função do manipulador:
Service1::CService1 *s = new Service1::CService1(); UpdateData(TRUE); bool result = false; s-
>Validate(CComBSTR(m_Name), CComBSTR(m_Password), &result); if (result)
CDialog::OnOK();

Visual Studio 111


11. Adicione o código a seguir após a última #include Instrução no arquivo de
origem atual:
#include "WebService.h"

Isso inclui o arquivo.h do serviço da Web usado por caixa de diálogo de


validação.
Para a rotina de validação para ser eficiente, caixa de diálogo de validação deve ser
o primeiro objeto Interface de usuário seja exibido. Se o usuário inserir o nome
correto e a senha a aplicativo rich client serão exibidos. Será se um nome incorreto
ou senha for inserida, o usuário atual ser impedido de acessar o aplicativo rich
client.
Para implementar esse comportamento, modifique a InitInstance função da classe do
aplicativo principal para chamar esta caixa de diálogo primeiro. O aplicativo
continua somente quando a caixa diálogo corretamente sai.
Para exibir a caixa de diálogo de validação inicialmente
1. No modo de classe, expanda o CMyProjectApp nó.
2. Clique duas vezes a InitInstance função para editar o corpo função.
3. Adicione o seguinte código antes que a chamada para a ShowWindow função
do objeto pMainFrame:
// Display the validation dialog box first CMyValidateDlg dlg; if (dlg.DoModal() != IDOK) return
FALSE;

4. Adicione o código a seguir após a última #include Instrução no arquivo de


origem atual:
#include "MyValidateDlg.h"

Isso inclui o arquivo.h da caixa de diálogo de validação.


5. Compilar uma solução. No menu Build, clique em Build Solution.
6. No menu Debug, clique em Start Without Debugging. Na caixa de diálogo
de verificação, inserir o mesmo texto nas caixas de edição Nome e senha, e
clique em OK. O aplicativo rich client será executada, exibindo sua caixa de
diálogo principal.
Criar um projeto de instalação
A etapa final ao desenvolver seu aplicativo Visual C++ está criando um projeto de
instalação.
Para criar um projeto de instalação
1. No Explorer Solution, clique com o botão direito do mouse a MyProject
Solução.
2. No menu de atalho, clique em Add, e clique em New Project
A New Project caixa de diálogo será exibida.
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

2. Alterne para modo Source.


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.

Executando a Página
Agora você pode testar os controles do servidor na página.
Para executar a 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">.
4. Feche o navegador.
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


5. Alterne para modo Source.
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(); }

Executando a Página
Agora você pode testar o calendário.
Para executar a página
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>.
4. Feche o navegador.
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
1. Abra o Visual Web Developer.
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.
O Visual Web Developer cria a pasta e uma nova página chamada
Default.aspx.
Adicionando um Controle GridView para Exibir Dados
Para exibir dados em um página da web do ASP.NET, é necessário o seguinte:
• Uma conexão com uma fonte de dados (como um banco de dados).
No procedimento a seguir, você criará uma conexão com o banco de dados SQL
Server Northwind.
• Um controle da fonte de dados na página, que executa consultas e gerencia
os resultados de consultas.
• Um controle na página para exibir os dados realmente.
No seguinte procedimento, você irá exibir dados em um controle GridView. O
controle GridView receberá seus dados a partir do controle SqlDataSource.
Você pode adicionar esses elementos para o site separadamente. No entanto, é
mais fácil começar a visualizando a exibição de dados usando o controleGridView,
e usando assistentes para criar a conexão e o controle da fonte de dados. O
procedimento a seguir explica como criar todos os três elementos que você deve
ter para exibir dados na página.
Para adicionar e configurar um controle GridView para exibir dados
1. No Visual Web Developer, alterne para o modo de exibição Design.
2. Da pasta Data em Toolbox, arraste um controle GridView para a página.
3. Se o o menu de atalho GridView Tasks não for exibido, clique com o botão
direito do mouse no controle GridView e clique em Show Smart Tag.
4. No menu GridView Tasks, em Choose Data Source list, clique em <New
data source>.
A caixa de diálogo Data Source Configuration aparece.

Visual Studio 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.
19. Clique em Finish.
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
1. Pressione CTRL+F5 para executar a página.
A página aparece no navegador. O controle GridView exibe todas as linhas
de dados da tabela Customers.
2. Feche o navegador.
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.
5. Pressione CTRL+F5 para executar a página.
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.
6. Feche o navegador.
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
1. Pressione CTRL+F5 para executar a página.
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
Para concluir esta explicação passo a passo, será necessário:
• 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.
Para criar um site do sistema de arquivos
1. Abra o Visual Web Developer.
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.
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.
O Visual Web Developer cria a pasta e uma nova página chamada
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.
10. Clique em Finish.
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.
4. Pressione CTRL+F5 para executar a página.
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
1. Alterne para ou abra a página Default.aspx.
2. Alterne para modo Design.
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
1. Abra o Visual Web Developer.
2. No menu File, clque em New Web Site.
A caixa de diálogo New Web Site aparecerá.
3. Em Visual Studio installed templates, clique em ASP.NET Web Site.
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.
O Visual Web Developer cria a pasta e uma nova página chamada
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.
Para executar a página
1. Salve a página.
2. Pressione CTRL+F5 para executar 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.
4. Feche o navegador.
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
Para concluir esta explicação passo a passo, será necessário:
• Visual Web Developer (Visual Studio).
• O .NET Framework.
• 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.
Para criar um site do sistema de arquivos
1. Abra o Visual Web Developer.
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.
4. Na caixa Location, insira 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 a linguagem de programação em que você preferir
para trabalhar.
6. Clique em OK.

Visual Studio 148


O Visual Web Developer cria a pasta e uma nova página chamada
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
1. No Solution Explorer, clique com o botão direito do mouse no nome do seu
site, e então clique Add New Item.
2. Em Visual Studio installed templates, clique em Master Page.
3. Na caixa Name, digite Master1.
4. Selecione a caixa de seleção Place code in separate file .

Observação

Esta explicação passo-a-passo assume que você está usando arquivos code-behind para todas as páginas.
Se você estiver usando uma página ASP.NET Single-file, o código ilustrado nesta explicação passo-a-
passo irá funcionar, mas aparecerá no modo de origem, não em um arquivo separado de código

5. Na lista Language, clique na linguagem de programação que você preferir e


clique Add.
A nova página mestra abre no modo de origem.
Na parte superior da página está uma declaração @ Master em vez de uma
declaração @ PAGE normalmente encontrada na parte superior de páginas
ASP.NET. O corpo da página contém um controle
<asp:contentplaceholder>, que é a área da página mestra onde os
conteúdo substituíveis serão mesclados nas páginas de conteúdo em tempo
de execução. Você irá trabalhar mais com o espaço reservado de conteúdo
posteriormente nesta explicação passo-a-passo.
Dispondo a Página Mestra
A página mestra define como as páginas no seu site aparentam. Ela pode conter
qualquer combinação de textos estáticos e controles. Uma página mestra também
contém um ou mais espaços reservados de conteúdo que designam onde o
conteúdo dinâmico aparecerá quando as páginas forem exibidas.
Nesta explicação passo a passo, você irá usar uma tabela para ajudar você a
posicionar elementos na página. Você iniciará criando uma tabela de layout para
armazenar os elementos da página mestra. Posteriormente, nesta seção, irá
posicionar o controle de espaço reservado de conteúdo que já estiver na página.
Para criar uma tabela de layout para a página mestra
1. Com o arquivo Master1.Master selecionado no modo de exibição de origem,
defina o esquema de destino para validação para o Microsoft Internet Explorer
6.0. Para definir esse valor, você pode usar tanto a lista suspensa na caixa de
ferramentas ou selecionar Options a partir do menu Tools, e clicar em
Validation.

Visual Studio 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.
4. Alterne para modo Design.
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
2. Feche o navegador.
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
1. No Solution Explorer, clique com o botão direito do mouse em
Master1.master, e clique Copy.
2. Clique com o botão direito do mouse no nome do site, e em seguida, clique
em Paste
Uma página mestra é adicionada ao site a Web com o nome Copy of
master1.master.
3. Clique com o botão direito do mouse em Copy of master1.master, clique
em Rename, e denomine a nova página mestra como Master2.master.
4. Abra a Master2.Master e, na diretiva @ Master, altere Master1 para Master2.
A diretiva completa da página vai parecer com o exemplo de código a seguir.
C#
<%@ Master Language="C#" CodeFile="Master2.master.cs" Inherits="Master2" %>

Visual Studio 155


5. Alterne para modo Design.
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
As tarefas ilustradas nesta explicação passo a passo incluem:
• 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
Para concluir esta explicação passo a passo, será necessário:
• Visual Web Developer Microsoft (Visual Studio).
• O .NET Framework.
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.
Para criar um site do sistema de arquivos
1. Abra Visual Web Developer.
2. No menu File, clique New Web Site.
A caixa de diálogo New Web Site aparece.
3. Em Visual Studio installed templates, clique em ASP.NET Web Site.
4. Na caixa Location, insira 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
trabalhar.
6. Clique em OK.
O Visual Web Developer cria a pasta e uma nova página chamada
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
1. Alterne para modo Design.

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.

3. Alterne para modo de origem.


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


1. Pressione CTRL+F5 para executar a página.
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
1. Alterne para modo de origem.
2. Altere a declaração da página:
<%@ Page theme="sampleTheme" %>

Para uma declaração de tema de folhas de estilo:


<%@ Page StyleSheetTheme="sampleTheme" %>

3. Pressione CTRL+F5 para executar a página.


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.
6. Pressione CTRL+F5 para executar a página.
A propriedade ForeColor de Label1 fica azul.
7. Alterne para modo de origem.
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" %>

9. Pressione CTRL+F5 para executar a página.


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
Para concluir esta explicação passo a passo, será necessário:
• 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.

2. Alterne para o modo de exibição Design.


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.
2. Alterne para o modo de exibição Design.
3. Arraste a página de controle de usuário que você criou, SearchUserControl.ascx,
do Solution Explorer para a zona cuja propriedade ID estiver definida como
SidebarZone.

4. Salve a página WebPartsDemo.aspx.


5. Alterne para o modo de visualização Source.
6. Dentro do elemento <asp:webpartzone> da SidebarZone, adicione um
elemento <asp:label> com contendo links, adicione também um atributo Title com
um valor de Search à marca de controle de usuário, conforme mostrado no exemplo a seguir:
<asp:WebPartZone id="SidebarZone" runat="server" headertext="Sidebar"> <zonetemplate>
<asp:label runat="server" id="linksPart" title="My Links"> <a
href="http://www.asp.net">ASP.NET site</a> <br /> <a
href="http://www.gotdotnet.com">GotDotNet</a> <br /> <a
href="http://www.contoso.com">Contoso.com</a> <br /> </asp:label> <uc1:SearchUserControl
id="searchPart" runat="server" title="Search" /> </zonetemplate> </asp:WebPartZone>
7. Salve e feche o arquivo.
Agora você pode testar sua página.

Para testar a página


• Carregue a página em um navegador.
A página exibe as duas zonas. A tela a seguir mostra a página.
Demonstração de Web Parts com duas zonas

Na barra de título de cada controle há uma seta para baixo que fornece acesso a
um menu de ações disponíveis que podem ser executadas em um controle.
Clique no menu de verbos para um dos controles, clique no verbo Minimize e
note que o controle é minimizado. No menu de verbos, clique em Restore e o
controle retornará ao seu tamanho normal.
Habilitando usuários para editar páginas e alterar layout
Web Parts fornece a funcionalidade para usuários alterarem o layout de controles
Web Parts arrastando-os de uma zona para outra. Além de permitir que os usuários
movam controles WebPart de uma zona para outra, você pode permitir que
usuários editem várias características dos controles, inclusive sua aparência, layout
e comportamento. O conjunto de controles Web Parts fornece a funcionalidade
básica para a edição de controles WebPart. Embora você não faça isso nesta
explicação passo a passo, você também pode criar controles de edição
personalizados que permitem que os usuários editem os recursos dos controles
WebPart. Assim como alterar a localidade de um controle WebPart, editar as
propriedades de um controle depende da personalização do ASP.NET para salvar as
alterações feitas pelos usuários.

Visual Studio 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.
4. Alterne para o modo de visualização Source.
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="&nbsp;Display Mode" Font-Bold="true" Font-Size="8" Width="120" />
<asp:DropDownList ID="DisplayModeDropdown" runat="server" AutoPostBack="true"
Width="120" OnSelectedIndexChanged="DisplayModeDropdown_SelectedIndexChanged" />
<asp:LinkButton ID="LinkButton1" runat="server" Text="Reset User State" ToolTip="Reset the
current user's personalization data for the page." Font-Size="8" OnClick="LinkButton1_Click" />
<asp:Panel ID="Panel2" runat="server" GroupingText="Personalization Scope" Font-Bold="true"
Font-Size="8" Visible="false" > <asp:RadioButton ID="RadioButton1" runat="server"
Text="User" AutoPostBack="true" GroupName="Scope"
OnCheckedChanged="RadioButton1_CheckedChanged" /> <asp:RadioButton ID="RadioButton2"
runat="server" Text="Shared" AutoPostBack="true" GroupName="Scope"
OnCheckedChanged="RadioButton2_CheckedChanged" /> </asp:Panel> </asp:Panel> </div>
6. Salve o arquivo, clicando no ícone de gravação na barra de ferramentas, ou selecionando Save no
menu File.

Para permitir que os usuários alterem o layout


1. Abra a página WebPartsDemo.aspx.
2. Alterne para o modo de exibição Design.
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.
7. Alterne para o modo de visualização Source.
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


1. Abra a página WebPartsDemo.aspx.

Visual Studio 172


2. Alterne para o modo de exibição Design.
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.
2. No menu File, clique em New Web Site.
A caixa de diálogo New Web Site aparece.
3. Sob oVisual Studio installed templates, selecione o ASP.NET Web Site.
4. Na caixa de listagem Location , selecione HTTP. Clique em Browse.
A caixa de diálogo Choose Location aparece.
5. Selecione Local IIS.
6. Abra o Local Web Servers.
7. Selecione o Default Web Site.
8. Clique no ícone Create New Web Application ( ) acima da lista de sites

Web e em seguida, nomeie a associação do novo site Web.


9. Clique em Open.
A caixa de diálogo Choose Location fecha.
10. Na caixa Languages, clique a linguagem de programação com a qual você
prefere trabalhar.
A linguagem de programação que você escolher será o padrão para seu site
Web, mas você pode definir as linguagens de programação para cada página
individualmente.
11. Clique em OK na caixa de diálogo New Web Site.
O Visual Web Developer cria o site Web e uma nova página chamada
Default.aspx.
Configurando a Associação
Posteriormente nesta explicação passo a passo você colocará páginas em um
subdiretório protegido. Você deve criar o subdiretório agora para que você possa
configurar a segurança para ele posteriormente na explicação passo a passo.
Para adicionar uma nova pasta ao site Web
1. No Solution Explorer, clique com o botão direito do mouse no nome do seu
site Web e clique em New Folder.
2. Nomear uma pasta MemberPages.
Antes de você trabalhar com a associação do ASP.NET, você deve configurar seu
aplicativo para ativar a associação e configurar os usuários. Você pode usar a
ferramenta Web Site Administration, que fornece uma interface do tipo assistente
para realizar esta configuração.
Para esta explicação passo a passo, você definirá um único usuário.
Para criar um usuário da associação
1. No menu Website, clique em ASP.NET Configuration.
2. Selecione o guia Security, clique o link para Use the security Setup
Wizard to configure security step by step, e em seguida, clique em Next
3. Vá para a etapa 2 do assistente e selecione a opção From the Internet.

Visual Studio 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.
7. Clique em Finish.
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
1. Alterne para ou abra a página Default.aspx.
2. A partir do grupo Login do Toolbox, arraste um controle LoginView para a
página.
O controle LoginView é exibido com seu modelo AnonymousTemplate
aberto. Este modelo permite que você defina o conteúdo que os usuários
verão antes de se conectarem.
3. Clique na área de edição do controle LoginView para ativar a edição.
4. Na área de edição do modelo Anonymous Template do controle
LoginView, digite Você não está autorizado. Clique no link Login para
entrar.
5. No painel LoginView Tasks, na lista Views, clique em
LoggedInTemplate. Se você não conseguir ver o painel LoginView Tasks,
clique com o botão direito do mouse no título do controle LoginView e
selecione Show Smart Tag.
Agora você está definindo o conteúdo que será exibido aos usuários que já
estão autorizados.
6. Clique na área de edição do controle LoginView para ativar a edição, e em
seguida, digite Você está autorizado. Bem-vindo..
7. A partir do gupo Login do Toolbox, arraste o controle LoginName para o
modelo após o texto.
Testando o Login
Agora você pode testar a funcionalidade de login do seu aplicativo.
Para testar o login
1. No Solution Explorer, clique com o botão direito do mouse em
Default.aspx e clique em Set As Start Page.
Isso configura o site para que, ao executar o site Web, a página Default.aspx
apareça primeiro.
2. Pressione CTRL+F5 para executar o site Web.
A ???home page??? (Default.aspx) aparece no navegador, mostrando o link
Login e a mensagem genérica.
3. Clique no link Login.
A página de login que você criou é exibida.

Visual Studio 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.
6. Feche o navegador.
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
1. Alterne para ou abra a página Default.aspx.
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
1. Pressione CTRL+F5 para executar o site Web.
2. Quando a página Default.aspx aparece no navegador, não faça o login. Em
vez disso, clique no link Members page.
Você é redirecionado para a página Login.aspx porque o acesso para a página
para membros foi negada para usuários anônimos.
3. Na página de login, digite o nome de usuário e a senha que você utilizou
anteriormente na explicação passo a passo para se conectar.
Você é redirecionado para a página Members.aspx porque o nome de usuário
que você utilizaou foi autorizado para acessar a página.
4. Feche a janela do navegador.
Criando Novos Usuários
Na primeira parte da explicação passo a passo, você criou um usuário com a
ferramenta Web Site Administration. Essa estratégia é útil se você estiver
trabalhando com uma lista de usuários pequena; por exemplo, se você estiver
criando usuários para uma equipe pequena. Entretando, em muitos sites Web, os
usuários têm permissão para se registrarem. O ASP.NET inclui o controle
CreateUserWizard que executa a mesma tarefa que você executou anteriormente
usando a ferramenta Web Site Administration.
Nesta parte da explicação passo a passo, você adicionará um recurso que permite
aos usuários se registrarem em seu site Web. Para iniciar, você criará uma página
de registro.
Para criar uma página de registro
1. No Solution Explorer, clique com o botão direito do mouse no nome do seu
site Web, clique em Add New Item e adicione uma nova Web Form
chamada Register.aspx.

Observação

Certifique-se de criar a página na raiz do site Web e não na pasta MemberPages.

2. Na página Register.aspx, alterne para o modo Design e digite um texto


estático, como Registro, para a página. Na barra de ferramentas
Formatting, use a lista drop-down Block Format para formatar o texto
como "Heading 1".
3. A partir do grupo Login do Toolbox, arraste um controle
CreateUserWizard para a página.
4. Na janela Properties para o controle CreateUserWizard, defina a
propriedade ContinueDestinationPageUrl para ~/Default.aspx.
Isso configura o controle para que a execução retorne para a home page,
assim que os usuários clicarem em Continue após a criação de um usuário, .
5. A partir do grupo Standard do Toolbox, arraste um controle HyperLink
para a página. Na janela Properties para o controle HyperLink, defina a
propriedade Text para Home e a propriedade NavigateUrl para
~/Default.aspx.

Visual Studio 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
1. Alterne para ou abra a página Default.aspx.
2. Clique com o botão direito do mouse no controle LoginView adicionado
anteriormente, e selecione Show Smart Tag. No painel LoginView Tasks,
selecione AnonymousTemplate da caixa de listagem Views para ativar a
edição no modelo anônimo.
3. A partir do grupo Standard do Toolbox, arraste um controle HyperLink
para um modelo anônimo. Na janela Properties para o controle HyperLink,
defina a propriedade Text para Register e a propriedade NavigateUrl para
Register.aspx. O link Register será exibido somente para os usuários que
não estão autorizados.
Agora você pode testar o processo de registro.
Para testar o registro
1. Pressione CTRL+F5 para executar o site Web e exibir a página Default.aspx.
Por você não estar conectado, a página contendo o link Register é exibida.
2. Clique no link Register.
A página de registro é exibida.
3. Nas caixas de texto, digite um novo nome de usuário, uma senha forte, um
endereço de e-mail e uma pergunta de segurança e de resposta. (Todas as
cinco peças de informação são necessárias.)
4. Clique em Create User.
Um mensagem de confirmação é exibida.
5. Clique o botão Continue.
Você retorna para a home page como um usuário autorizado. Observe que o
link Login foi alterado para Logout e que a informação exibida no controle
Login é da propriedade LoggedInTemplate, não da propriedade
AnonymousTemplate.
6. Clique no link Logout.
A página muda para exibir a informação para os usuários anônimos.
7. Clique no link Login.
8. Insira as credenciais para o usuário que você acabou de criar.
Você está conectado como o novo usuário.
9. Feche a janela do navegador.
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
1. Alterne para ou abra a página Default.aspx.
2. Clique com o botão direito do mouse no controle LoginView e depois clique
em Show Smart Tag. No menu LoginView Tasks, na lista Views, clique
em LoggedInTemplate.
Isso alterna o controle LoginView para o modo de edição para o conteúdo
que será exibido para usuários que estão conectados.
3. A partir do grupo Standard do Toolbox, arraste um controle HyperLink
para a região de edição. Na janela Properties para o controle HyperLink,
defina a propriedade Text para Change password e a propriedade
NavigateUrl para ~/MemberPages/ChangePassword.aspx.
O link Change password será exibido somente aos usuários que estão
conectados, sendo o oposto do link Register que você criou anteriormente.
Agora você pode testar o processo de alteração de senha.
Para testar a alteração de senha
1. Pressione CTRL+F5 para executar o site Web.
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.
7. Clique no link Login.
8. Digite a nova senha.
Você está conectado com a nova senha.
9. Feche a janela do navegador.
Recuperando uma Senha
Ocasionalmente, os usuários esquecerão suas senhas. Você pode adicionar uma
página de recuperação de senha ao seu site Web para que eles possam efetuar
novamente a conexão para seu site. A recuperação de senha pode ter duas formas:
• Você pode enviar aos usuários a senha que eles selecionaram (ou a que você
criou para eles quando você configurou o site). Esta opção requer que o site
armazene a senha usando criptografia reversível.
• Você pode enviar aos usuários uma nova senha, que eles podem alterar
usando a página de alteração de senha que você criou anteriormente. Essa
opção é útil se o site Web armazena senhas usando um esquema de criptografia
não reversível como hashing.

Observação

Retornando uma senha em texto não criptografado usando e-mail não é recomendado para sites que
requerem um nível alto de segurança. Para sites de alta segurança, é recomendável que você retorne
senhas usando criptografia, como o Secure Sockets Layer (SSL).

Por padrão, o sistema de associação do ASP.NET protege senhas por hashing, o que
significa que as senhas não podem ser recuperadas. Portanto, para essa parte da
explicação, seu site Web enviará aos usuários uma nova senha.

Observação

A recuperação de senha requer que o seu site Web possa enviar mensagens de e-mail. Se você não
consegue configurar o seu site Web para enviar email (conforme explicado em "Configurando o
Aplicativo para E-mail" anteriormente), não conseguirá adicionar uma recuperação de senha ao seu site.

Para adicionar recuperação de senha


1. No Solution Explorer, clique com o botão direito do mouse no nome do seu
site Web, clique em Add New Item e adicione uma nova Web Form
chamada RecoverPassword.aspx.

Observação

Certifique-se de criar a página na raiz do site Web, não na pasta MemberPages.

2. Na página RecoverPassword.aspx, alterne para o modo Design digite um


texto estático como Redefinir minha senha para um novo valor. Na barra

Visual Studio 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.
4. A partir do grupo Standard do Toolbox, arraste um controle HyperLink
para a página. Na janela Properties para o controle HyperLink, defina a
propriedade Text para Home e a propriedade NavigateUrl para
~/Default.aspx.
5. Alterne para a página Default.aspx.
6. Clique com o botão direito do mouse no controle LoginView e depois clique
em Show Smart Tag. No menu LoginView Tasks, na lista Views, clique
em AnonymousTemplate.
Isso alterna o controle LoginView para o modo de edição para o conteúdo
que aparecerá para os usuários que não estão autorizados.
7. A partir do grupo Standard do Toolbox, arraste um controle HyperLink
para um modelo. Na janela Properties para o controle HyperLink, defina a
propriedade Text para Forgot your password? e a propriedade
NavigateUrl para ~/RecoverPassword.aspx.
Agora você pode testar a recuperação de senha.
Para testar a recuperação de senha
1. Pressione CTRL+F5 para executar o site Web.
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.
As tarefas ilustradas nesta explicação passo a passo incluem:
• Criar um XML Web Service simples no Visual Web Developer.
• Criar um site em separado que usa o serviço da Web.
Pré-requisitos
Para concluir esta explicação passo a passo, será necessário:
• 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


1. Abra o Visual Web Developer.
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 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.
7. Feche o navegador.
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
1. No menu File, clique em New Web Site.
2. Em Visual Studio installed templates, clique em ASP.NET Web Site.
3. Clique em Browse.
4. Clique em Local IIS.
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(); }

6. Pressione CTRL+F5 para executar a página.


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.
2. Clique em Local IIS.
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


clique em View Code.
O Visual Web Developer abre o arquivo de código para a página.
6. Posicione o ponteiro do mouse na seguinte linha:
C#
double temperature = System.Convert.ToDouble(TemperatureTextbox.Text);

7. Pressione F9 para definir um ponto de interrupção na linha.


Testando a depuração
O site e o serviço da Web estão configurados para a depuração, para que você
agora possa começar a depurar. Você irá iniciar na página Default.aspx e depurar o
código até que o código chame o serviço da Web. O depurador alternará para o
serviço da Web e continuará a depuração através do código.
Para depurar a página e o serviço da Web
1. Pressione F5 para executar a página Default.aspx usando depuração.
A página aparece no navegador.
2. Na caixa, digite um valor, como 100, e clique em Convert.
O Visual Web Developer começa a executar o código da página, mas pára e
realça a linha com o ponto de interrupção sobre ele.
3. Pressione F11 para ir para a próxima linha.
4. Pressione F11 novamente.
Como a linha seguinte chama o serviço da Web, o depurador vai para o
serviço da Web, parando na primeira linha do método FahrenheitToCelsius.
5. Continue pressionando F11.
O depurador avança através do restante do método e retorna para a página
que chamou o método. Se você continuar a depuração, o depurador irá de
volta para o serviço da Web e para o método CelsiusToFahrenheit.
6. Feche o navegador, que também fecha o depurador.
Próximas etapas
Esta explicação passo a passo ilustrou os princípios básicos de criação de um
serviço da Web muito simples e de usá-lo em um aplicativo ASP.NET. Você pode
desejar experimentar serviços da Web com recursos adicionais e mais complexos.
Sugestões para explorações adicionais incluem o seguinte:
• Compreender o processamento que ocorre quando você faz uma chamada
XML Web Service.
Para mais informações, consulte Anatomia do tempo de vida de um XML Web
Service.
• Entender como usar XML Web Services.

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


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

Visual Studio 198


• 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:
<?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.

Visual Studio 199


7. No menu Debug, clique em Delete All Breakpoints.
Implantando o XML Web Service
Para tornar seu XML Web Services disponível para outros, você deve implantá-lo
em um servidor Web que seja acessível para os clientes que você queira dar
suporte. Para distribuir o XML Web Services para um servidor que não seja o
servidor de desenvolvimento, você pode adicionar um projeto Web Setup ou copiar
os arquivos necessários para o servidor de destino. Nesta explicação passo a passo,
você pode escolher como implantar este XML Web Services. Para obter mais
informações, consulte COMO: Implantar Serviços da Web XML no Código
Gerenciado.
Para implantar o XML Web Services usando um projeto Web Setup
1. No menu File, aponte para Add, e clique New Project.
2. Selecionar o nó Other, e o nó Setup and Deployment Projects, e clique
em Web Setup Project.
3. Na caixa Name, digitar TempConvert1WebSetup, e clique OK.

Observação

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

4. No painel esquerdo do File System Editor, selecione Web Application


Folder. Para obter mais informações, consulte File System Editor.
5. No Solution Explorer, clique com o botão direito do mouse em
TempConvert1WebSetup, aponte para Add, e clique Project Output.
6. Na caixa de diálogo Add Project Output Group, selecione Content Files.
Para obter mais informações, consulte Como adicionar e remover Outputs
Project no File System Editor:.
o O grupo Content Files consiste dos seguintes arquivos para o XML Web
Services: Service1.asmx, GLOBAL.asax, e Web.config. Para obter mais
informações, consulte COMO: Implantar Serviços da Web XML no Código
Gerenciado.
7. Clique em OK.
8. No Solution Explorer, clique com o botão direito do mouse no
projetoTempConvert1WebSetup, e no menu de atalho, clique Build.
Isso cria um arquivo do Windows Installer no diretório de projeto local.
Executar este arquivo instala o aplicativo da Web.
Para implantar o XML Web Services, copiando o projeto
1. No Solution Explorer, selecione o projeto TempConvert1.
2. No menu Project, clique em Copy Web Site.
3. Clique no ícone ao lado da caixa suspensa Connect To para abrir a caixa de
diálogo Open Web Site. Navegue para a localidade para a qual você deseja
copiar o projeto.
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.
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:

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#.
Durante o curso desta explicação passo a passo, você irá realizar as atividades a
seguir:
• Criar um serviço XML da Web usando o ASP.NET Web Service modelo de
projeto.
• Implementar o XML Web Services.
• Depurar o serviço da Web XML.
• 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 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á.
Criar projeto serviço XML da Web
Usando o ASP.NET Web Service modelo de projeto, Visual Studio cria
automaticamente um projeto do serviço XML da Web que usa C++.
Para criar um projeto Serviço da Web ASP.NET com C++
1. No menu File, aponte para New, e clique Project para abrir a New Project
caixa de diálogo.
2. Selecione a Visual C++ Projects pasta, e, em seguida, clique no ASP.NET
Web Service ícone.
3. Na caixa Name, digite TempConvert3 e depois clique em OK.
O modelo de projeto fornece automaticamente os arquivos necessários e
referências a suporte um serviço XML da Web.

Dica

No Solution Explorer Consulte o arquivo ReadMe.txt que descreve os projetos e arquivos gerados.

Implementar o serviço da Web XML


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.

Para adicionar um método de XML Web Service


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

6. Salve a solução.
7. No menu Build, clique em Build Solution.
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:
• Start Debugging
• Start Without Debugging
• View in Browser
Como um projeto Visual Studio, este XML Web Services tem configurações
separadas para as versões de lançamento e depuração. Criadas essas configurações
porque você criado este projeto usando o ASP.NET Web Service modelo de
projeto, Visual Studio automaticamente e definir as opções padrão apropriado e
outras configurações. Para obter mais informações, consulte HOW TO: definir
depuração e configurações de versão.
Nessa explicação passo a passo, será colocar um ponto de interrupção no serviço
XML da Web e use o Start Debugging método. Quando o serviço da Web XML
estiver sendo executado, será anexar ao processo do sistema em que estiver sendo
executado para depurá-la. Para obter mais informações, consulte Como Depurar
XML Web Services em Código Não Gerenciado.
Antes da depuração, verifique as configurações de depuração. Para obter mais
informações, consulte Preparação da Depuração: Web Services XML (C++).
Para usar um ponto de interrupção e iniciar o XML Web Services com depuração
1. No menu Debug, selecione New Breakpoint, e selecione Break at
Function.
Na caixa New Breakpoint de diálogo, digite
TempConvert3::TempConvert3Class::ConvertTemperature lado para
Function e clique OK para colocar um ponto de interrupção na declaração
ConvertTemperature de método.
2. No menu Debug, clique em Start Debugging.
Este comando instrui Visual Studio para executar o serviço XML da Web como
ele faria normalmente. O Visual Studio compila o projeto e o implanta no
servidor de desenvolvimento designado. Após a conclusão, o navegador
padrão exibe o arquivo.asmx a partir do servidor de implantação.
Quando você abre um arquivo.asmx em um navegador, o XML Web Services
retorna uma página Service auxiliar que fornece informações sobre o XML
Web Services. Clicar no Service Description Link retorna um documento
XML que contém o descrição do serviço formal do serviço XML Web. Para
obter mais informações, consulte Descrição do XML Web Service.

Visual Studio 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.
6. O XML Web Services responde retornando o valor convertido em um
documento XML semelhante ao seguinte:
<?xml version="1.0" encoding="utf-8" ?> <double
xmlns="http://Walkthrough/XmlWebServices/">100</double>

Para interromper executando o serviço XML da Web e retornar ao editor de


código, no menu Debug, clique em Stop Debugging.
7. No menu Debug, clique em Delete All Breakpoints.
Para obter mais informações, consulte Passo-a-passo: Depuração de um serviço
XML da Web.
Implantando o XML Web Service
Para implantar esse serviço XML da Web, você deve criar um projeto de
implantação.
Para implantar o XML Web Services usando um projeto Web Setup
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

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.

5. No painel esquerdo da guia File System (TempConvert3WebSetup),


selecione Web Application Folder. Para obter mais informações, consulte
Editor do sistema de arquivos.
6. No Solution Explorer, clique com o botão direito do mouse
TempConvert3WebSetup, aponte para Add, e clique em Project Output.
7. Na caixa Add Project Output Group de diálogo, selecione Content Files.
Para obter mais informações, consulte Como adicionar e remover resultados
Project no editor do sistema de arquivos:.
o O grupo arquivos conteúdo consiste os seguintes arquivos para o
serviço da Web XML: TempConvert3.asmx, Global.asax, e Web.config. Para

Visual Studio 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.
Isso cria um arquivo do Windows Installer no diretório do projeto local.
Executar este arquivo em um servidor Web para instalar este serviço da Web
XML.
Para obter mais informações, consulte Implantando aplicativos e componentes.
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#
• 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.
Durante o curso desta explicação passo a passo, você irá realizar as atividades a
seguir:
• Criar um serviço XML da Web usando o modelo do projeto Serviço da Web
Server ATL.
• Implementar o XML Web Services.
• 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 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.
Criar projeto serviço XML da Web
O Visual Studio fornece um modelo de projeto Serviço da Web Server ATL para
ajudá-lo criar serviços da Web XML usando ATL Server. Para obter mais
informações, consulte Criar um Projeto ATL Server.
Para criar um projeto do serviço da Web ATL Server
1. No menu File, aponte para New, e clique Project para abrir a New Project
caixa de diálogo.
2. Selecione a Visual C++ Projects pasta, e, em seguida, clique no ATL
Server Web Service ícone.
3. Na caixa Name, digite TempConvert4.
4. Clique OK Para iniciar o ATL Server Project Wizard.
5. No ATL Server Project Wizard, clique Finish para aceitar os padrões do
projeto. Para obter mais informações, consulte Criar um Projeto ATL Server.

Observação

Você tem a opção de criar uma DLL combinado, que combina a funcionalidade ISAPI com o código do
aplicativo. Esta opção está localizada na página Project Settings do assistente. No entanto, para essa
explicação passo a passo, você irá criar DLLs separados.

6. O assistente cria uma solução, que contém dois projetos separados: um


projeto do manipulador e um projeto de extensão ISAPI.

Visual Studio 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.
Implementar o serviço 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.
Para adicionar um método de XML Web Service
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.

4. Salve a solução.

Visual Studio 208


5. No menu Build, clique em Build Solution.
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 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.
Para implantar o XML Web Services usando um projeto Web Setup
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

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 da File System Editor, selecione Web Application


Folder. Para obter mais informações, consulte Editor do sistema de arquivos.
5. No Solution Explorer, clique com o botão direito do mouse
TempConvert4WebSetup, aponte para Add, e clique em Project Output
6. Na caixa Add Project Output Group de diálogo, selecione Content Files,
Primary output e Debug Symbols. Para obter mais informações, consulte
Como adicionar e remover resultados Project no editor do sistema de
arquivos:.
o O grupo arquivos conteúdo consiste os arquivos restantes para o
serviço XML da Web, tais como TempConvert4.htm e TempConvert4.disco.
o O grupo primário de saída consiste do projeto DLL, TempConvert4.dll,
e suas dependências.
o O grupo símbolos de depuração consiste do arquivo PDB projeto,
TempConvert4.pdb.
7. Clique em OK.
8. No Solution Explorer, clique com o botão direito do mouse
TempConvert4WebSetup novamente, aponte para Add, e clique em
Project Output
9. Na caixa Add Project Output Group de diálogo, alterar o projeto para
TempConvert4Isapi, e selecione Primary output e Debug Symbols. Para
obter mais informações, consulte Como adicionar e remover resultados
Project no editor do sistema de arquivos:.
o O grupo primário de saída consiste do projeto DLL,
TempConvert4Isapi.dll, e suas dependências.
o O grupo símbolos de depuração consiste do arquivo PDB projeto,
TempConvert4Isapi.pdb.
10. Clique em OK.

Visual Studio 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
Isso cria um arquivo do Windows Installer no diretório do projeto local.
Executar este arquivo em um servidor Web para instalar este serviço da Web
XML.
Para obter mais informações, consulte Implantando aplicativos e componentes.
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#
• 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++.
Durante o curso desta explicação passo a passo, você irá realizar as atividades a
seguir:
• Criar um aplicativo do cliente usando o CLR Console Application modelo de
projeto.
• Adicionar uma referência da Web para um XML Web Services.
• Escrever código para acessar o XML Web Services.
• Execute o aplicativo do cliente no modo de depuração.
Para concluir a explicação passo a passo, você deve fornecer o seguinte:
• Uma máquina atendendo aos requisitos encontrado no Requisitos de
hardware do Visual Studio.
• Um serviço XML da Web criado de uma das orientações a seguir:
o Explicação Passo a Passo: Criando um XML Web Services usando
Visual Basic ou Visual C#
o Walkthrough: Criando um serviço da Web XML usando ATL Server
o Passo-a-passo: Criando um XML Web Service usando C++ e o CLR
Criando um projeto cliente de XML Web Services
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


1. No menu File, aponte para New, e clique Project para abrir a New Project
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.
5. Clique OK para criar o projeto.
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

Visual Studio 211


algoritmo predeterminado. A meta do processo é localizar a descrição de serviço,
que é um documento XML que usa o WSDL (Web Services Description Language).
Para obter mais informações, consulte Descoberta de XML Web Service.
A descrição de serviço descreve quais serviços estão disponíveis e como interagir
com os serviços. Sem uma descrição de serviço, é impossível interagir com um XML
Web Services programaticamente. Para obter mais informações, consulte Descrição
do XML Web Service.
O aplicativo precisa um meio para se comunicar com o serviço da Web XML e para
localizá-lo em tempo de execução. Adicionar uma referência da Web ao seu projeto
para o XML Web Services faz isso por gerar uma classe proxy que interfaceia com o
XML Web Services e fornece uma representação local do XML Web Services. Para
obter mais informações, consulte Referências da Web e COMO: Gerar um Proxy de
Serviço da Web XML.
Adicionar uma referência da Web
1. Na Solution Explorer, selecione o TempConvert3Client nó de projeto. No
menu Project, clique em Add Web Reference.
2. Na caixa URL da caixa Add Web Reference de diálogo, digite a URL para
obter o descrição do serviço do serviço XML Web você deseja acessar, such as
http://localhost/TempConvert3WebSetup/TempConvert3.asmx.
Clique no Go botão para recuperar informações sobre o serviço da Web XML.
Ou-
Se o serviço da Web XML existir na máquina local, clique no Web services
on the local machine Link no painel do navegador. Clique no link para o
serviço da Web XML TempConvert3 na lista fornecida para recuperar
informações sobre o serviço da Web XML.
3. Na caixa Web reference name, renomear a referência da Web, a
ConvertSvc Qual é o espaço para nome será usado para esta referência da
Web.
4. Clique Add Reference para adicionar uma referência da Web para o destino
XML Web Service. Para obter mais informações, consulte Como: Adicionar e
remover referências da Web.
O Visual Studio baixa o descrição do serviço e adiciona-o ao seu projeto. Em
seguida, ele gera uma classe de proxy e compila uma DLL do descrição do
serviço. Finalmente, Visual Studio adiciona um novo arquivo WebService.h, de
cabeçalho, ao seu projeto. Este arquivo de cabeçalho referencia espaços para
nome do .NET Framework para usar os Serviços XML da Web e a DLL criado
necessário. Se explorar o diretório do projeto local, você também encontrará
o arquivo de fonte Visual C# para a DLL.
Acessando o XML Web Services
Depois de adicionar uma referência para o serviço da Web XML ao seu projeto, a
próxima etapa é para criar uma instância de classe de proxy do serviço da Web
XML. Você pode acessar os métodos do XML Web Service da mesma maneira que
você acessar métodos qualquer do objeto chamando os métodos da classe de
proxy. Quando o aplicativo chama esses métodos, o código gerado pelo Visual
Studio trata as comunicações entre o aplicativo e o serviço da Web XML.
Acessar o XML Web Services
1. No Solution Explorer, localize TempConvertClient3.cpp na pasta Source
Files e abra este arquivo para edição.

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

3. Salve a solução.
4. No menu Build, clique em Build Solution.
Depurando o cliente de XML Web Services
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
• Start without Debugging
Como um projeto do Visual Studio, este aplicativo tem separadas configurações
para versões liberação e DEBUG. Criadas essas configurações porque você criado
este projeto usando o CLR Console Application modelo de projeto, Visual Studio
automaticamente e definir as opções padrão apropriado e outras configurações.
Para obter mais informações, consulte HOW TO: definir depuração e configurações
de versão.
Nessa explicação passo a passo, será colocar um ponto de interrupção no aplicativo
e use o Start Debugging método.
Antes da depuração, verifique as configurações de depuração. Para obter mais
informações, consulte Preparação da depuração: Projetos de console.
Para utilizar um ponto de interrupção e iniciar o aplicativo com depuração
1. No Editor do código, coloque o cursor na linha de código que chama a função
proxy:
double dCelsius = proxy->ConvertTemperature(dFahrenheit);

2. Pressione F9 para colocar um ponto de interrupção nesta linha de código.


ou ——
Clique à esquerda dessa linha de código na margem indicador.
Para obter mais informações, consulte COMO: Depurar Código no Editor.
3. No menu Debug, clique em Start Debugging.
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
de tarefas. Para obter mais informações, consulte Explicação detalhada sobre
o depurador e Exibindo Dados no Depurador.
5. No menu Debug, clique Continue para continuar o processamento.
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.
6. No menu Debug, clique em Delete All Breakpoints.

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++.
Durante o curso desta explicação passo a passo, você irá realizar as atividades a
seguir:
• Criar um aplicativo do cliente usando o modelo Project Win32.
• Adicionar uma referência da Web para um XML Web Services.
• Escrever código para acessar o XML Web Services.
• Execute o aplicativo do cliente no modo de depuração.
Para concluir a explicação passo a passo, você deve fornecer o seguinte:
• Uma máquina que atenda aos requisitos encontrado no Requisitos de
hardware do Visual Studio.
• Um serviço XML da Web criado de uma das orientações a seguir:
o Explicação Passo a Passo: Criando um XML Web Services usando
Visual Basic ou Visual C#
o Walkthrough: Criando um serviço da Web XML usando ATL Server
o Passo-a-passo: Criando um XML Web Service usando C++ e o CLR
Criando um projeto cliente de XML Web Services
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


1. No menu File, aponte para New, e clique Project para abrir a New Project
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.
3. Clique em Finish.

Visual Studio 215


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.
O descrição do serviço ou contrato, descreve quais serviços estão disponíveis e
como interagir com os serviços. Sem uma descrição de serviço, é impossível
interagir com um XML Web Services programaticamente. Para obter mais
informações, consulte Descrição do XML Web Service.
O aplicativo deve ter um meio para se comunicar com o serviço da Web XML e para
localizá-lo. Adicionar uma referência da Web ao seu projeto para o XML Web
Services faz isso por gerar uma classe proxy que interfaceia com o XML Web
Services e fornece uma representação local do XML Web Services. Para obter mais
informações, consulte Referências da Web.
Adicionar uma referência da Web
1. No menu Project, clique em Add Web Reference.
2. Na caixa URL da caixa Add Web Reference de diálogo, digite a URL para
obter o descrição do serviço do serviço XML Web você deseja acessar, such as
http://localhost/TempConvert4/TempConvert4Service.asmx. Clique
no botão Go para recuperar informações sobre o XML Web Services.
Ou-
Se o XML Web Services está na máquina local, clique no link Web services
on the local machine no painel do navegador. Clique no link para o serviço
da Web XML TempConvert4 na lista fornecida para recuperar informações
sobre o serviço da Web XML.
3. Na caixa Web reference name, renomeie a referência da Web para
ConvertSvc, que é o namespace que você usará para essa referência da
Web.
4. Clique Add Reference para adicionar uma referência da Web para o destino
XML Web Service. Para obter mais informações, consulte Como: Adicionar e
remover referências da Web.
O Visual Studio gera um novo arquivo de cabeçalho mas não adiciona-lo para
o projeto. No entanto, ele não salvar o arquivo de cabeçalho gerado para a
pasta do projeto. O nome do arquivo de cabeçalho depende do serviço da
Web XML você optar por acessar. Este arquivo de cabeçalho é re-Generated
sempre que você criar o projeto. Para obter o nome correto do arquivo de
cabeçalho, examine o conteúdo da seção janela saída do log de compilação
(BuildLog.htm no diretório Arquivos intermediário) ou Output Window o. O
nome de arquivo correto aparece em uma linha que lembra o seguinte:
/out:ConvertSvc.h. Para exibir no menu View Aponte para Other Windows e
clique em Output. o Output Window,
Para obter mais informações, consulte Como: Adicionar e remover referências da
Web.
Acessando o XML Web Services

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.
Acessar o XML Web Services
1. No Solution Explorer, localize stdafx.h na pasta Header Files e abra este
arquivo para edição.
2. Adicione o seguinte # definir instruções (em negrito) após o # existente
definir instrução WIN32_LEAN_AND_MEAN:
#define WIN32_LEAN_AND_MEAN // Disable client timeout for testing. Default is 10000
milliseconds. #define ATL_SOCK_TIMEOUT INFINITE // Minimum system requirements are
Windows 98, Windows NT 4.0, or later #define _WIN32_WINDOWS 0x0410

3. Add the following #include statements after the existing #include for
<atlbase.h>:
#include "ConvertSvc.h" #include <conio.h> #include <iostream>

Observação

O nome do arquivo de cabeçalho gerado quando adicionando uma referência da Web pode diferir daquele
mostrado acima como ConvertSvc.h. Para obter o nome correto do arquivo de cabeçalho, examine o
conteúdo da seção janela saída do log de compilação (BuildLog.htm no diretório Arquivos intermediário)
ou Output Window o. O nome de arquivo correto aparece em uma linha que lembra o seguinte:
/out:ConvertSvc.h. Para exibir no menu View Aponte para Other Windows e clique em Output. o
Output Window,

4. No Solution Explorer, localize TempConvertClient4.cpp na pasta Source


Files e abrir este arquivo para edição.
5. Primeiro, você criará uma instância da classe de proxy do serviço da Web
XML. Em seguida, você irá levar um valor, que o console fornece, e fazer uma
chamada ao método do serviço ConvertTemperature da Web XML
chamando o método na classe proxy. Você irá exibir o valor retornado pelo
serviço da Web XML no console. Insira o código a seguir:

Observação

O código a seguir usa uma classe denominada TempConvert4Service::CTempConvert4Service.


Aponte para o arquivo de cabeçalho gerado na sua pasta do projeto para determinar o nome de classe
adequado para o serviço da Web XML e substitua-onde
TempConvert4Service::CTempConvert4Service. aparece o código abaixo

6. #include "stdafx.h" void AccessService(){ using namespace std; double dFahrenheit = 0.0;
double dCelsius = 0.0; TempConvert4Service::CTempConvert4Service ws; while (1){ cout <<
"Enter a temperature in degrees Fahrenheit: "; cin >> dFahrenheit; if (!cin.good()){ cout << "Not a
temperature" << endl; break; } HRESULT hr = ws.ConvertTemperature(dFahrenheit, &dCelsius);
if (SUCCEEDED(hr)) cout << dFahrenheit << " F = " << dCelsius << " C\n" << endl; else cout <<

Visual Studio 217


"An error occurred: " << hr << endl; } } int _tmain(int argc, _TCHAR* argv[]){ if
(SUCCEEDED(CoInitialize(NULL))){ AccessService(); CoUninitialize(); } return 0; }

7. Salve a solução.
8. No menu Build , clique em Build Solution.
Depurando o cliente de XML Web Services
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)
• Start without Debugging
Como um projeto do Visual Studio, este aplicativo tem separadas configurações
para versões liberação e DEBUG. Criadas essas configurações porque você criado
este projeto usando o modelo do projeto Project Win32, Visual Studio
automaticamente e definir as opções padrão apropriado e outras configurações.
Para obter mais informações, consulte HOW TO: definir depuração e configurações
de versão.
Nessa explicação passo a passo, será colocar um ponto de interrupção no aplicativo
e use o Start (with Debugging) método.
Para utilizar um ponto de interrupção e iniciar o aplicativo com depuração
1. No menu Debug, clique em New Breakpoint.
Na guia Function, digite AccessService na caixa Function e clique OK para
colocar um ponto de interrupção na declaração AccessService de método.
2. No menu Debug , clique em Start.

Dica

é F5 o atalho do teclado padrão para Start.

3. Este comando instrui Visual Studio para executar o aplicativo no depurador.


O Visual Studio compila o projeto e o implanta no servidor de
desenvolvimento designado. Após a conclusão, o navegador padrão exibe o
arquivo.asmx a partir do servidor de implantação.
4. Para interromper a execução do XML Web Service e retornar para o Code
Editor, feche o navegador.
ou ——
No menu Debug, clique em Stop Debugging.

Dica

é SHIFT+F5 o atalho do teclado padrão para Stop Debugging.

5. Na janela do console, digite o número 212 e pressione ENTER.

Visual Studio 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
de tarefas. Para obter mais informações, consulte Explicação detalhada sobre
o depurador e Exibindo Dados no Depurador.
6. No menu Debug, clique Continue para continuar o processamento.

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
A fim de concluir este explicação passo a passo, será necessário:
• 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


5. No Visual Studio, abra o Solution Explorer e selecione uma solução ou
projeto a ser ligado.
6. No menu File, clique em Source Control, depois em Change Source
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
5. No Visual Studio, abra o Solution Explorer e selecione uma solução ou
projeto a ser desacoplado.
6. No menu File, clique em Source Control, depois em Change Source
Control.
7. Na caixa de diálogo Change Source Control, clique em Unbind.
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


5. No Visual Studio, abra o Solution Explorer.
6. Clique em um caminho inválido na coluna Enter Working Copy Location
Here.
7. Clique no botão de reticências (…)
8. Digite um caminho válido, por exemplo, http://<host local>/pasta1, e clique
em OK. Se a pasta ainda não existir, o Visual Studio criará uma.

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


Conforme descrito em Introdução ao Controle de Código Fonte, uma solução no
Visual Studio pode ter um ou mais vínculos com o controle de código fonte. Uma
conexão é criada automaticamente sempre que um item é vinculado ao controle de
código fonte conforme descrito em Como vincular ou desvincular uma solução ou
um projeto. Pode-se criar uma conexão manualmente conforme descrito neste
tópico.
Se você desconectar seu computador da rede ou perder a conexão por alguma
outra razão, você deve desconectar temporariamente os vínculos da solução a fim
de editar os projetos e os arquivos nela contidos. Quando você desconecta uma
solução do controle de código fonte, o único comando básico que você pode usar é
o comando de check-out. Ao realizar o check-out de um item desconectado, a cópia
local do item, contida na sua pasta de trabalho, torna-se editável. Quando for
possível acessar o banco de dados novamente, você pode reconectar a solução e
sincronizar sua cópia local com a cópia mestre mais recente.

Procedimentos
Para conectar uma solução ou um projeto ao controle de código fonte
5. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem
conectados.
6. No meu File , clique em Source Control e depois em Change Source
Control.
7. Na caixa de diálogo Change Source Control, clique em Connect.
Visual Studio 238
8. Clique em OK.
Para desconectar uma solução ou projeto de controle de código fonte
5. No Visual Studio, abra a janela Solution Explorer e selecione os itens a serem
desconectados.
6. No menu File, clique em Source Control e depois em Change Source
Control.
7. Na caixa de diálogo Change Source Control, clique em Disconnect.
8. Clique em OK.

COMO: copiar um item sob controle de origem


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

Observação

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

Para copiar um projeto sob controle de origem


8. No Visual Studio, abra o Solution Explorer.
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


8. No Visual Studio, abra o Solution Explorer.
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
5. No Visual Studio, no menu Tools, clique em Options.
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


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

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
5. No Visual Studio, no menu Tools, clique em Options.
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


5. No Visual Studio, no menu Tools, clique em Options.
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


5. No Visual Studio, no menu Tools, clique em Options.
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.
11. No menu File, clique em Source Control, depois em Change Source
Control.
12. Na caixa de diálogo Change Source Control, clique em Unbind.
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


3. No Visual Studio, abra o Solution Explorer.
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
7. No Visual Studio, no menu File, clique em Open.
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


6. No Visual Studio, no menu File, clique em Open.
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


10. No Visual Studio, abra o Solution Explorer.
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


4. No Visual Studio, no menu Tools, clique em Options.
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.

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

Acesso à caixa de diálogo


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

Visual Studio 249


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.

Caixa de diálogo Access


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

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

Acesso à caixa de diálogo


No Visual Studio, selecione um item no Solution Explorer. No menu File, clique em
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
Identifica colunas para exibição e a ordem na qual elas são exibidas.
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
Altera a ordem de classificação das colunas exibidas.
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
Especifica um comentário a ser associado com a operação de check-in.
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
Altera a ordem de classificação das colunas exibidas.
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
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


Recupera a versão mais recente de todos os itens quando você abre uma
solução ou projeto.
Manter itens check-out ao verificar na
Especifica que itens em processo de check-in devem permanecer com check-
out para você. Se você desejar alterar esta opção para um check-in

Visual Studio 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
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
operação de salvar.

Configurações de ambiente controle de origem


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

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


Avançadas
Permite que você defina opções adicionais para usar o plug-in de controle de
origem . O botão Advanced só está disponível quando um plug-in de
controle de origem válido está instalado no computador local. As
configurações avançadas são específicas para o plug-in.
Identificação de logon
Especifica o nome de usuário para efetuar logon no plug-in de controle de
origem. Se seu plug-in der suporte, esse nome será colocado
automaticamente na caixa de diálogo de logon usada pelo plug-in de controle
de origem para acessar o servidor. Para ativar essa opção, desative logons
de usuário automáticos do seu plug-in de controle de origem, e reinicie o
Visual Studio.

Observação

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

Executar atualizações de status em segundo plano


Atualiza automaticamente os ícones de controle de origem no Solution
Explorer à medida que o status de item se altera. Se você tiver atrasos ao
executar operações intensivas no servidor, especialmente quando abrir uma

Visual Studio 255


solução ou projeto do controle de origem, desmarcar esta opção pode
melhorar o desempenho.
Configurações plug-in
Especifica o nome do plug-in de controle de origem para o qual você está
fazendo configurações.

Caixa de diálogo Source Control


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

Acesso à caixa de diálogo


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.

Acesso à caixa de diálogo


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

Observação

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

Columns
Identifica as colunas a serem exibidas e a ordem na qual elas são exibidas.
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
Altera a ordem de classificação das colunas de exibição.
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
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 259


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
7. No menu Tools, escolha Import and Export Settings.
8. Na Welcome to the Import and Export Settings Wizard Página, clique
em Import selected environment settings e clique em Next.
9. Na página Save Current Settings, selecionar Yes, save my current
settings, e clique em Next
10. No Which collection of settings do you want to import, selecione uma
coleção configurações na lista e clique em Next.
11. 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.
12. Clique em Finish.
A Reset Complete página lista os erros associados a redefinindo as
configurações com Details.

Visual Studio 260


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
8. No menu Tools, escolha Import and Export Settings.
9. Na Welcome to the Import and Export Settings Wizard Página, clique
em Export selected environment settings e clique em Next.
10. 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.

11. No What do you want to name your settings file, digite um nome para o
arquivo de configurações.
12. 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.
13. Clique em Finish.
14. Na página Export Complete, examine os erros associados à exportação as
configurações com Details.
Importar um arquivo.vssettings
Após ter criado um arquivo.vssettings, você pode usar esse arquivo em outros
computadores ao importar esse arquivo para outra instalação do Visual Studio.
Você também pode importar arquivos de configuração criados por outros usuários e
aplicar essas configurações para o Visual Studio.
Se você está importando o arquivo configurações contém todas as categorias
configurações possíveis, importar esse arquivo completamente substitui as
configurações existentes. Importar o arquivo se um arquivo de configurações

Visual Studio 261


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
9. No menu Tools, escolha Import and Export Settings.
10. Na Welcome to the Import and Export Settings Wizard Página, clique
em Import selected environment settings e clique em Next.
11. 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.
12. 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.
13. 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.

14. Clique em Finish.


15. Na caixa Save Current Settings de diálogo, decidir se deve ou não para
salvar as configurações atuais.
16. 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
6. No menu Tools, escolha Options
7. Na pasta Environment, escolha Import and Export Settings.

Visual Studio 262


8. Na Automatically save my settings to this file, digite uma pasta
compartilhada ou clique Browse para localizar um compartilhamento de rede.
9. Clique em OK.
10. 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
6. Partir do Tools menu, escolha Options.
7. Na pasta Environment, escolha Import and Export Settings.
8. Selecione Use team settings file.
9. Insira um UNC ou caminho local, ou clique Browse para localizar o
arquivo.vssettings de grupo.
10. 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 263


Escolha Configurações para exportar, importar e exportar
configurações Assistente
Use esta página do Assistente para configurações a importação e exportação para
especificar algumas ou todas as suas configurações atuais ser exportados para um
arquivo para uso em outros computadores. Você pode acessar este assistente a
partir do Tools menu clicando Import and Export Settings.
• COMO: Compartilhar configurações entre computadores
Which settings do you want to export?
Selecione para exportar todas as configurações, ou especificar um sub-set
das configurações por categoria ou item de categoria.

Observação

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

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


Assistente
Use esta página do Assistente para configurações a importação e exportação para
especificar o nome e local do arquivo que irá conter as configurações exportadas.
Você pode acessar este assistente a partir do Tools menu clicando Import and
Export Settings.
COMO: Compartilhar configurações entre computadores
What do you want to name your settings file?
Digite um nome personalizado para as configurações exportadas.
Store my settings file in this directory.
Especifica o diretório padrão no qual as configurações exportadas serão
salvos. Clique Browse para especificar uma pasta personalizada.

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


configurações
Use esta página do Assistente para configurações a importação e exportação para
salvar as configurações ativos antes de importar novas configurações. Você pode
acessar este assistente a partir do Tools menu clicando Import and Export
Settings.
COMO: Compartilhar configurações entre computadores
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 264


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
Use esta página do Assistente para configurações a importação e exportação para
especificar a coleção Configurações você pretende importar. Você pode acessar este
assistente a partir do Tools menu clicando Import and Export Settings.
• COMO: Compartilhar configurações entre computadores
Which settings do you want to import?
Selecione uma coleção na lista, ou clique Browse para localizar uma coleção
diferente para importar.
Description
Exibe informações sobre a coleção configurações que são otimizadas para.
Somente disponível para Default Settings.

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


Assistente configurações exportação
Use esta página do assistente Importar e exportar configurações para especificar
uma coleção configurações predefinidos ou uma coleção configurações
personalizadas você deseja importar para uso no IDE. Você pode acessar este
assistente a partir do Tools menu clicando Import and Export Settings.
• Como: Alterar configurações selecionadas
Which collection of settings do you want to import?
Lista as coleções configurações disponíveis. Clique Browse para navegar
para uma coleção configurações que não aparece na lista.
Description
Exibe informações sobre a coleção configurações que são otimizadas para.
Para obter mais informações sobre coleções configurações predefinidas,
consulte Configurações do Visual Studio.

Visual Studio 265


<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 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 ,
clique em Properties.
2. Clique na Application Guia.
3. No campo Assembly Name, digite o nome para o seu aplicativo.

COMO: alterar o namespace para um aplicativo


A propriedade Root Namespace define o namespace raiz para todos os arquivos
no projeto. Por exemplo, se você definir o namespace raiz para Projeto1, e você
tiver uma classe Classe1 fora de qualquer namespace em seu código, o seu
namespace seria Projeto1.Classe1. Se você tiver uma Classe2 em um namespace
Order no código, seu namespace seria Projeto1.Order.Classe2.

Também é possível limpar a propriedade Root Namespace, a qual permite que


você especifique manualmente a estrutura do namespace do seu projeto. Para mais
informações, consulte Declaração de namespace.

Para alterar o namespace de um projeto


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guia Application.
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 .
2. Clique na guia Application.
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).
2. Clique na guia Application.
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.
2. Clique na guia Application.
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


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
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
1. Com um projeto selecionado no Solution Explorer, no menu Project, clique
em Properties.
2. Clique na guia Application.
3. Desmarque a caixa de seleção Enable XP visual styles.

Para ativar os estilos visuais do Windows XP


1. Com um projeto selecionado no Solution Explorer, no menu Project, clique
em Properties.
2. Clique na guia Application.
3. Marque a caixa de seleção Enable XP visual styles.

Observação

Estilos visuais são ativados por padrão.

COMO: Especificar comportamento de instâncias para um aplicativo


Observação

Este tópico se aplica somente aos projetos do Visual Basic.

Os aplicativos criados com Visual Basic são, por padrão, aplicativos de múltiplas
instâncias; os usuários podem iniciar várias instâncias do aplicativo compilado. Em
alguns casos, você pode impedir os usuários de iniciar várias instâncias do seu
aplicativo. Isso pode ser feito marcando a propriedade Make Single Instance
Application para o seu projeto, acessível da página Application do Project
Designer.
Quando a caixa de seleção Make Single Instance Application está marcada,
somente uma única instância do aplicativo compilado é permitida. Se um usuário
tentar iniciar uma segunda instância, o foco é deslocado para a instância que já
está sendo executada e o evento StartupNextInstance é destacado.

Para criar um aplicativo de instância única


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guia Application.
3. Marque a caixa de seleção Make single instance application.

Para criar um aplicativo de múltiplas instâncias


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guia Application.
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

Este tópico se aplica somente para os projetos do Visual Basic.

Aplicativos baseados no Visual Basic usam autenticação do Windows para identificar


o usuário conectado no momento. Essas informações podem ser recuperadas em
tempo de execução usando o objeto My.User. Para informações sobre
programação com o objeto My.User, consulte Acessando dados do usuário. Em tais
casos, defina a Authentication mode. para autenticação Windows.
Em algumas situações, convém escrever seu próprio código para autenticar
usuários, ao invés de usar os métodos de autenticação padrão do Windows. Em tais
casos, defina a Authentication mode para autenticação Application-defined.

Para ativar a autenticação personalizada (Application-DEFINED)


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guia Application.
3. Na lista suspensa Authentication mode, selecione a autenticação
Application-defined.
Você precisará fornecer seu próprio código de autenticação.

Para usar autenticação do Windows


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guia Application.
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

Este tópico se aplica somente para os projetos do Visual Basic.

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


1. Com um projeto selecionado no Solution Explorer (Explorer de Solução),
no menu Project (Projeto), clique em Properties (Propriedades).
2. Clique na guia Application.
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


1. No Solution Explorer, clique duas vezes no nó My Project do projeto.
2. No Project Designer, clique na guia References.
3. Na lista References, selecione a referência que deseja remover.
4. Clique no botão Remove.

Dica

Você também pode verificar seu projeto procurando referências não utilizadas e remover todas elas de
uma vez. Para mais informações, consulte COMO: Remover referências não usadas.

Para definir um caminho de referência


1. No Solution Explorer, clique duas vezes no nó My Project do projeto.
2. No Project Designer, clique na guia References.

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.
2. No Project Designer, clique na guia References.
3. Na lista Imported Namespaces, selecione a caixa de seleção para o
namespace que você deseja adicionar.

Observação

Para ser importado, o namespace deve estar em um componente referenciado. Se o namespace não
aparecer na lista, você precisará adicionar uma referência para o componente que o contém. Para mais
informações, consulte COMO: Adicionar ou remover referências no Visual Studio.

Para remover um namespace importado


1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.
2. No Project Designer, clique na guia References.
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
1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.
2. No Project Designer, clique na guia References.
3. Na caixa de texto abaixo da lista Imported Namespaces, digite o nome
completo do namespace que deseja importar, incluindo o espaço para o
namespace raiz.
4. Clique no botão Add user import para adicionar um namespace à lista
Imported Namespaces

Observação

O botão Add user import será desativado se o namespace corresponde a um já na lista; você não pode
adicionar uma importação duas vezes.

Para atualizar uma importação de usuário


1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.
2. No Project Designer, clique na quia References .
3. Na lista Imported Namespaces, selecione o namespace que você deseja
alterar.
4. Na caixa de texto abaixo da lista Imported Namespaces, digite o nome
para o novo namespace.
5. Clique no botão Update user import para atualizar o namespace na lista
Imported Namespaces.

COMO: Remover Referências Não Usadas


Para reduzir o tamanho do seu aplicativo, você pode desejar remover referências a
componentes que são na verdade não são chamados pelo seu código. Isso pode ser
feito usando a caixa de diálogo Unused References, acessível a partir da página
References do Project Designer

Para remover referências não utilizados


1. No Solution Explorer, clique duas vezes com o nó My Project do projeto.
No Project Designer, clique na guia References.
2. Clique no botão Unused references para abrir a caixa de diálogo Unused
References
O projeto é varrido, e a caixa de diálogo é preenchida com uma lista de
referências que não estão sendo referenciadas no seu código.

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


1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.
2. No Project Designer, selecione a guia References.
3. Selecione um componente referenciado na lista References.
As propriedades associadas a essa referência aparecem numa lista na janela
Properties.
4. Selecione Copy Local da coluna esquerda, e seguida, clique na seta da
coluna direita para alterar o valor para True.

Para definir a propriedade Copy Local como False


1. No Solution Explorer, clique duas vezes no nó My Project para o projeto.
2. No Project Designer, selecione a guia References.
3. Selecione um componente referenciado na lista References
As propriedades associadas a essa referência aparecem numa lista na janela
Properties.
4. Selecione Copy Local da coluna esquerda, e seguida, clique na seta na
coluna direita para alterar o valor para False.

Gerenciando propriedades de depuração


As propriedades de depuração que definem o comportamento da depuração, como
ação de inicício, opções de início, e depuração remota são definidas no painel

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


2. Selecione a guia Resources.
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.
2. Selecione a guia Resources.
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


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
2. Clique na guiaResources. Na barra de ferramentas Resource Designer,
aponte para a lista suspensa, clique na seta, e certifique-se de que ele esteja
definido como Strings (que é o padrão). Uma grade de configurações
aparecerá, exibindo as seqüências de caracteres mantidas por essa instância
do Resource Designer.
3. Clique na coluna Name da última linha da grade, que está marcada com um
asterisco (*).
4. Na coluna Name, insira um nome para a seqüência de caracteres.
5. Na coluna Value, insira a seqüência de caracteres a ser usada como um
recurso.
6. Opcionalmente, digite um comentário na coluna Comment.

Observação

Comentários não são compilados no aplicativo; eles estão disponíveis somente em tempo de projeto.

Para remover um recurso de seqüência de caracteres


1. Com um projeto selecionado no Solution Explorer, no menu Project ,
clique em Properties.
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


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


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


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


1. Com um projeto selecionado no Solution Explorer (Explorer de Solução),
no menu Project (Projeto), clique em Properties (Propriedades).
2. Clique na guia Resources.
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.<