Apostila Visual C# (Consolidada)_pt-br

Prévia do material em texto

Visual C# Consolidado 1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Nível I - Iniciante 
 
 
Autor: Elzevir Jr. 
Janeiro, 2007 
 
 
 
 
Visual C# Consolidado 2
ÍNDICE 
VISUAL C#......................................................................................................................................................................16 
GUIA DE INTRODUÇÃO AO VISUAL C#......................................................................................................17 
GUIA DA DOCUMENTAÇÃO DO VISUAL C#....................................................................................................................17 
INTRODUÇÃO À LINGUAGEM C# E AO .NET FRAMEWORK ............................................................................................18 
O QUE HÁ DE NOVO NO VISUAL C# 2005.......................................................................................................................20 
O QUE HÁ DE NOVO NA C# 2.0 IDIOMA E COMPILER......................................................................................................22 
ATUALIZANDO APLICATIVOS VISUAL C# PARA VISUAL STUDIO 2005..........................................................................24 
CRIANDO SEU PRIMEIRO APLICATIVO C# .....................................................................................................................25 
USANDO STARTER KITS C#...........................................................................................................................................26 
RECURSOS DE AJUDA ADICIONAIS (VISUAL C#)...........................................................................................................26 
COMO FAZER EM C# .....................................................................................................................................................27 
USANDO O IDE DO VISUAL C# .......................................................................................................................29 
INTRODUÇÃO À IDE (VISUAL C#).................................................................................................................................29 
CRIANDO UM PROJETO (VISUAL C#).............................................................................................................................31 
PROJETANDO UMA INTERFACE DE USUÁRIO (VISUAL C#) .............................................................................................34 
O INTELLISENSE ...........................................................................................................................................................36 
LISTAS DE CONCLUSÃO .................................................................................................................................................37 
INFORMAÇÕES RÁPIDAS ................................................................................................................................................37 
MEMBROS DA LISTA......................................................................................................................................................37 
INFORMAÇÕES DE PARÂMETRO .....................................................................................................................................37 
ADICIONANDO DIRETIVAS 'USING' .................................................................................................................................38 
REFATORAÇÃO..............................................................................................................................................................38 
TRECHOS DE CÓDIGO ....................................................................................................................................................38 
SUBLINHADO ONDULADO..............................................................................................................................................38 
AJUDA DE LEGIBILIDADE ..............................................................................................................................................39 
Estrutura de tópicos ................................................................................................................................................39 
COLORIZAÇÃO ..............................................................................................................................................................39 
NAVEGANDO E PROCURANDO.........................................................................................................................40 
EXIBIÇÃO DE CLASSE ....................................................................................................................................................40 
NAVEGAÇÃO CTRL+TAB............................................................................................................................................40 
BARRAS DE NAVEGAÇÃO ..............................................................................................................................................41 
LOCALIZAR EM ARQUIVOS ............................................................................................................................................42 
CRIANDO E DEPURANDO (VISUAL C#) .....................................................................................................43 
MODELAGEM E ANÁLISE DE CÓDIGO (VISUAL C#)............................................................................46 
ADICIONANDO E EDITANDO RECURSOS (VISUAL C#) ....................................................................49 
OBTENDO AJUDA (VISUAL C#) ......................................................................................................................51 
IMPLANTANDO APLICATIVOS C# .................................................................................................................54 
RECURSOS DO CODE EDITOR DO VISUAL C#.................................................................................................................54 
Refatoração .............................................................................................................................................................54 
TRECHOS DE CÓDIGOS (C#)...........................................................................................................................................55 
CÓDIGO COLORIZATION................................................................................................................................................56 
METADADOS COMO FONTE............................................................................................................................................58 
CONFIGURAÇÕES DO IDE VISUAL C# ...........................................................................................................................59 
ATALHOS DE TECLADO VISUAL C#...............................................................................................................................60 
Teclas de atalho.......................................................................................................................................................60 
TECLAS DE ATALHO PADRÃO CONFIGURAÇÕES DEVELOPMENT GERAIS ........................................................................62 
ESCREVENDO APLICATIVOS COM O VISUAL C# ..................................................................................64 
USANDO A BIBLIOTECA DE CLASSE DO .NET FRAMEWORK (VISUAL C#).....................................................................64 
CRIANDO APLICATIVOS DO WINDOWS FORMS (VISUAL C#) .........................................................................................65 
CRIANDO APLICATIVOS DE CONSOLE (VISUAL C#) ......................................................................................................65 
ACESSAR E EXIBIR DADOS (VISUAL C#)........................................................................................................................65CRIANDO APLICATIVOS MÓVEIS E INCORPORADOS (VISUAL C#) .................................................................................66 
Visual C# Consolidado 3
CRIANDO E ACESSANDO SERVIÇOS DA WEB (VISUAL C#)...........................................................67 
CRIANDO COMPONENTES (VISUAL C#)....................................................................................................68 
DESENVOLVENDO NA PLATAFORMA DO OFFICE (VISUAL C#) ......................................................................................68 
Programação do Office (Como Fazer em C#).........................................................................................................68 
Como: Atualizar soluções das Ferramentas do Visual Studio para o Office ..........................................................69 
O EXCEL USANDO EXPLICAÇÕES PASSO-A-PASSO.............................................................................71 
COLETA DE DADOS USANDO UM FORMULÁRIO DO WINDOWS WALKTHROUGH.............................................................71 
ALTERANDO PLANILHA FORMATAÇÃO USANDO CONTROLES CHECKBOX WALKTHROUGH: .........................................73 
EXIBINDO TEXTO EM UMA CAIXA DE TEXTO EM UMA PLANILHA USANDO UM BOTÃO WALKTHROUGH: ........................76 
PROGRAMAÇÃO CONTRA EVENTOS DE UM CONTROLE NAMEDRANGE WALKTHROUGH:...............................................78 
PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE .....................................81 
PASSO-A-PASSO: LIGANDO UMA CÉLULA DE PLANILHA A UM CAMPO DE BANCO DE DADOS..........................................84 
WALKTHROUGH: VINCULAÇÃO CÉLULAS PARA VÁRIAS COLUNAS EM UMA TABELA .....................................................87 
CRIANDO UMA RELAÇÃO MESTRE / DETALHES USANDO UM DATASET EM CACHE WALKTHROUGH: .............................91 
WALKTHROUGH: ATUALIZANDO UM GRÁFICO EM UMA PLANILHA USANDO BOTÕES DE OPÇÃO ....................................94 
VINCULAÇÃO DE DADOS PARA CONTROLES EM UM PAINEL AÇÕES DO EXCEL WALKTHROUGH: ..................................99 
IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM MANIFESTO DEPLOYMENT WALKTHROUGH: ..........103 
IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM ARQUIVO DO WINDOWS INSTALLER WALKTHROUGH:
....................................................................................................................................................................................107 
PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE ...................................112 
O WORD USANDO EXPLICAÇÕES PASSO-A-PASSO ..........................................................................116 
WALKTHROUGH: CHANGING DOCUMENT FORMATAÇÃO USANDO CONTROLES CHECKBOX .......................................116 
EXIBINDO TEXTO EM UMA CAIXA DE TEXTO EM UM DOCUMENTO USANDO UM BOTÃO WALKTHROUGH:....................119 
WALKTHROUGH: CRIANDO MENUS DE ATALHO PARA INDICADORES...........................................................................121 
WALKTHROUGH: ATUALIZANDO UM GRÁFICO EM UM DOCUMENTO USANDO BOTÕES DE OPÇÃO ................................124 
VINCULAÇÃO DE DADOS PARA CONTROLES EM UM PAINEL AÇÕES DO WORD WALKTHROUGH: ................................128 
WALKTHROUGH: CRIAR UMA MARCA INTELIGENTE QUE CONVERTE TEMPERATURES DE FAHRENHEIT PARA CELSIUS133 
IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM MANIFESTO DEPLOYMENT WALKTHROUGH: ..........135 
IMPLANTANDO UM WORD OU SOLUTION DO EXCEL USANDO UM ARQUIVO DO WINDOWS INSTALLER WALKTHROUGH:
....................................................................................................................................................................................139 
PASSO-A-PASSO: CONCEDENDO E REMOVENDO PERMISSÕES PARA UMA SOLUÇÃO DO OFFICE ...................................144 
COMO: ADICIONAR CONTROLES A DOCUMENTOS DO OFFICE ...................................................................................147 
COMO: EXECUTAR CÁLCULOS DO EXCEL POR PROGRAMAÇÃO.................................................................................149 
COMO: CRIAR MENUS DO OFFICE PROGRAMATICAMENTE...........................................................................................149 
COMO: CRIAR BARRAS DE FERRAMENTAS DO OFFICE POR PROGRAMAÇÃO .............................................................150 
DESENVOLVIMENTO CORPORATIVO (VISUAL C#)...........................................................................152 
PROGRAMAÇÃO DO TABLET PC (VISUAL C#) ..........................................................................................152 
ÁUDIO, VÍDEO, JOGOS E ELEMENTOS GRÁFICOS (VISUAL C#) ......................................................152 
CRIANDO STARTER KITS (VISUAL C#).......................................................................................................154 
MIGRANDO PARA O VISUAL C# ...................................................................................................................155 
C# PARA DESENVOLVEDORES JAVA ............................................................................................................................155 
CONVERTENDO APLICATIVOS JAVA PARA VISUAL C#.................................................................................................155 
PARA DESENVOLVEDORES C++ C# .............................................................................................................................155 
GUIA DE PROGRAMAÇÃO C# .........................................................................................................................158 
EM UM PROGRAMA C# ................................................................................................................................................158 
Hello world-seu primeiro programa (guia de programação C#)..........................................................................159 
Estrutura geral de um programa C# (guia de programação C#)..........................................................................160 
MAIN() E ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#) ........................................................160 
ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#)........................................................................161 
COMO: EXIBIR ARGUMENTOS DE LINHA DE COMANDO (GUIA DE PROGRAMAÇÃO C#) ..............................................162 
COMO: ACESSAR ARGUMENTOS DE LINHA DE COMANDO USANDO FOREACH (GUIA DE PROGRAMAÇÃO C#).............163 
MAIN() RETORNA VALORES (GUIA DE PROGRAMAÇÃO C#).........................................................................................163 
TIPOS DE DADOS (GUIA DE PROGRAMAÇÃO C#) ..........................................................................................................164 
MATRIZES (GUIA DE PROGRAMAÇÃO DO C#).....................................................................................165 
MATRIZES COMO OBJETOS (GUIA DE PROGRAMAÇÃO C#) ...........................................................................................165 
Visual C# Consolidado 4
MATRIZES MULTIDIMENSIONAIS (GUIA DE PROGRAMAÇÃO C#) ..................................................................................166 
MATRIZES PASSAGEM COMO PARÂMETROS (GUIA DE PROGRAMAÇÃO C#)..................................................................166 
PASSANDO REF USANDO MATRIZES E OUT (GUIA PROGRAMAÇÃO C#) .......................................................................168 
SEQÜÊNCIAS (GUIA DE PROGRAMAÇÃO C#) ................................................................................................................169 
USANDO STRINGS (GUIA DE PROGRAMAÇÃO C#) ........................................................................................................169 
ESPECIFICAÇÃO DA LINGUAGEM C# ........................................................................................................173REFERÊNCIA C# ....................................................................................................................................................174 
PALAVRAS-CHAVE C#.................................................................................................................................................174 
PALAVRA-CHAVE ABSTRACT.......................................................................................................................................174 
PALAVRA-CHAVE EVENT.............................................................................................................................................177 
PALAVRA-CHAVE NEW................................................................................................................................................181 
OPERADOR NEW ....................................................................................................................................................181 
MODIFICADOR NEW..............................................................................................................................................184 
PALAVRA-CHAVE STRUCT..................................................................................................................................186 
PALAVRA-CHAVE AS............................................................................................................................................189 
PALAVRA-CHAVE EXPLICIT .........................................................................................................................................190 
PALAVRA-CHAVE NULL...............................................................................................................................................191 
PALAVRA-CHAVE SWITCH ...........................................................................................................................................192 
PALAVRA-CHAVE BASE ...............................................................................................................................................194 
PALAVRA-CHAVE EXTERN...........................................................................................................................................196 
PALAVRA-CHAVE OBJECT ...........................................................................................................................................197 
PALAVRA-CHAVE THIS ................................................................................................................................................198 
PALAVRA-CHAVE BOOL ..............................................................................................................................................200 
PALAVRA-CHAVE FALSE .............................................................................................................................................201 
OPERADOR FALSE .................................................................................................................................................201 
FALSE (LITERAL) ...................................................................................................................................................201 
PALAVRA-CHAVE OPERATOR ......................................................................................................................................202 
PALAVRA-CHAVE THROW ...........................................................................................................................................204 
PALAVRA-CHAVE BREAK ............................................................................................................................................205 
PALAVRA-CHAVE TRY-FINALLY..................................................................................................................................206 
PALAVRA-CHAVE OUT.................................................................................................................................................207 
PALAVRA-CHAVE TRUE...............................................................................................................................................208 
OPERADOR TRUE...................................................................................................................................................208 
TRUE (LITERAL) .....................................................................................................................................................208 
PALAVRA-CHAVE BYTE...............................................................................................................................................209 
PALAVRA-CHAVE FIXED..............................................................................................................................................210 
PALAVRA-CHAVE OVERRIDE .......................................................................................................................................212 
PALAVRA-CHAVE TRY-CATCH.....................................................................................................................................213 
PALAVRA-CHAVE SWITCH ...........................................................................................................................................216 
PALAVRA-CHAVE FOAT...............................................................................................................................................218 
PALAVRA-CHAVE PARAMS ..........................................................................................................................................219 
PALAVRA-CHAVE TYPEOF ...........................................................................................................................................220 
PALAVRA-CHAVE TRY-CATCH.....................................................................................................................................222 
PALAVRA-CHAVE FOR .................................................................................................................................................225 
PALAVRA-CHAVE PRIVATE..........................................................................................................................................226 
PALAVRA-CHAVE UINT................................................................................................................................................227 
PALAVRA-CHAVE CHAR......................................................................................................................................228 
PALAVRA-CHAVE FOREACH, IN ...................................................................................................................................228 
PALAVRA-CHAVE VOLATILE .......................................................................................................................................229 
PALAVRA-CHAVE DELEGATE.......................................................................................................................................230 
PALAVRA-CHAVE OCK ................................................................................................................................................232 
PALAVRA-CHAVE STACKALOC ....................................................................................................................................234 
OPERADORES C# ..................................................................................................................................................237 
OPERADORES SOBRECARREGADOS ..........................................................................................................................238 
OPERADOR [ ]..............................................................................................................................................................239OPERADOR ( )..............................................................................................................................................................240 
OPERADOR . (PONTO) ..................................................................................................................................................241 
OPERADOR +...............................................................................................................................................................241 
OPERADOR -................................................................................................................................................................242 
OPERADOR * ...............................................................................................................................................................243 
Visual C# Consolidado 5
OPERADOR / ................................................................................................................................................................244 
OPERADOR %..............................................................................................................................................................245 
OPERADOR & ..............................................................................................................................................................245 
OPERADOR | ................................................................................................................................................................246 
OPERADOR ^ ...............................................................................................................................................................247 
OPERADOR !................................................................................................................................................................248 
OPERADOR ~ ...............................................................................................................................................................248 
OPERADOR =...............................................................................................................................................................249 
OPERADOR <...............................................................................................................................................................250 
OPERADOR >...............................................................................................................................................................250 
OPERADOR ?: ..............................................................................................................................................................251 
OPERADOR ++.............................................................................................................................................................252 
OPERADOR -- ..............................................................................................................................................................253 
OPERADOR &&...........................................................................................................................................................254 
DIRECTIVES PREPROCESSOR C# ................................................................................................................256 
#IF (REFERÊNCIA C#) ..................................................................................................................................................256 
#ELSE PESSOA (REFERÊNCIA C#) ................................................................................................................................257 
#ENDIF (REFERÊNCIA C#)............................................................................................................................................257 
# DEFINIR (REFERÊNCIA C#) .......................................................................................................................................258 
#UNDEF (REFERÊNCIA C#)...........................................................................................................................................258 
#WARNING (REFERÊNCIA C#)......................................................................................................................................258 
#ERROR (REFERÊNCIA C#) ..........................................................................................................................................259 
# LINE (REFERÊNCIA C#).............................................................................................................................................259 
#REGION (REFERÊNCIA C#).........................................................................................................................................260 
#ENDREGION (REFERÊNCIA C#)...................................................................................................................................260 
# PRAGMA (REFERÊNCIA C#).......................................................................................................................................260 
AVISO # PRAGMA (REFERÊNCIA C#)............................................................................................................................260 
SOMA DE VERIFICAÇÃO # PRAGMA (REFERÊNCIA C#) .................................................................................................261 
OPÇÕES DO COMPILADOR C#.......................................................................................................................262 
CRIANDO DE LINHA DE COMANDO...............................................................................................................................262 
COMO CONSTRUIR A PARTIR DA LINHA DE COMANDO: ................................................................................................263 
IMPLANTAÇÃO DE APLICATIVOS C# ........................................................................................................264 
OPÇÕES DO COMPILADOR C# LISTADAS POR CATEGORIA ............................................................................................264 
Otimização.............................................................................................................................................................264 
Arquivos de saída ..................................................................................................................................................264 
Conjuntos .NET Framework..................................................................................................................................264 
Erros Debugging / verificação ..............................................................................................................................265 
Preprocessor .........................................................................................................................................................265 
Recursos ................................................................................................................................................................265 
Diversos.................................................................................................................................................................265 
OPÇÕES DO COMPILADOR C# LISTADAS ALFABETICAMENTE ......................................................................................266 
COMO LOCALIZAR AJUDA PARA ERROS DO COMPILADOR: ...........................................................................................267 
PARA ENCONTRAR AJUDA PARA UM ERRO ..................................................................................................................267 
EXEMPLOS DO VISUAL C#...............................................................................................................................268EXEMPLO WORLD DE SAUDAÇÃO................................................................................................................................269 
EXEMPLO DE PARÂMETROS DA LINHA DE COMANDO...................................................................................................271 
EXEMPLO MATRIZES ...................................................................................................................................................272 
EXEMPLO PROPRIEDADES............................................................................................................................................272 
EXEMPLO BIBLIOTECAS...............................................................................................................................................273 
EXEMPLO DE VERSÃO..................................................................................................................................................274 
COLEÇÃO EXEMPLO CLASSES .....................................................................................................................................275 
EXEMPLO STRUCTS .....................................................................................................................................................276 
EXEMPLO INDEXADORES.............................................................................................................................................277 
INDEXADO EXEMPLO PROPRIEDADES..........................................................................................................................278 
EXEMPLO CONVERSIONS DEFINIDAS PELO USUÁRIO ...................................................................................................279 
EXEMPLO GENERICS (C#)............................................................................................................................................279 
EXEMPLO REPRESENTANTES .......................................................................................................................................281 
EXEMPLO EVENTOS.....................................................................................................................................................282 
Visual C# Consolidado 6
EXEMPLO DE IMPLEMENTAÇÃO DE INTERFACE EXPLÍCITA ..........................................................................................283 
EXEMPLO DOS MÉTODOS CONDICIONAL .....................................................................................................................284 
EXEMPLO DE DOCUMENTAÇÃO XML..........................................................................................................................285 
PLATAFORMA INVOKE EXEMPLO ................................................................................................................................286 
EXEMPLO PARTE 1 INTEROP COM ..............................................................................................................................287 
EXEMPLO PARTE 2 INTEROP COM ..............................................................................................................................288 
EXEMPLO ATRIBUTOS..................................................................................................................................................289 
EXEMPLO DE SEGURANÇA...........................................................................................................................................290 
SEGMENTAÇÃO DE EXEMPLO......................................................................................................................................291 
EXEMPLO DE CÓDIGO NÃO SEGUROS ...........................................................................................................................292 
EXEMPLO BD OLE .....................................................................................................................................................293 
PRODUZIR EXEMPLO ...................................................................................................................................................294 
ANÔNIMO EXEMPLO REPRESENTANTES.......................................................................................................................295 
EXEMPLO TIPOS PARCIAL ............................................................................................................................................296 
EXEMPLO ANULÁVEL ..................................................................................................................................................296 
TERMINOLOGIA C# .............................................................................................................................................298 
EXEMPLOS DO VISUAL C#...............................................................................................................................301 
EXEMPLO WORLD DE SAUDAÇÃO................................................................................................................................303 
EXEMPLO DE PARÂMETROS DA LINHA DE COMANDO...................................................................................................304 
EXEMPLO MATRIZES ...................................................................................................................................................305 
EXEMPLO PROPRIEDADES............................................................................................................................................306 
EXEMPLO BIBLIOTECAS...............................................................................................................................................307 
EXEMPLO DE VERSÃO..................................................................................................................................................308 
COLEÇÃO EXEMPLO CLASSES .....................................................................................................................................309 
EXEMPLO STRUCTS .....................................................................................................................................................310 
EXEMPLO INDEXADORES.............................................................................................................................................311 
INDEXADO EXEMPLO PROPRIEDADES..........................................................................................................................311 
EXEMPLO CONVERSIONS DEFINIDAS PELO USUÁRIO ...................................................................................................312 
EXEMPLO GENERICS (C#)............................................................................................................................................313 
EXEMPLO OVERLOADING DO OPERADOR ....................................................................................................................314 
EXEMPLO REPRESENTANTES .......................................................................................................................................315 
EXEMPLO EVENTOS.....................................................................................................................................................316 
EXEMPLO DE IMPLEMENTAÇÃO DE INTERFACE EXPLÍCITA ..........................................................................................317 
EXEMPLO DOS MÉTODOS CONDICIONAL .....................................................................................................................318 
EXEMPLO DE DOCUMENTAÇÃO XML..........................................................................................................................318 
PLATAFORMA INVOKE EXEMPLO ................................................................................................................................319EXEMPLO PARTE 1 INTEROP COM ..............................................................................................................................320 
EXEMPLO PARTE 2 INTEROP COM ..............................................................................................................................322 
EXEMPLO ATRIBUTOS..................................................................................................................................................323 
EXEMPLO DE SEGURANÇA...........................................................................................................................................324 
SEGMENTAÇÃO DE EXEMPLO......................................................................................................................................325 
EXEMPLO DE CÓDIGO NÃO SEGUROS ...........................................................................................................................326 
EXEMPLO BD OLE .....................................................................................................................................................327 
PRODUZIR EXEMPLO ...................................................................................................................................................328 
ANÔNIMO EXEMPLO REPRESENTANTES.......................................................................................................................328 
EXEMPLO TIPOS PARCIAL ............................................................................................................................................329 
EXEMPLO ANULÁVEL ..................................................................................................................................................330 
COMO FAZER EM C#................................................................................................................................................332 
LINGUAGEM C# (COMO EU FAÇO EM C#).........................................................................................................334 
O QUE HÁ DE NOVO NA C# 2.0 IDIOMA E COMPILER....................................................................................................340 
Usando Starter Kits C# .........................................................................................................................................340 
Especificação da Linguagem C# ...........................................................................................................................341 
Main() e argumentos de linha de comando (Guia de programação C#)...............................................................341 
Main() retorna valores (Guia de programação C#)..............................................................................................343 
base (Referência do C#) ........................................................................................................................................343 
Construtores de instância (Guia de programação C#) .........................................................................................345 
CLASSES GENÉRICAS NO .NET FRAMEWORK ..............................................................................................................357 
Visão geral sobre Generics no .NET Framework..................................................................................................357 
Tipos e Generics aninhadas ..................................................................................................................................358 
System.Collections.Generic ...................................................................................................................................359 
Visual C# Consolidado 7
System.Collections.ObjectModel ...........................................................................................................................359 
O encadeamento representantes............................................................................................................................361 
Igualdade e classificação Comparisons ................................................................................................................361 
Funcionalidade coleção ........................................................................................................................................361 
Vantagens de Generics ..........................................................................................................................................362 
A palavra-chave default em código fonte "genérico" (Guia de programação C#) ...............................................363 
Métodos genérico (Guia de programação C#)......................................................................................................363 
Restrições em parâmetros de tipo (Guia de programação C#) .............................................................................365 
Representantes genéricos (Guia de programação C#)..........................................................................................367 
Uma tabela imposto exemplo ................................................................................................................................375 
Criar um suplemento de automação para Excel usando o Visual Studio e código gerenciado ............................375 
Executar o suplemento do Excel............................................................................................................................376 
Executar código em outro domínio de aplicação (Guia de programação C#)......................................................392 
Exemplos do Visual C#..........................................................................................................................................394 
.NET FRAMEWORK (COMO FAZER EM C#).......................................................................................................397 
INTRODUÇÃO À LINGUAGEM C# E AO .NET FRAMEWORK ..........................................................................................408 
Visão geral sobre o .NET Framework...................................................................................................................410 
Visão Geral Conceitual Sobre o .NET Framework ...............................................................................................410 
COMMON LANGUAGE RUNTIME..................................................................................................................................416 
Visão geral do Common Language Runtime .........................................................................................................416 
Gerenciamento automático de memória................................................................................................................417 
CTS (Common Type System) .................................................................................................................................420 
Visão Geral do CTS (Common Type System) ........................................................................................................420 
Definições de Tipo.................................................................................................................................................422 
Membros de Tipos .................................................................................................................................................424 
Tipos de valor no Common Type System...............................................................................................................426 
Classes no Common Type System..........................................................................................................................427 
Delegados no Common Type System.....................................................................................................................428Matrizes em Common Type System .......................................................................................................................430 
Interfaces no Common Type System......................................................................................................................431 
Ponteiros no Common Type System (CTS) ............................................................................................................431 
OS METADADOS E OS COMPONENTES AUTODESCRITIVOS ............................................................................................433 
Visão Geral Sobre Metadados...............................................................................................................................433 
Estrutura e uso de metadados ...............................................................................................................................434 
Metadados e Estrutura do Arquivos PE ................................................................................................................434 
Uso de metadados em tempo de execução.............................................................................................................435 
ASSEMBLIES NO COMMON LANGUAGE RUNTIME........................................................................................................436 
Visão Geral Sobre Assemblies...............................................................................................................................437 
Benefícios do Assembly .........................................................................................................................................438 
Sumário de assembly .............................................................................................................................................439 
Manifesto do Assembly ..........................................................................................................................................440 
Cache Global de Assemblies .................................................................................................................................442 
Assemblies de Nomes Fortes .................................................................................................................................443 
Considerações sobre segurança de assemblies .....................................................................................................443 
Versionamento de Assembly ..................................................................................................................................445 
Número de Versão do Assembly ............................................................................................................................446 
Versão Informativa do Assembly ...........................................................................................................................447 
Posicionamento do Assembly ................................................................................................................................447 
Assemblies e execução lado a lado........................................................................................................................448 
Visão Geral da Biblioteca de Classes do .NET Framework..................................................................................448 
Localizador rápido de tecnologia..........................................................................................................................451 
Criando Novas Seqüências de Caracteres.............................................................................................................458 
Aparando e Removendo Caracteres ......................................................................................................................460 
Preenchendo Seqüências de Caracteres................................................................................................................461 
Comparando Seqüências de Caracteres................................................................................................................462 
Alterando a Caixa..................................................................................................................................................466 
Usando a Classe StringBuilder .............................................................................................................................467 
Acrescentar............................................................................................................................................................468 
Coleções e Estruturas de Dados............................................................................................................................472 
Definir coleções.....................................................................................................................................................472 
Comumente usados tipos da coleção.....................................................................................................................474 
Coleções de bits.....................................................................................................................................................474 
Visual C# Consolidado 8
Coleções especializados ........................................................................................................................................475 
Criando e Manipulating coleções..........................................................................................................................475 
Selecionando uma Classe de Coleção ...................................................................................................................476 
Enumerar uma coleção..........................................................................................................................................477 
Coleções e sincronização (segurança do segmento) .............................................................................................478 
Comparações e classifica em coleções..................................................................................................................478 
Quando Usar Coleções Genéricas ........................................................................................................................479 
Classe genérica List ..............................................................................................................................................480 
Considerações sobre desempenho.........................................................................................................................481 
Classe genérica SortedDictionary.........................................................................................................................483 
DEPURAÇÃO (COMO FAZER EM C#) ............................................................................................................................495 
Compilando no Visual Studio ................................................................................................................................495 
Compilação Durante o Desenvolvimento de Aplicativos ......................................................................................495 
Configurações de Compilação ..............................................................................................................................496 
Compilar plataformas ...........................................................................................................................................498 
Compilar elementos de interface do usuário.........................................................................................................504 
Caixa de Diálogo Batch Build...............................................................................................................................504Janela de saída......................................................................................................................................................506 
Caixa de Diálogo Configuration Manager............................................................................................................507 
Depuração no Visual Studio..................................................................................................................................508 
O que há de novo no depurador Visual Studio 2005.............................................................................................508 
Segurança do Depurador ......................................................................................................................................511 
Segurança de Depuração Gerenciada...................................................................................................................511 
Segurança em Depuração Remota ........................................................................................................................511 
Segurança de Depuração de Serviços da Web ......................................................................................................512 
Componentes Externos ..........................................................................................................................................512 
Símbolos e Código Fonte.......................................................................................................................................512 
Preparação e configurações de depuração...........................................................................................................512 
Configurações do Projeto do Depurador ..............................................................................................................513 
Requisitos de software depuração SQL.................................................................................................................513 
Configurações do projeto para um C++ depurar configuração...........................................................................515 
Como definir permissões SQL Server para depuração: ........................................................................................518 
Configurações do projeto para uma configuração de depuração no Visual Basic ...............................................519 
Arquivos PDB (C++) ............................................................................................................................................521 
Arquivos DBG .......................................................................................................................................................521 
Instalando símbolos para sistema de depuração chamada Crashes .....................................................................522 
Depuração de projetos DLL..................................................................................................................................523 
Preparação da depuração: Projetos de console ...................................................................................................526 
Preparação de Depuração: Tipos de Projeto do Visual C++ ..............................................................................526 
Preparação da Depuração: Configurações de Propriedades Recomendáveis .....................................................527 
Depuração preparação: Applications formulários Windows (.NET)....................................................................527 
Projetos Win32 depuração preparação: ...............................................................................................................528 
Preparação da Depuração: Web Services XML (C++)........................................................................................529 
Preparação para depuração: tipos de projeto C#, J# e Visual Basic ...................................................................529 
Aplicativos da Web depuração preparação: .........................................................................................................529 
Preparação para depuração : Aplicativos ASP.NET da Web ...............................................................................530 
Projetos Serviço da Web XML depuração preparação:........................................................................................530 
Preparação para depuração: Serviços da Web ATL Server..................................................................................532 
Preparação para depuração: Projetos ATL Server ..............................................................................................532 
Instalação de depuração remota ...........................................................................................................................533 
Depuração na uma plataforma de 64 bits .............................................................................................................539 
Depuração e o processo Hosting...........................................................................................................................540 
Explicação detalhada sobre o depurador..............................................................................................................542 
Depurando o código gerenciado ...........................................................................................................................542 
Diagnóstico de mensagens na janela de saída ......................................................................................................542 
Asserção no código gerenciado.............................................................................................................................543 
Parar instruções no Visual Basic ..........................................................................................................................546 
Depurar o método OnStart como: .........................................................................................................................549 
Depuração de código nativo..................................................................................................................................551 
Como debug otimizado código: .............................................................................................................................551 
DebugBreak e __debugbreak ................................................................................................................................553 
Declarações...........................................................................................................................................................553 
_DEBUG ...............................................................................................................................................................554 
Visual C# Consolidado 9
Detecção vazamento de memória e isolamento.....................................................................................................555 
Para depurar código de montagem embutido .......................................................................................................556 
Técnicas de depuração atl .....................................................................................................................................556 
Técnicas de depuração MFC.................................................................................................................................557 
Técnicas de depuração CRT..................................................................................................................................558 
Depuração Native FAQs do código.......................................................................................................................559 
COM e depurando ActiveX....................................................................................................................................560Depurar aplicativos da Web..................................................................................................................................562 
Depuração SQL.....................................................................................................................................................563 
Depuração referência Interface de usuário...........................................................................................................564 
Aperfeiçoando a depuração com o atributo de exibição do depurador ................................................................573 
Descrição...............................................................................................................................................................575 
Código ...................................................................................................................................................................575 
Para criar o formulário do Windows para essa explicação passo a passo...........................................................579 
Para anexar ao formulário do Windows para depuração.....................................................................................581 
Banco de dados de depuração T-SQL ...................................................................................................................590 
SEGURANÇA (COMO FAZER EM C#) ............................................................................................................................596 
Segurança no Visual Studio...................................................................................................................................596 
Noções Básicas sobre Segurança de Accesso a Código........................................................................................596 
Práticas recomendadas de política de segurança .................................................................................................597 
Visão geral da administração de política de segurança .......................................................................................597 
Administração de diretiva de segurança geral......................................................................................................599 
Determinando quando para modificar a diretiva de segurança............................................................................599 
Ferramentas de administração..............................................................................................................................600 
Aumentar permissões.............................................................................................................................................601 
Administração com atributos Grupo de códigos ...................................................................................................602 
Dicas de administração.........................................................................................................................................603 
Administração de diretiva corporativa..................................................................................................................604 
Administração de diretiva da máquina..................................................................................................................604 
Administração de diretiva de usuário....................................................................................................................604 
EXPLICAÇÕES PASSO-A-PASSO DO .NET FRAMEWORK SDK ......................................................................................719 
Como Registrar Assemblies de Interoperabilidade Primários ..............................................................................784 
Como Empacotar Várias Versões de Bibliotecas de Tipos ...................................................................................785 
APLICATIVOS DO WINDOWS (COMO FAZER EM C#) ....................................................................................................786 
Componente Timer (Windows Forms)...................................................................................................................797 
Visão geral do componente de timer (Windows Forms)........................................................................................797 
Limitações do componente Timer de formulários do Windows na propriedade Interval......................................798 
Controle toolBar Windows (formulários)..............................................................................................................800 
Visão geral sobre de controle toolBar (formulários do Windows)........................................................................800 
Como adicionar botões a um controle ToolBar usando o criador:.......................................................................801 
PÁGINAS DA WEB E SERVIÇOS DA WEB (COMO FAZER EM C#)................................................................806 
O que há de novo no desenvolvimento para Web no Visual Studio.......................................................................806 
Servidor de Desenvolvimento do ASP.NET ...........................................................................................................807 
Publicação de Web Sites .......................................................................................................................................808 
Extensibilidade de Controle ..................................................................................................................................811 
Ligação de Dados com Controles de Fonte de Dados ..........................................................................................812 
Controles de dados avançados ..............................................................................................................................812 
Vinculação bidirecional de dados .........................................................................................................................813 
Armazenamento de seqüência de caracteres de conexão ......................................................................................813 
Acesso a dados em duas e três camadas ...............................................................................................................813 
Compatibilidade com Versões Anteriores para Acesso a Dados ..........................................................................814 
INTRODUÇÃO A PÁGINAS DA WEB DO ASP.NET.........................................................................................................815 
Postagem cruzada de páginas ...............................................................................................................................816 
Preservando o estado da página ...........................................................................................................................816 
Controles de servidor ............................................................................................................................................817 
Compatibilidade do navegador .............................................................................................................................818 
Documentos e dados XML.....................................................................................................................................818 
O que há de novo no System.Xml ..........................................................................................................................818 
Migrando de versão 1.1 das classes XML .............................................................................................................819 
Arquitetura Overview of XML no .NET Framework .............................................................................................822 
Segurança e seus aplicativos System.Xml.............................................................................................................822 
Considerações sobre segurança System.Xml.........................................................................................................823 
Visual C# Consolidado 10
Processamento DTD..............................................................................................................................................824 
Processamento de esquema...................................................................................................................................824 
Recursos externos..................................................................................................................................................824 
Compartilhar objetos XmlReaderSettings .............................................................................................................825 
Suporte componentes.............................................................................................................................................825 
Processamento de dados .......................................................................................................................................825 
Processamento DTD..............................................................................................................................................825 
Tratamento de entidade.........................................................................................................................................825 
Recursos externos..................................................................................................................................................825 
Recursos externos..................................................................................................................................................826 
Blocos de script .....................................................................................................................................................826 
Objetos de extensão...............................................................................................................................................826 
System.Xml codificação diretrizes .........................................................................................................................827 
Acesso externo.......................................................................................................................................................827 
Negação de Serviço ...............................................................................................................................................827 
Processamento.......................................................................................................................................................828 
Dados XML processo In-Memory..........................................................................................................................829 
Processo dados XML usando o modelo DOM.......................................................................................................829 
Processo dados XML usando o modelo de dados XPath.......................................................................................830 
Lendo XML com o XmlReader...............................................................................................................................831 
Escrevendo XML com o XmlWriter .......................................................................................................................832 
Novos recursos na classe XmlWriter .....................................................................................................................832 
Verificação de caracteres......................................................................................................................................833 
Verificando a conformidade ..................................................................................................................................833 
Usando o XmlWriter..............................................................................................................................................833 
Transformações em XSLT......................................................................................................................................834 
Usando a classe XslCompiledTransform...............................................................................................................834 
Migrando da classe XslTransform ........................................................................................................................835 
Considerações sobre segurança XSLT ..................................................................................................................837 
Transformações em XSLT com a classe XslTransform..........................................................................................839 
Modelo de objeto de esquema (SOM) do XML......................................................................................................841 
Visão geral do modelo de objeto do esquema XML ..............................................................................................841 
Leitura e escrita esquemas XML ...........................................................................................................................843 
Criando esquemas XML ........................................................................................................................................844 
Atravessando esquemas XML................................................................................................................................847 
Editar Esquemas XML...........................................................................................................................................849 
Incluindo ou importar esquemas XML ..................................................................................................................853 
Integração XML com dados relacional e ADO.NET.............................................................................................855 
Resolver externos recursos XML nomeados por um URI......................................................................................857 
Resolvendo recursos usando o XmlResolver .........................................................................................................857 
Fornecer credenciais de autenticação para XmlResolver quando leitura de um arquivo ....................................858 
Para criar um objeto XmlReader que usa um XmlSecureResolver .......................................................................860 
Codificação de caracteres de nomes XML e conversão de tipos de dados XML...................................................860 
Espaços para nomes em um documento XML .......................................................................................................860 
Suporte tipo nas classes System.Xml .....................................................................................................................861 
Mapear tipos de dados XML para tipos CLR........................................................................................................861 
Observações de implementação de suporte tipo XML...........................................................................................863 
Conversão de tipos de dados XML ........................................................................................................................864 
SERVIÇOS DA WEB XML NO CÓDIGO GERENCIADO ....................................................................................................866 
Introdução à programação serviços XML da Web no código gerenciado ............................................................866Programação na Web com XML Web Services .....................................................................................................867 
Criando XML Web Services em código gerenciado ..............................................................................................867 
Acessando XML Web Services no código gerenciado ...........................................................................................869 
Criado usando clientes do serviço XML da Web ASP.NET e Serviços XML da Web ...........................................870 
Acessar a Página de Ajuda de Serviço ..................................................................................................................878 
Acessar a descrição de serviço..............................................................................................................................878 
Fornecendo um nome de mensagem para um método de XML Web Service ........................................................883 
Criando uma nova transação com um método de XML Web Service....................................................................884 
Protegendo Serviços da Web XML Criados Usando ASP.NET.............................................................................895 
ACESSO A DADOS (COMO FAZER EM C#) ....................................................................................................................900 
Criando os controles para exibir os pedidos para cada cliente (registros filho) ..................................................902 
Visão geral sobre como conectar-se a dados no Visual Studio.............................................................................903 
Visão Geral do Adaptador de Tabela....................................................................................................................921 
Visual C# Consolidado 11
Visão Geral do Preenchimento de DataSets e Consultas de Dados......................................................................927 
Visão Geral da Exibição dados .............................................................................................................................936 
Ligação de Objeto no Visual Studio ......................................................................................................................962 
Visão Geral da Edição de dados em DataSets ......................................................................................................966 
Visão geral sobre validação de dados...................................................................................................................967 
Visão Geral do Salvar dados.................................................................................................................................972 
Introdução ao CONCURRENCY dados em ADO.NET .........................................................................................982 
CONCURRENCY pessimista.................................................................................................................................982 
CONCURRENCY otimista.....................................................................................................................................983 
Última no WINS.....................................................................................................................................................983 
A abordagem número versão.................................................................................................................................984 
Para adicionar o tratamento de erro para o erro de concorrência ......................................................................989 
Elementos de Dados de Interface de Usuário .......................................................................................................994 
Adaptadores de Dados do ADO.NET ....................................................................................................................997 
Projetos SQL Server ..............................................................................................................................................998 
CRIANDO CLASSES (COMO FAZER EM C#) ................................................................................................................1004 
COMO: Criar Tipos em Diagramas de Classe ...................................................................................................1004 
Criando e Configurando Membros de Tipos .......................................................................................................1005 
Criar membros tipo .............................................................................................................................................1005 
COMO: Modificar membros de tipo....................................................................................................................1006 
COMO: Adicionar um parâmetro a um método..................................................................................................1006 
COMO: Abrir a janela Class Details ..................................................................................................................1007 
Atalhos de teclado para a janela Detalhes de classe ..........................................................................................1007 
Usando o teclado.................................................................................................................................................1008 
Observações úteis sobre a janela Class Details ..................................................................................................1009 
Exibição de informações somente leitura............................................................................................................1010 
Elementos da janela Class Details ......................................................................................................................1011 
Linhas membro ....................................................................................................................................................1011 
Linhas de parâmetro............................................................................................................................................1012 
COMO: Herdar de um Tipo Genérico.................................................................................................................1012 
COMO: Definir herança entre tipos....................................................................................................................1013 
COMO: Definir associações entre tipos..............................................................................................................1013 
COMO: Excluir formas de tipos e código associado de diagramas classe.........................................................1014 
COMO: Aplicar atributos personalizados a tipos ou membros de tipo...............................................................1015 
COMO: Exibir Herança entre Tipos ...................................................................................................................1015 
COMO: Exibir tipos derivados............................................................................................................................1016 
COMO: Remover formas de tipos de diagramas de classe .................................................................................1016 
COMO: Exibir compartimentos em formas de tipo.............................................................................................1017 
COMO: Exibir detalhes do tipo: .........................................................................................................................1018 
COMO: Alternar entre notação de membro e notação de associação................................................................1019 
COMO: Exibir membros de tipo .........................................................................................................................1019COMO: Adicionar diagramas de classes a projetos ...........................................................................................1020 
COMO: Exibir tipos existentes............................................................................................................................1021 
Ententendo um código que você não escreveu ....................................................................................................1022 
COMO: Agrupar membros de tipo......................................................................................................................1022 
COMO: Adicionar comentários a diagramas de classe ......................................................................................1022 
Personalizando diagramas de classe...................................................................................................................1023 
COMO: Copiar elementos de diagrama de classe para um documento do Microsoft Office .............................1024 
COMO: Imprimir diagramas de classe ...............................................................................................................1024 
COMO: Ignorar membros de tipo .......................................................................................................................1025 
COMO: Renomear tipos e membros de tipo........................................................................................................1025 
COMO: Mover um membro de tipo de um tipo para outro .................................................................................1026 
COMO: Implementar uma interface....................................................................................................................1026 
COMO: Implementar uma classe abstrata..........................................................................................................1027 
COMO: Extrair para interface (C# somente)......................................................................................................1027 
COMO: Reordenar parâmetros (C# somente) ....................................................................................................1027 
COMO: Criar um membro ..................................................................................................................................1027 
COMO: Implementar um designer para um controle..........................................................................................1029 
COMO: Criar e configurar componentes no modo Design.................................................................................1030 
Como: Acessar suporte em tempo de design no Windows Forms .......................................................................1036 
COMO: Implementar um provedor Extender HelpLabel ....................................................................................1037 
COMO: Acessar serviços em tempo de criação ..................................................................................................1041 
COMO: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute............................1048 
Visual C# Consolidado 12
Como: Executar inicialização personalizada para controles no modo de design...............................................1049 
COMO: Implementar um conversor de tipo ........................................................................................................1050 
Para implementar um conversor de tipo simples que pode converter uma seqüência para um ponto................1050 
Para implementar um conversor de tipo simples que fornece uma lista drop-down de valores padrão em um 
navegador Propriedade.......................................................................................................................................1051 
Para implementar um conversor tipo que produz Propriedade baseado no construtor-código de inicialização1053 
COMO: Implementar um editor UI de tipo .........................................................................................................1054 
Como: Estender a aparência e comportamento de controles no modo de design...............................................1055 
COMO: Criar um controle de formulários do Windows que tira vantagem de recursos em tempo de criação..1064 
COMO: Anexar marcas inteligentes para um componente de formulários do Windows ....................................1071 
COMO: Ajustar atributos, eventos e propriedades de um componente no modo Design ...................................1073 
PROGRAMAÇÃO DO OFFICE (COMO FAZER EM C#) ...................................................................................................1080 
Como: Atualizar soluções das Ferramentas do Visual Studio para o Office ......................................................1080 
O Excel Usando Explicações Passo-a-passo.......................................................................................................1081 
Coleta de dados usando um formulário do Windows Walkthrough: ...................................................................1081 
Para criar um novo projeto .................................................................................................................................1081 
Para adicionar um intervalo nomeado para Sheet1............................................................................................1081 
Para adicionar um formulário do Windows........................................................................................................1082 
Para exibir o formulário e coletar informações..................................................................................................1082 
Para enviar informações para a planilha ...........................................................................................................1083 
Para testar sua pasta de trabalho .......................................................................................................................1083 
Alterando planilha formatação usando controles CheckBox Walkthrough: .......................................................1083 
Para criar um novo projeto .................................................................................................................................1084 
Para adicionar três caixas de seleção.................................................................................................................1084 
Para adicionar texto a um controle NamedRange ..............................................................................................1085 
Exibindo texto em uma caixa de texto em uma planilha usando um botão Walkthrough: ..................................1086 
Para testar sua pasta de trabalho .......................................................................................................................1088 
Programação contra eventos de um controle NamedRange Walkthrough: ........................................................1088 
Walkthrough: vinculação células para várias colunas em uma tabela ...............................................................1099 
Criando uma relação mestre / detalhes usando um DataSet em cache Walkthrough:........................................1103 
Para criar um novo projeto .................................................................................................................................1104 
Armazenar em cache DataSet..............................................................................................................................1105 
Para percorrer os registros.................................................................................................................................1106 
Para testar o cache de dados ..............................................................................................................................1106 
Para adicionar os dados .....................................................................................................................................1107Para adicionar um gráfico ..................................................................................................................................1108 
Para criar um novo projeto .................................................................................................................................1108 
Para alterar o nome do controle gráfico.............................................................................................................1109 
Para adicionar um controle de usuário...............................................................................................................1109 
Para adicionar controles Windows Form ao controle de usuário ......................................................................1109 
Para criar um evento e propriedade em um controle de usuário........................................................................1110 
Para manipular o evento CheckedChanged dos botões de opção.......................................................................1110 
Para adicionar o controle do usuário sua planilha ............................................................................................1111 
Para alterar o tipo de gráfico que é exibido na planilha ....................................................................................1111 
Para testar sua pasta de trabalho .......................................................................................................................1112 
Vinculação de Dados para controles em um painel Ações do Excel Walkthrough:............................................1112 
Para criar um novo projeto .................................................................................................................................1113 
Para adicionar uma nova fonte de dados para o projeto....................................................................................1113 
Para adicionar um NamedRange e um controle ListObject ................................................................................1114 
Para adicionar um controle painel Ações ...........................................................................................................1114 
Para adicionar controles Windows Forms ligados a dados a um controle painel Ações ...................................1114 
Para definir propriedades de vinculação de dados do controle..........................................................................1115 
Para mostrar o painel Ações ...............................................................................................................................1115 
Para testar seu documento ..................................................................................................................................1115 
Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: .........................1116 
Para criar um novo projeto .................................................................................................................................1117 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1117 
Para publicar a solução ......................................................................................................................................1117 
Para atualizar o manifesto do aplicativo incorporado........................................................................................1118 
Para atualizar a manifesto de implantação.........................................................................................................1119 
Para atualizar o manifesto do aplicativo externo ...............................................................................................1119 
Para copiar os arquivos de solução para o servidor ..........................................................................................1120 
Para conceder confiança total para a pasta de rede...........................................................................................1120 
Visual C# Consolidado 13
Para testar a implantação ...................................................................................................................................1120 
Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: .............1121 
Para criar um novo projeto .................................................................................................................................1122 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1122 
Para criar um projeto de instalação para a solução...........................................................................................1122 
Para adicionar o documento e conjunto ao projeto de instalação......................................................................1123 
Para criar um projeto ação personalizada..........................................................................................................1123 
Para criar uma ação personalizada que edita o manifesto do aplicativo ...........................................................1124 
Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação................................1125 
Para testar a instalação ......................................................................................................................................1125 
Passo-a-passo: Concedendo e removendo permissões para uma solução do Office ..........................................1126 
Para criar um novo projeto .................................................................................................................................1126 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1126 
Para remover um grupo de códigos ....................................................................................................................1127 
Para criar um nome forte ....................................................................................................................................1128 
Para conceder confiança com base em nome forte .............................................................................................1128 
Para testar sua pasta de trabalho .......................................................................................................................1128 
O Word Usando Explicações Passo-a-passo.......................................................................................................1129 
Walkthrough: Changing Document formatação usando controles CheckBox ....................................................1129 
Para criar um novo projeto .................................................................................................................................1129 
Para adicionar três caixas de seleção.................................................................................................................1130 
Para adicionar texto e um controle indicador.....................................................................................................1130 
Para alterar a formatação quando uma caixa de seleção é marcada.................................................................1131 
Para testar seu documento ..................................................................................................................................1132 
Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough: ................................1132 
Para criar um novo projeto .................................................................................................................................1133 
Para adicionar um botão e uma caixa de texto ...................................................................................................1133Para escrever para a caixa de texto quando o botão é clicado...........................................................................1133 
Para testar seu documento ..................................................................................................................................1134 
Walkthrough: Criando menus de atalho para indicadores .................................................................................1134 
Para criar um novo projeto .................................................................................................................................1135 
Para adicionar texto ao seu documento ..............................................................................................................1135 
Para adicionar um controle indicador ao seu documento ..................................................................................1135 
Para criar o menu de atalho................................................................................................................................1135 
Para formatar o texto contido no indicador........................................................................................................1136 
Para testar seu documento ..................................................................................................................................1137 
Walkthrough: atualizando um gráfico em um documento usando botões de opção............................................1137 
Para criar um novo projeto .................................................................................................................................1138 
Para adicionar um gráfico ..................................................................................................................................1138 
Para adicionar um controle de usuário...............................................................................................................1139 
Para adicionar controles Windows Form ao controle de usuário ......................................................................1139 
Para adicionar uma referência à 11.0 biblioteca objeto do Graph Microsoft ....................................................1140 
Para criar um evento e propriedade em um controle de usuário........................................................................1140 
Para manipular o evento CheckedChange dos botões de opção.........................................................................1140 
Para adicionar o controle de usuário do documento ..........................................................................................1141 
Para alterar o tipo de gráfico que é exibido no documento ................................................................................1141 
Para testar seu documento ..................................................................................................................................1142 
Vinculação de Dados para controles em um painel Ações do Word Walkthrough:............................................1142 
Para criar um novo projeto .................................................................................................................................1143 
Para adicionar um controle painel Ações ...........................................................................................................1143 
Para adicionar uma nova fonte de dados para o projeto....................................................................................1143 
Para adicionar controles Windows Forms ligados a dados a um controle painel Ações ...................................1144 
Para carregar o controle com dados...................................................................................................................1145 
Para definir propriedades de vinculação de dados do controle..........................................................................1145 
Para formatar os títulos de tabela.......................................................................................................................1145 
Para criar a tabela ..............................................................................................................................................1146 
Para inserir texto em uma tabela do Word..........................................................................................................1146 
Para mostrar o painel Ações ...............................................................................................................................1147 
Para testar seu documento ..................................................................................................................................1147 
Walkthrough: criar uma marca inteligente que converte Temperatures de Fahrenheit para Celsius ................1148 
Para criar um novo projeto .................................................................................................................................1148 
Para configurar seu projeto ................................................................................................................................1148 
Para criar a marca inteligente ............................................................................................................................1149 
Visual C# Consolidado 14
Para criar o manipulador de eventos..................................................................................................................1149 
Para testar sua pasta de trabalho .......................................................................................................................1150 
Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: .........................1150 
Para criar um novo projeto .................................................................................................................................1151 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1151 
Para publicar a solução ......................................................................................................................................1152 
Para atualizar o manifesto do aplicativo incorporado........................................................................................1152 
Para atualizar a manifesto de implantação.........................................................................................................1153 
Para atualizar o manifesto do aplicativo externo ...............................................................................................1153 
Para copiar os arquivos de solução para o servidor ..........................................................................................1154 
Para conceder confiança total para a pasta de rede...........................................................................................1154 
Para testar a implantação ...................................................................................................................................1154 
Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: .............1155 
Para criar um novo projeto .................................................................................................................................1156 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1156 
Para criar um projeto de instalação para a solução...........................................................................................1156 
Para adicionar o documento e conjunto ao projeto de instalação......................................................................1157 
Para criar um projeto ação personalizada..........................................................................................................1157 
Paracriar uma ação personalizada que edita o manifesto do aplicativo ...........................................................1158 
Para adicionar a saída primária do projeto ação personalizada ao projeto de instalação................................1159 
Para testar a instalação ......................................................................................................................................1159 
Passo-a-passo: Concedendo e removendo permissões para uma solução do Office ..........................................1160 
Para criar um novo projeto .................................................................................................................................1160 
Para adicionar uma caixa de mensagem a um evento de inicialização ..............................................................1160 
Para remover um grupo de códigos ....................................................................................................................1161 
Para criar um nome forte ....................................................................................................................................1162 
Para conceder confiança com base em nome forte .............................................................................................1162 
Para testar sua pasta de trabalho .......................................................................................................................1162 
COMO: Adicionar Controles a Documentos do Office.......................................................................................1162 
Para arrastar um Windows Forms controle para o documento..........................................................................1163 
Para desenhar um Windows Forms controle sobre o documento .......................................................................1163 
Para adicionar um controle Windows Forms para o documento clicando uma única vez sobre o controle ......1164 
Para adicionar um controle Windows Forms para o documento clicando duas vezes no controle ....................1164 
Para adicionar um controle Windows Forms para o documento, pressionando a tecla ENTER........................1164 
Para adicionar um Windows Forms controlar programaticamente ...................................................................1165 
COMO: Executar Cálculos do Excel por Programação .....................................................................................1165 
Para executar cálculos em um controle NamedRange ........................................................................................1165 
Executar cálculos para o aplicativo inteiro ........................................................................................................1165 
Para executar cálculos em todas as pastas de trabalho abertas.........................................................................1165 
Como: Criar menus do Office programaticamente .............................................................................................1166 
COMO: Criar Barras de Ferramentas do Office por Programação...................................................................1167 
DISPOSITIVOS INTELIGENTES ....................................................................................................................................1168 
O que há de novo em projetos Smart Device.......................................................................................................1168 
O que há de novo no desenvolvimento visual aplicativos dispositivos C++.......................................................1168 
Destino vários sistemas operacionais .................................................................................................................1168 
Sistema do projeto ...............................................................................................................................................1168 
O IntelliSense ......................................................................................................................................................1168 
Modo misto Solutions ..........................................................................................................................................1168 
Instalar do aplicativo ..........................................................................................................................................1168 
Aplicativos personalizados e assistentes de classe..............................................................................................1168 
Editor de recursos ...............................................................................................................................................1169 
ATL......................................................................................................................................................................1169 
MFC ....................................................................................................................................................................1170 
O que há de novo no Managed projetos de dispositivo .......................................................................................1170 
Como Iniciar o Emulador de Dispositivo no Visual Studio.................................................................................1171 
Visão geral do acesso de dados (projetos do dispositivo gerenciado) ................................................................1172 
Visão geral Solutions do dispositivo de embalagem ...........................................................................................1173 
Alternar plataformas em projetos de dispositivo.................................................................................................1174 
Ferramentas Remotas para Projetos de Dispositivos .........................................................................................1174 
Visão geral sobre segurança (dispositivos).........................................................................................................1175 
Seleção método de conexão.................................................................................................................................1176 
Atualizando Projetos Criados com Ferramentas Anterior..................................................................................1178 
Selecionando uma Linguagem de Desenvolvimento............................................................................................1179 
Visual C# Consolidado 15
Programação para Dispositivos usando o .NET Compact Framework ..............................................................1182 
Referência do .NET Compact Framework para Projetos de Dispositivos ..........................................................1183 
Gerenciando Trechos de Código em Projetos Dispositivos ................................................................................1186 
Diferenças entre depuradores de dispositivos e de desktop ................................................................................1194 
IMPLANTAÇÃO (COMO FAZER EM C#) .......................................................................................................................1235 
 
Visual C# Consolidado 16
VISUAL C# 
 
Microsoft Visual C# 2005, pronunciado C sharp, é uma linguagem de programação projetada para 
criar uma ampla variedade de aplicativos executados no .NET Framework. C# é simples, 
poderoso, com segurança de tipos, e orientada a objetos. Com suas muitas inovações, C# permite 
o desenvolvimento rápido de aplicativos mantendo a expressividade e elegância das linguagens 
do estilo C. 
Visual Studio oferece suporte ao Visual C# com um editor de códigos completo, modelos de 
projeto, designers, assistentes de código, depurador poderoso e de fácil uso, e outras 
ferramentas. A biblioteca de classes do .NET Framework fornece acesso a uma grande variedade 
de serviçosdo sistema operacional e outras classes úteis, e bem estruturadas que aceleram o 
ciclo de desenvolvimento significativamente. 
Nesta seção 
 
Guia de Introdução ao Visual C# 
Apresenta os recursos do C# 2.0 para programadores novos para a linguagem ou novos 
para o Visual Studio, e fornece um roadmap para encontrar ajuda no Visual Studio. Isso 
também está localizado nas páginas "Como Fazer". 
Usando o Visual C# IDE 
Apresenta o ambiente de desenvolvimento do Visual C#. 
Escrevendo aplicativos com Visual C# 
Fornece uma orientação de alto nível abrangendo tarefas comuns de programação usando 
C# e o .NET Framework, com links para a documentação mais detalhada. 
Migrando para o Visual C# 
Compara a linguagem C# com Java e C++ e descreve como usar o Java Language 
Conversion Assistant para converter aplicativos Java e Visual J++ para Visual C#. 
Guia de programação C # 
Fornece informações e exemplos práticos sobre como usar construções de linguagem C#. 
Referência C# 
Fornece informações de referência detalhadas em conceitos de programação C#, 
palavras-chave, tipos, operadores, atributos, diretivas de pré-processador, opções de 
compilador, e erro de compilador e avisos. 
Especificação da linguagem C# 
Links para a versão mais recente das especificações C# no formato Microsoft Word. 
Exemplos de Visual C# 
Exemplo de código fonte que demonstram como programar usando Visual C#. 
Visual C# Consolidado 17
GUIA DE INTRODUÇÃO AO 
VISUAL C# 
Os tópicos a seguir ajudam a iniciar o desenvolvimento de aplicativos usando o Microsoft Visual 
C# 2005. Esses tópicos também lhe introduzirão a muitos novos recursos no Microsoft Visual 
Studio 2005 como versão 2.0 da linguagem C#. 
Nesta seção 
Guia da documentação do Visual C# 
Fornece uma orientação de alto nível sobre o conteúdo da documentação Visual C#. 
Introdução à linguagem C# e ao Framework .NET 
Fornece uma visão geral sobre a linguagem C# e a plataforma .NET. 
O Que Há de Novo no Visual C-# 2005 
O que há de novo no Microsoft Visual C# 2005. 
O Que Há de Novo na Linguagem e Compilador C# 2.0 
O que há de novo na versão 2.0 do C#. 
Atualizando Aplicativos Visual C# para Visual Studio 2005 
Atualizando seus projetos existentes para o Microsoft Visual Studio 2005. 
Criando Seu Primeiro Aplicativo C# 
Escrevendo, compilando e executando um simples aplicativo C#. 
Usando Starter Kits C# 
Usando os Starter Kits C#. 
Recursos de ajuda adicionais (Visual C#) 
Links para outros recursos de ajuda. 
Como Fazer em C# 
Links para tópicos que mostram como executar uma variedade de tarefas específicas. 
Guia da Documentação do Visual C# 
A documentação do Microsoft Visual C# 2005 contém informações que são específicas para a 
linguagem C#, como palavras-chave, opções de compilador, mensagens de erro e conceitos de 
programação. Esta documentação também oferece uma visão geral de como usar o ambiente de 
desenvolvimento integrado (IDE). Além disso, existem muitos links para obter ajuda detalhada 
sobre classes .NET Framework, desenvolvimento da Web do ASP.NET, depuração, programação 
de banco de dados SQL e muito mais. 
O diagrama a seguir fornece uma exibição dos conceitos do conteúdo da documentação do Visual 
C# e o relacionamento deste conteúdo com outras seções relevantes da documentação do Visual 
Studio e a MSDN on-line. 
Visual C# Consolidado 18
 
Introdução à linguagem C# e ao .NET Framework 
C# é uma linguagem elegante orientada a objetos e fortemente tipada que permite aos 
desenvolvedores criar uma ampla variedade de aplicativos seguros e eficientes que são 
executados sob o .NET Framework. Você pode usar C# para criar aplicativos clientes tradicionais 
do Windows , XML Web services, componentes distribuídos, aplicativos cliente-servidor, 
aplicativos de banco de dados, e muito, muito mais. Microsoft Visual C# 2005 fornece um editor de 
código avançado, designers de interface de usuário convenientes, depurador integrado, e muitas 
outras ferramentas para facilitar o rápido desenvolvimento de aplicativos com base na versão 2.0 
da linguagem C# e do .NET Framework. 
Observação 
A documentação Visual C# presume que você tenha uma compreensão dos conceitos básicos 
existentes de programação. Se você for um completo principiante, convém explorar Visual C# 
Express Edition, que está disponível na Web. Você também pode aproveitar qualquer um dos 
diversos livros excelentes e recursos da Web em C# para aprender técnicas de prática de 
programação. 
Linguagem C# 
A sintaxe C# é altamente expressiva, mas com menos de 90 palavras-chave, também é simples e 
fácil para aprender. A sintaxe do C# utilizando chaves como marcador de blocos será 
instantaneamente reconhecível para qualquer pessoa familiarizada com C, C++ ou Java. Os 
desenvolvedores que conhecem qualquer uma dessas linguagens são normalmente capazes de 
começar a trabalhar produtivamente em C# dentro de muito pouco tempo. A sintaxe C# simplifica 
muitas das complexidades de C++ enquanto fornece recursos poderosos como tipos de valor 
anulável, enumerações, delegações, métodos anônimos e acesso direto à memória, que não 
foram localizados em Java. C# também oferece suporte a métodos e tipos genéricos, que 
fornecem aumento de segurança e desempenho, e iteradores, que permitem implementadores 
das classes de coleção definirem comportamentos personalizados da iteração que são simples 
para usar pelo código do cliente. 
Visual C# Consolidado 19
Como uma linguagem orientada a objetos, C# suporta os conceitos de encapsulamento, herança 
e polimorfismo. Todas as variáveis e métodos, incluindo o método Main, ponto de entrada do 
aplicativo, são encapsulados em definições da classe. Uma classe pode herdar diretamente de 
uma classe pai, mas ela pode implementar qualquer número de interfaces. Métodos que 
substituem métodos virtuais em uma classe pai exigem a palavra-chave override como uma 
forma para evitar redefinição acidental. No C#, uma estrutura é como uma classe simplificada; ele 
é um tipo alocado na pilha que pode implementar interfaces mas não tem suporte a herança. 
Além desses princípios orientados a objetos, C# facilita o desenvolvimento de componentes de 
software através de vários construtores inovadores da linguagem, incluindo: 
• Assinaturas de métodos encapsulados chamadas delegações, que permitem notificações 
de eventos fortemente tipados. 
• Propriedades, que servem como accessadores de variáveis membros privadas. 
• Atributos, que fornecem metadados declarativos sobre tipos no tempo de execução. 
• Comentários internos da documentação XML. 
Se você precisar interagir com outro software Windows como objetos COM ou DLLs nativas 
Win32, você pode fazer isso em C# através de um processo denominado "Interoperabilidade". 
Interoperabilidade permite que programas C# façam praticamente tudo que um aplicativo C++ 
nativo pode fazer. C# também suporta ponteiros e o conceito de código "inseguro" para os casos 
no qual o acesso direto a memória é absolutamente essencial. 
O processo de compilação C# é simples comparado ao C e C++ e mais flexível do que em Java. 
Não há nenhum arquivo cabeçalho separado, e nenhum requisito de que métodos e tipos sejam 
declarados em uma ordem específica. Um arquivo fonte C# pode definir qualquer número de 
classes, estruturas, interfaces, e eventos. 
Arquitetura da plataforma .NET Framework 
Programas C# são executados no .NET Framework, um componente integrante do Windows que 
inclui um sistema de execução virtual chamado de Common Language Runtime (CLR) e um 
conjunto unificado de bibliotecas de classe. O CLR é implementação comercial da Microsoft do 
Common Language Infrastructure (CLI), um padrão internacional que é a base para criar 
ambientes de execução e desenvolvimento nos quais linguagens e bibliotecas trabalham 
perfeitamente juntas. 
Código fonte escrito em C# é compilado em uma linguagem intermediária (IL) que está em 
conformidade com a especificação CLI. O código IL, juntamentecom recursos como bitmaps e 
seqüências de caracteres, é armazenado em disco em um arquivo executável chamado de 
assembly, normalmente com uma extensão .exe ou .dll. Um assembly contém um manifesto que 
fornece informações sobre tipos do assembly, versão, cultura, e requisitos de segurança. 
Quando o programa C# é executado, o módulo (assembly) é carregado no CLR, que pode levar a 
várias ações com base nas informações no manifesto. Em seguida, se os requisitos de segurança 
forem atendidos, o CLR executa a compilação Just-In-Time (JIT) para converter o código IL em 
instruções nativas da máquina. O CLR também oferece outros serviços relacionados a coleta de 
lixo automática, tratamento de exceção, e gerenciamento de recursos. Código que é executado 
pelo CLR é as vezes conhecido como "código gerenciado", em contraste com "código não 
gerenciado" que é compilado em linguagem de máquina nativa que atinge um sistema específico. 
O diagrama a seguir ilustra os relacionamentos entre o tempo de compilação e o tempo de 
execução dos arquivos de código fonte C#, as bibliotecas de classes base, módulos (assemblies), 
e o CLR. 
Visual C# Consolidado 20
 
A interoperabilidade da linguagem é um recurso chave do .NET Framework. Por estar em 
conformidade com o Common Type Specification (CTS), o código IL produzido pelo compilador C# 
pode interagir com código que foi gerado a partir das versões .NET do Visual Basic, Visual C++, 
Visual J#, ou qualquer uma das outras mais de 20 linguagens CTS-Compliant. Um conjunto único 
pode conter vários módulos escritos em linguagens .NET diferentes, e os tipos podem se 
referenciar como se eles fossem escritos na mesma linguagem. 
Além dos serviços de tempo de execução, o .NET Framework também inclui uma biblioteca 
abrangente com mais de 4000 classes organizadas em namespaces que fornecem uma variedade 
de funcionalidades úteis para tudo desde entrada e saída de arquivo até manipulação de 
seqüência para análise XML e controles de Windows Forms. Uma aplicação C# típica usa 
amplamente a biblioteca de classe do .NET Framework para manipular tarefas comuns de 
"conexões internas". 
O que há de novo no Visual C# 2005 
O Microsoft Visual C# 2005 inclui novos recursos nas áreas a seguir: 
• Linguagem e Compilador 
• Editor de códigos 
• Ambiente de desenvolvimento 
• Documentação e especificação de linguagem 
• Depuração 
Linguagem e Compilador 
A linguagem C# agora suporta tipos genérico, iteradores e tipos parciais. A versão mais recente 
do compilador C# também inclui novos recursos e opções. Para mais informações, consulte O que 
há de novo na Linguagem e Compilador C# 2.0. 
Editor de códigos 
O Editor de códigos contém os seguintes recursos novos para Visual C# 2005. 
Trechos de código 
Visual C# Consolidado 21
Trechos de códigos aumentam a velocidade de entrada de códigos de construção comuns 
fornecendo um modelo que pode ser preenchido. Trechos são armazenados como arquivos XML 
que podem ser facilmente editados e personalizados. 
• Trechos de códigos (C#) 
• COMO: Usar trechos de código (C#) 
• COMO: Usar trechos de código circunscritos 
Refatoração 
Ferramentas de refactoração podem automaticamente reestruturar seu código fonte, por exemplo, 
promovendo as variáveis locais para parâmetros ou convertendo um bloco de código em um 
método. 
• COMO: Promover variável local para parâmetro 
• Extrair o método 
• Encapsular o campo 
• Extrair a interface 
• Renomear 
• Remover parâmetros 
• Reordenar parâmetros 
Ambiente de Desenvolvimento 
O ambiente de desenvolvimento inclui os seguintes aperfeiçoamentos para Visual C# 2005. 
O IntelliSense 
O IntelliSense foi aprimorado com os novos recursos a seguir: 
• A lista de conclusão de List Members aparece automaticamente quando você volta com o 
cursor para um operador de escopo que precede um objeto, ou quando você desfaz a ação de 
conclusão. 
• Quando você escreve código de tratamento de erros, o Membros lista o ajuda a descobrir 
qual exceção atrair filtrando membros irrelevantes da lista de conclusão em uma cláusula 
catch. 
• Quando você precisa inserir código padronizado, o Automatic Code Generation agora 
permite que você determine que o IntelliSense insira o código para você. 
• IntelliSense está disponível ao criar aplicativos da Web. 
Class Designer 
O Class Designer é um novo editor que exibe graficamente classes e tipos e permite que os 
métodos sejam adicionados ou modificados. Também é possível usar ferramentas de refatoração 
a partir da janela Class Designer. 
• Consulte Projetando e exibindo classes e tipos. 
Banco de Testes de Objeto 
O banco de testes de objeto é projetado para teste simples a nível de objeto. Permite criar uma 
instância de um objeto e chamar seus métodos. 
• Consulte Banco de Testes de Objeto. 
Implantação ClickOnce 
A implantação ClickOnce permite que você publique aplicativos do Windows em um servidor Web 
ou em compartilhamento de arquivos de rede para instalações simplificadas. 
Visual C# Consolidado 22
• Consulte Implantação ClickOnce. 
Suporte a Ferramentas para Assemblies Fortemente Nomeados 
A caixa de diálogo Project Properties foi reprojetada, e agora inclui suporte para assinatura a 
assemblies. 
• Consulte Propriedades do Projeto. 
Assistentes de Código 
Os assistentes código a seguir estão agora obsoletos: 
• Assistente para o método C# 
• Assistente para a propriedade C# 
• Assistente para o campo C# 
• Assistente para o indexador C# 
Documentação e Especificação de Linguagem 
Amplamente a documentação de referência do C# tem sido regravada para fornecer informações 
mais completas para perguntas comuns assim como avançadas de uso que os desenvolvedores 
podem encontrar ao criar aplicativos em C#. 
O especificador de linguagem do C# está mais integrado para o ambiente de Ajuda, mas é 
fornecido em dois arquivos .doc. Esses arquivos são instalados por padrão em \\Microsoft 
Visual Studio 8\vcsharp\specifications\1033\. As versões mais atualizadas podem 
ser baixadas na Central de Desenvolvimento do C# no MSDN. Para mais informações, consulte 
Especificação de Linguagem do C#. 
Melhorias na Depuração Específica do C# 
Novos recursos, incluindo Edit e Continue, foram adicionados para auxiliar o desenvolvedor C#. 
O que há de novo na C# 2.0 idioma e Compiler 
Com o lançamento do Visual Studio 2005, a linguagem C# foi atualizada para versão 2.0, que 
oferece suporte os seguintes recursos novos: 
Tipos genéricos 
Tipos genéricos são adicionados ao idioma para ativar os programadores para atingir um 
nível alto de reutilização e desempenho avançado para classes coleção. Tipos genéricos 
podem diferir somente por aridade. Parâmetros também podem ser forçados a ser tipos 
específicos. Para obter mais informações, consulte Parâmetros genéricos tipo. 
Iteradores 
Iterators facilitam para ditar um foreach loop como será iterar sobre uma coleção o 
conteúdo. 
Classes parciais 
Definições de tipo parcial permitem que um tipo simples, a ser dividida em vários arquivos, 
como uma classe,. O designer visual studio utiliza esse recurso para separar seu código 
gerado do código do usuário. 
Tipos anulável 
Tipos anuláveis permitem que uma variável para conter um valor que é indefinido. Tipos 
anuláveis são úteis quando trabalhar com bancos de dados e outras estruturas de dados 
que podem conter elementos que contêm sem valores específicos. 
Métodos anônimo 
Visual C# Consolidado 23
Agora é possível para passar um bloco de código como um parâmetro. Qualquer Lugar um 
representante é esperado, um bloco de código poderá ser usado: não é necessário para 
definir um novo método. 
Qualificador alias Namespace 
O qualificador alias espaço para nome. proporciona mais controle sobre acessar membros 
espaço para nome (::) O global:: alias permite acesso a raiz que pode estar ocultas por 
uma entidade em seu código. 
Classes estáticas 
Classes estáticas são uma maneira segura e conveniente de declararuma classe que 
contém métodos estáticos que não podem ser instanciados. Em C# versão 1.2 você seria 
tenha definido o construtor de classe como particular para impedir que a classe sendo 
instanciado. 
Alias assembly externo 
Referência versões diferentes do mesmo componente contidos no mesmo conjunto com 
esse uso expandido de palavra-chave extern. 
Propriedade acessibilidade Accessor 
Do get agora é possível para definir diferentes níveis de acessibilidade para e set 
assessores em Propriedades. 
Covariância e Contravariance em representantes 
O método passado para um representante agora podem ter maior flexibilidade no seu tipo 
de retorno e parâmetros. 
HOW TO: Declare, Instantiate, e usar um representante 
Método conversão de grupo fornece uma sintaxe simplificada para declarar 
representantes. 
Buffers tamanho fixo 
Em um bloco código desprotegido, agora é possível para declarar estruturas de tamanho 
fixo com matrizes incorporados. 
Conjuntos de amigo 
Conjuntos podem fornecer acesso a tipos não-públicos para outros conjuntos. 
Controle de aviso embutido 
A #pragma diretiva de aviso pode ser usada para desativar e ativar determinados avisos 
do compilador. 
volátil 
Agora pode ser aplicada a IntPtr palavra-chave volatile e UIntPtr. 
O compilador C# apresenta os seguintes adições e alterações para esta versão: 
Opção /errorreport 
Pode ser usado para relatar erros de compilador interno à Microsoft através da Internet. 
Opção /incremental 
Foi removido. 
e /keycontainer/KeyFile Opções 
Oferecer suporte à especificação chaves criptográficas. 
Opção /langversion 
Pode ser usado para especificar compatibilidade com uma versão específica do idioma. 
Visual C# Consolidado 24
Opção /linkresource 
Contém opções adicionais. 
Opção /moduleassemblyname 
Permite que você se criar um.netmodule tipos de arquivo e acesso não-públicos em um 
conjunto existente. 
Opção /PDB 
Especifica o nome e local do arquivo.pdb. 
Opção /Platform 
Permite que você para arquiteturas Family (IPF) Itanium e x 64 de destino. 
Aviso # pragma 
Usado para desativar e ativar individuais avisos no código. 
Atualizando Aplicativos Visual C# para Visual Studio 2005 
Quando você abre um arquivo de projeto ou de solução criado por uma versão anterior do Visual 
Studio, o Assistente para Atualização guia você através do processo de converter seu projeto para 
Visual Studio 2005. O Assistente para Atualização executa várias tarefas, entre elas: cria novas 
propriedades e atributos e exclui os obsoletos, mas como a verificação de erros tornou-se mais 
rígida, você pode encontrar novos erros ou mensagens de aviso que não foram produzidos pela 
versão anterior do compilador. Assim, a etapa final na atualização de um aplicativo existente é 
fazer as alterações de código necessárias para resolver quaisquer novos erros. 
Freqüentemente, um código que produzia uma certa mensagem nas versões anteriores do 
compilador de C# produz uma mensagem diferente na versão atual. Normalmente, isso se deve 
ao fato de que uma mensagem geral foi substituída por uma mais específica. Como nenhuma 
alteração no código é necessária, essas diferenças não foram documentadas. 
A seguir, estão as novas mensagens que o 'Assistente para Atualização' gera devido à verificação 
de erros mais rigorosa. 
Novas Mensagem de Erro e de Aviso 
CS0121: Ambiguous call (Chamada ambígua) 
Devido a uma conversão implícita, o compilador não foi capaz de chamar uma implementação 
específica de um método sobrecarregado. Você pode resolver este erro das seguintes formas: 
• Especificar os parâmetros do método de tal forma que a conversão implícita não exista. 
• Remover todos as outras implementações do método. 
• Converter para um tipo apropriado antes de chamar o método. 
CS0122: Method inaccessible due to its protection level (Método 
inacessível devido ao seu nível de proteção) 
Você poderá receber este erro ao fazer referência um tipo em um assembly compilado pelo C++ 
que foi compilado com a opção de compilador /d1PrivateNativeTypes. 
Este erro ocorre porque, na versão atual, um assembly C++ produz uma assinatura que usa um 
tipo que não está marcado como público. 
Você pode contornar esse problema usando a opção /test:AllowBadRetTypeAccess do 
compilador. Esta opção será removida quando este recurso foi corrigido. 
CS0429: Unreachable expression code detected (Expressão de código 
inatingível detectada) 
Visual C# Consolidado 25
Este erro ocorre sempre que parte de uma expressão em seu código é inatingível. Por exemplo, a 
condição false && myTest() casa com esse critério, pois o método myTest() nunca será 
executado já que o lado esquerdo da operação && é sempre falso. Para corrigir isso, refaça o 
teste lógico para eliminar o código inacessível. 
CS0441: A class cannot be both static and sealed (Uma classe não pode 
ser ao mesmo tempo estática e lacrada) 
Todas as classes estáticas são também classes lacradas. A especificação de linguagem C# 
proíbe a especificação de ambos os modificadores em uma classe e o compilador agora relata 
isso como um erro. 
Para corrigir esse erro, remova sealed da classe. 
CS1699: Warning on use of assembly signing attributes (Alerta no uso de 
atributos de assinatura de assembly) 
Os atributos de assembly que especificam assinatura foram movidos do código para opções do 
compilador. Usar os atributos AssemblyKeyFile ou AssemblyKeyName no código produz este 
aviso. 
Em vez desses atributos, você deve usar as opções de compilador a seguir: 
• Use a opção de compilador /keyfile (Especifica um Arquivo Chave de Nome Forte) 
(Opções do Compilador de C#) ao invés do atributo AssemblyKeyFile, e use /keycontainer 
(Especifica um Contêiner de Chave de Nome Forte) (Opções do Compilador de C#) ao invés 
de AssemblyKeyName. 
Não mudar para as opções de linha de comando não pode dificultar os diagnósticos do 
compilador quando friend assemblies estiverem sendo usados. 
Se você estiver usando /warnaserror (Trata Aviso como Erros) (Opção do Compilador de C#), 
você pode converter de volta para um aviso adicionando /warnaserror-:1699 a linha de 
comando do seu compilador. Se necessário, você pode desativar o aviso usando 
/nowarn:1699. 
Incremental compilation removed (Compilação incremental removida) 
A opção /incremental do compilador foi removida. O recurso de Edição e Continuação substitui 
essa funcionalidade. 
Criando Seu Primeiro Aplicativo C# 
Somente leva um minuto para criar um aplicativo C#. Siga estas etapas para criar um programa 
que abre uma janela e reage a um pressionamento de botão. 
Procedimentos 
Para criar um aplicativo C# 
1. No menu File, aponte para New, e em seguida, clique em Project 
2. Verifique se o modelo Windows Application está selecionado, no campo Name, 
digite MyProject , e clique em OK. 
Você verá um Windows Form no designer de Windows Forms. Essa é a interface de usuário 
para seu aplicativo. 
3. No menu View, clique em Toolbox para tornar a lista de controles visível. 
4. Expanda a lista Common Controls, e arraste o controle Label para seu formulário. 
5. Também da lista Common Controls, arraste um botão para o formulário, próximo ao 
Label. 
Visual C# Consolidado 26
6. Clique duas vezes no novo botão para abrir o Editor de Código. Visual C# inseriu um 
método chamado button1_Click que é executado quando o botão for clicado. 
7. Altere o método para ter esta aparência: 
private void button1_Click(object sender, EventArgs e) {label1.Text = "Hello, World!";} 
8. Pressione F5 para compilar e executar o aplicativo. 
Quando você clicar no botão, é exibida uma mensagem de texto. Parabéns! Você acabou 
de escrever seu primeiro aplicativo C#. 
Usando Starter Kits C# 
Um Starter Kit é um aplicativo completo e independente pronto para você carregar e compilar. Um 
Starter Kit vem com sua própria documentação, incluindo descrições de técnicas de programação, 
e sugestões para como ele pode ser personalizado. StarterKit é uma maneira excelente de ver 
um aplicativo C# que funciona em ação. 
Para carregar e compilar um Starter Kit Visual C# 
1. No menu File, clique em New Project. 
A caixa de diálogo New Project será exibida. Esta caixa de diálogo lista os diferentes 
tipos de aplicativos padrão que Visual C# pode criar. 
2. Selecione um tipo de aplicativo Starter Kit, e clique em OK. 
O Starter Kit é carregado no Visual C#. 
3. Para compilar e iniciar o projeto Starter Kit, pressione F5. 
Recursos de Ajuda Adicionais (Visual C#) 
Os sites e grupos de notícias a seguir lhe ajudarão a encontrar respostas para problemas comuns 
e não tão comuns. 
Recursos Microsoft 
Os sites a seguir são mantidos pela Microsoft e hospedam artigos e grupos de discussão sobre 
tópicos de interesse para os desenvolvedores C#. 
Na Web 
A Ajuda do Microsoft e Suporte 
Fornece acesso a artigos da KB, downloads e atualizações, WebCasts de suporte e outros 
serviços. 
O Microsoft Visual C# Developer Center 
Fornece exemplos de código, informações sobre atualização, e conteúdo técnico. 
Grupos de discussão MSDN 
Fornece uma maneira para conectar-se a uma comunidade de especialistas de todo o 
mundo. 
Fóruns 
Forums técnico da Microsoft 
Fóruns discussão baseados na Web para muitas tecnologias Microsoft incluindo C# e o 
Framework .NET. 
Grupos de notícias 
microsoft.public.dotnet.languages.csharp 
Fornece um fórum para perguntas e discussão geral sobre Visual C#. 
Visual C# Consolidado 27
microsoft.public.vsnet.general 
Fornece um fórum para perguntas e problemas no Visual Studio. 
microsoft.public.vsnet.IDE 
Fornece um fórum para perguntas sobre como trabalhar no ambiente Visual Studio. 
microsoft.public.vsnet.documentation 
Fornece um fórum para perguntas e problemas na documentação Visual C#. 
Recursos de terceiros 
O site do MSDN fornece informações sobre sites de terceiros e grupos de notícias de atual 
interesse. Para a lista mais atual dos recursos disponíveis, consulte o Site MSDN Community. 
Como Fazer em C# 
Como Fazer é sua porta de entrada para tópicos-chave baseados em tarefas sobre programação 
e desenvolvimento de aplicativos em C#. As categorias essenciais sobre o que você pode fazer 
com C# estão listadas neste tópico. Os links fornecem referências para páginas de ajuda 
importantes baseadas em procedimento. 
A Linguagem C# 
Especificação da Linguagem C# ... Threading… Genéricos... Trechos de Código… 
Exemplos… mais 
O Framework .NET 
Entrada e Saída em Arquivos… Strings… Coleções… Serialização… Componentes… 
Módulos (assemblies) e Domínios de Aplicativo… mais 
Aplicativos do Windows 
Criando Aplicativos do Windows… Controles…Windows Forms… Desenhando… mais 
Páginas Web e Web Services 
Pages Web do ASP.NET… XML Web Services… mais 
Depuração 
Usando o Depurador VS… Classe Trace .Framework NET… Depuração de Transações 
SQL… mais 
Accesso a Dados 
Conectando a Fontes de Dados… O SQL Server... Vinculação de Dados… mais 
Criando Classes 
Class Designer... Trabalhando com Classes e Outros Tipos... Criando e Modificando 
Membros-tipo... Linhas-mestras para a Criação de Bibliotecas de Classes… mais 
Segurança 
Segurança no Acesso ao Código… Práticas Recomendadas de Política de Segurança… 
Conjuntos de Permissões… mais 
Programação do Office 
Programação do Office… Controles… Word… Excel… mais 
Dispositivos Inteligentes 
O que há de novo em Projetos para Dispositivos Inteligentes... Programação para 
Dispositivos Inteligentes... Depuração em Dispositivos Inteligentes... mais 
Implantação 
Visual C# Consolidado 28
ClickOnce… O Windows Installer 
Recursos adicionais 
Os seguintes sites requerem uma conexão com a Internet. 
Visual Studio 2005 Developer Center 
Contém vários artigos e recursos sobre o desenvolvimento de aplicativos usando o Visual 
Studio 2005. Este site é atualizado regularmente com novo conteúdo. 
Visual C# Developer Center 
Contém vários artigos e recursos sobre desenvolvimento de aplicativos C#. Este site é 
atualizado regularmente com novo conteúdo. 
Microsoft .NET Framework Developer Center 
Contém vários artigos e recursos em desenvolvimento e depuração de aplicativos do 
Framework .NET. Este site é atualizado regularmente com novo conteúdo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
Visual C# Consolidado 29
USANDO O IDE DO VISUAL C# 
Esta seção lhe apresenta ao ambiente de desenvolvimento integrado (IDE) do Visual C# e 
descreve como ele é usado em todas as fases do ciclo de desenvolvimento, indo desde como 
configurar um projeto até distribuir o aplicativo concluído para usuários finais. 
Introdução à IDE (Visual C#) 
O ambiente de desenvolvimento integrado (IDE) do Visual C# é uma coleção de ferramentas de 
desenvolvimento expostas por meio de uma interface de usuário comum. Algumas das 
ferramentas são compartilhados com outras linguagens do Visual Studio, e algumas, como o 
compilador C#, são exclusivas para Visual C#. A documentação nesta seção fornece uma visão 
geral de como usar as ferramentas mais importantes do Visual C# enquanto você trabalha na IDE 
em várias fases do processo de desenvolvimento. 
Observação 
Se você estiver desenvolvendo um aplicativo ASP.NET 2.0, você irá usar a IDE Visual Web 
Developer, que é uma parte totalmente integrada do Visual Studio 2005. Entretanto, se suas 
páginas code-behind estiverem em Visual C#, você estará utilizando o Editor de Códigos do Visual 
C# dentro do Visual Web Developer. Portanto, alguns tópicos nesta seção, como Projetando uma 
interface de usuário (Visual C#), talvez não sejam completamente aplicáveis a aplicativos da Web.
Ferramentas Visual C# 
A seguir estão as mais importantes ferramentas e janelas no Visual C#. As janelas para a maioria 
dessas ferramentas podem ser abertas a partir do menu View. 
• O Editor de Códigos, para escrever código fonte. 
• O compilador C#, para converter código fonte C# em um programa executável. 
• O depurador do Visual Studio, para testar seu programa. 
• O Toolbox (Caixa de Ferramentas) e o Designer, para o desenvolvimento rápido de 
interfaces de usuário usando o mouse. 
• Solution Explorer (Gerenciador de Soluções) para exibir e gerenciar arquivos de 
projeto e configurações. 
• Designer de Projeto, para configurar opções do compilador, caminhos de 
implantação, recursos, e mais. 
• Modo de Exibição de Classe, para navegar através de código fonte de acordo com 
tipos, não arquivos. 
• Janela Properties (Janela de Propriedades), para configurar propriedades e eventos 
nos controles na sua interface de usuário. 
• Pesquisador de objetos para exibir os métodos e as classes disponíveis em bibliotecas de 
vínculo dinâmico incluindo assemblies do .NET Framework e objetos COM. 
• Gerenciador de Documento, para navegação e pesquisa de documentação do produto em 
sua máquina local e na Internet. 
Como a IDE expõe as ferramentas 
Você interage com as ferramentas através de janelas, menus, páginas de propriedades, e 
assistentes na IDE. A IDE básica tem mais ou menos esta aparência: 
Visual C# Consolidado 30
 
Rapidamente você pode acessar qualquer janela de ferramenta aberta ou arquivos, pressionando 
CTRL + TAB. Para mais informações, consulte Navegando e procurando (Visual C#). 
Janelas do Editor e do Windows Form Designer 
A janela principal é usada pelo Editor de Códigos e pelo Windows Forms Designer. Você pode 
alternar entre o modo Código e o modo Design pelo pressionamento da tecla F7, ou clicando em 
Code ou Designer no menu View. Enquanto estiver no modo Design, você pode arrastar 
controles da Caixa de Ferramentas para a janela , que você poderá tornar visível clicando na 
guia Toolbox na margem esquerda. Para obter mais informações sobre o Editor de Códigos, 
consulte Editando Código (Visual C#). Para obter mais informações sobre o Windows Forms 
Designer, consulte O Windows Forms Designer. 
A janela Properties no canto inferior direito é povoada somente no modo Design. Ela permite a 
você definir propriedadese ligar eventos a controles de interface de usuário como botões, caixas 
de texto, e assim por diante. Quando você define esta janela como Ocultar 
Automaticamente, ela será colapsada na margem direita sempre que você alternar para o 
Modo Código. Para obter mais informações sobre a janela Properties e o Designer, consulte 
Projetando uma interface de usuário (Visual C#). 
Gerenciador de Soluções e Designer de Projeto 
A janela na parte superior direita é a do Gerenciador de Soluções, que mostra todos os 
arquivos em seu projeto em um modo de exibição de árvore hierárquica. Quando você usa o 
menu Project para adicionar novos arquivos ao seu projeto, você os verá refletidos no 
Gerenciador de Soluções. Além dos arquivos, o Gerenciador de Soluções também 
exibe as configurações do projeto, e referências a bibliotecas externas exigidas pelo seu 
aplicativo. 
As páginas de propriedades do Designer de Projeto são acessadas com o botão direito do 
mouse no nó Properties no Gerenciador de Soluções, e clicando Open. Use essas 
páginas para modificar opções de compilação, requisitos de segurança, detalhes de implantação, 
e muitas outras propriedades do projeto. Para obter mais informações sobre o Gerenciador de 
Soluções e o Designer de Projeto, consulte Criando um Projeto (Visual C#). 
Janela do Compilador, do Depurador, e de Lista de Erros 
O compilador C# não tem nenhuma janela porque ele é não uma ferramenta interativa, mas você 
pode definir opções do compilador no Designer de Projeto. Quando você clica em Build no 
menu Build , o compilador C# é chamado pela IDE. Se a compilação for bem sucedida, o painel 
de status exibe uma mensagem compilação bem sucedida. Se houver erros de compilação, a 
janela Error List aparece abaixo da janela Editor/Designer com uma lista de erros. Dê um duplo 
clique em um erro para ir para a linha com problema no seu código fonte. Pressione F1 para 
consultar a documentação de Ajuda para o erro realçado. 
O Depurador tem várias janelas que exibem valores de variáveis e informações de tipo quando o 
seu aplicativo está sendo executado. Você pode usar a janela do Editor de Códigos durante a 
depuração para especificar uma linha na qual pausar a execução, e depurar o código linha a linha. 
Para mais informações, consulte Criando e Depurando (Visual C#). 
Visual C# Consolidado 31
Personalizando a IDE 
Toda janela no Visual C# pode ser feita ancorável ou flutuante, oculta ou visível, ou pode ser 
movida para novos locais. Para alterar o comportamento de uma janela, clique nos ícones da seta 
para baixo ou push-pin na barra de título e selecione dentre as opções disponíveis. Para mover 
uma janela ancorada para um novo local ancorado, arraste a barra de título até que os ícones de 
conta-gotas da janela apareçam. Mantendo pressionado o botão esquerdo do mouse, mova o 
ponteiro do mouse sobre o ícone no novo local. Posicione o ponteiro sobre os ícones esquerda, 
direita, superior ou inferior para encaixar a janela no lado especificado. Posicione o ponteiro sobre 
o ícone meio para tornar a janela uma janela com guias. Como você posiciona o ponteiro, um 
retângulo azul semi-transparente aparece, o qual indica onde a janela será ancorada no novo 
local. 
 
Você pode personalizar muitos outros aspectos da IDE clicando em Options no menu Tools. 
Para mais informações, consulte Opções de Caixa de Diálogo do Visual Studio. 
Criando um Projeto (Visual C#) 
Quando você estiver pronto para iniciar a codificação, a primeira etapa é configurar um projeto. O 
projeto contém todos os materiais processados para seu aplicativo, incluindo não apenas arquivos 
de código fonte, mas também arquivos de recursos como ícones, referências a arquivos externos 
que seu programa depende, e dados de configuração como configurações do compilador. Quando 
você cria um projeto, Visual C# chama o compilador C# e outras ferramentas internas para criar 
um conjunto executável usando os arquivos em seu projeto. 
Criando um novo projeto 
Você cria um novo projeto, clicando no menu File, apontando para New, e clicando em 
Project. 
Observação 
Se você selecionar Web Site em vez de Project, a IDE (ambiente de desenvolvimento integrado) 
Visual Web Developer abre. Este é um ambiente separado e distinto dentro do Visual Studio para 
criar aplicativos ASP.NET. A IDE Visual Web Developer usa o editor de código do Visual C# para 
edição de arquivos code-behind no C#. Se você estiver criando aplicativos da Web, você deve 
usar a documentação do Visual Web Developer principalmente, mas consulte Editando código 
(Visual C#) para obter informações sobre o editor C#. 
A ilustração a seguir mostra a caixa de diálogo New Project. Você pode ver que Visual C# 
está selecionado por padrão na janela em à esquerda, e à direita, você tem a opção de seis ou 
mais modelos de projeto para escolher. Se você expandir o Smart Device ou o nó Other 
Project Types à esquerda, você pode ver que diferentes tipos de projeto aparecem no lado 
direito. 
Visual C# Consolidado 32
 
Starter Kits são outros tipos de modelo de projeto. Se você instalar um Starter Kit, você o verá 
listado na caixa de diálogo New Project. Para mais informações, consulte Starter Kits. 
Depois que você selecionar um modelo de projeto e clicar OK, Visual Studio cria o projeto e você 
está pronto para começar a codificação. Arquivos de projeto, referências, configurações, e 
recursos estão visíveis na janela Solution Explorer (Gerenciador de Soluções) à direita. 
 
Visual C# Consolidado 33
O que há em seu projeto? 
Propriedades 
O nó Properties representa definições de configuração que se aplicam a seu projeto inteiro e 
são armazenados no arquivo .csproj na sua pasta solução. Essas configurações incluem opções 
de compilação, segurança, configurações de implantação e muito mais. Você faz modificações em 
seu projeto usando o Designer de Projeto, que é um conjunto de Páginas de 
Propriedades que você acessa clicando com o botão direito do mouse em Properties, e 
selecionando Open. Para mais informações, consulte Modificando propriedades de projeto 
(Visual C#). 
Referências 
No contexto de um projeto, uma referência simplesmente identifica um arquivo binário que seu 
aplicativo requer para executar. Normalmente, uma referência identifica um arquivo DLL como um 
dos arquivos de biblioteca de classe do .NET Framework. Ele também pode fazer referência um 
assembly .NET (chamado de um shim) que permite seu aplicativo chamar métodos em um objeto 
COM ou DLL Win32 nativa. Se seu programa cria uma instância de uma classe que está definida 
em algum outro assembly, você deve adicionar uma referência a esse arquivo em seu projeto 
antes de você compilar o projeto. Para adicionar uma referência, clique em Add Reference no 
menu Project. Todos os projetos C# por padrão incluem uma referência à mscorlib.dll, que 
contém as classes principais do .NET Framework. Você pode adicionar referências a DLLs 
adicionais do .NET Framework e outros arquivos, clicando no menu Project, e selecionando 
Add Reference. 
Observação 
Não confunda o conceito de uma referência de projeto com o conceito de tipos referência em C# 
ou outras linguagens de programação. O primeiro refere-se a um arquivo e seu local esperado no 
disco. O último refere-se a tipos C#, que são declarados usando a palavra-chave class. 
Recursos 
Um recurso é um dado que está incluído no seu aplicativo mas pode ser armazenado de tal forma 
que pode ser modificado independentemente de outro código fonte. Por exemplo, você pode 
armazenar todas as suas seqüências como recursos em vez de embutí-las no código fonte. Você 
pode converter as seqüências em diferentes idiomas mais adiante, e adicioná-las à pasta do 
aplicativo que você entrega a clientes sem precisar recompilar seu assembly. Os cinco tipos de 
recursos definidos pelo Visual C# são: seqüências, imagens, ícones, áudio, e arquivos. Você 
adiciona, remove ou edita recursos usando o Designer de Recursos, que é acessado na guia 
Resourcesno Designer de Projeto. 
Formulários 
Quando você cria um projeto Windows Forms, o Visual C# adiciona um formulário no projeto por 
padrão e chama-o Form1. Os dois arquivos que representam o formulário são chamados 
Form1.cs e Form1.designer.cs. Você escreve seu código no Form1.cs; o arquivo designer.cs é 
onde o Windows Forms Designer escreve o código que implementa todas as ações que você 
realizou arrastando e soltando controles da Caixa de Ferramentas. 
Você pode adicionar um novo formulário, clicando no item de menu Project, e selecionando 
Add Windows Form. Cada formulário tem dois arquivos associados a ele. Form1.cs, ou 
qualquer outro nome que você dê, contém o código fonte que você escreveu para configurar o 
formulário e seus controles, como caixas de listagem e caixas de texto, e responde a eventos 
como clique de botão e pressionamento de tecla. Em projetos simples do Windows Forms, você 
faz a maioria ou toda a sua codificação nesse arquivo. 
O arquivo Designer.cs contém o código fonte que o Forms Designer escreve quando você 
arrasta controles para o formulário, define propriedades na janela Properties, e assim por 
diante. Normalmente, você não deve editar esse arquivo manualmente. 
Visual C# Consolidado 34
Observação 
Obviamente, se você criar um projeto de aplicativos de console, ele não conterá arquivos código 
fonte para Windows Forms. 
Outros arquivos de código fonte 
Um projeto pode incluir qualquer número de arquivos .cs adicionais que pode ou não estar 
associado a um Windows Form específico. Na ilustração anterior do Gerenciador de 
Soluções, program.cs contém o ponto de entrada para o aplicativo. Um único arquivo .cs pode 
conter qualquer número de definições de classe e estrutura. Você pode adicionar arquivos novos 
ou existentes ou classes no seu projeto, clicando em Add New Item ou Add Existing Item 
no menu Project. 
Projetando uma interface de usuário (Visual C#) 
No Visual C#, a maneira mais rápida e conveniente de criar sua interface de usuário (UI) é fazê-la 
visualmente, usando o Windows Forms Designer e o Toolbox. Há três etapas básicas 
para criar todas as interfaces de usuário: 
• Adicionar controles a superfície de criação. 
• Definir propriedades iniciais para os controles. 
• Escrever manipuladores para eventos especificos. 
Embora você também possa criar sua UI escrevendo seu próprio código, designers permitem que 
você realize este trabalho muito mais rapidamente que na codificação manual. 
Observação 
Você pode usar Visual C# para criar aplicativos de console que possuem uma interface 
simplesmente baseada em texto. Para mais informações, consulte Criando aplicativos de console 
(Visual C#). 
Adicionando controles 
No designer, você usa o mouse para arrastar, por Exemplo botões e caixas de texto, para uma 
superfície de projeto que representa o formulário. A ilustração a seguir mostra uma caixa de 
combinação que foi arrastado da janela Toolbox para um formulário no Windows Forms 
Designer. 
Visual C# Consolidado 35
 
Enquanto você trabalha visualmente, o designer converte suas ações em código fonte C# e os 
grava em um arquivo de projeto chamado <nome>designer.cs onde <nome> é o nome que você 
deu para o formulário. Quando seu aplicativo é executado, esse código fonte irá posicionar e 
dimensionar os elementos de UI para que elas apareçam da mesma maneira que na superfície de 
projeto. Para mais informações, consulte O Windows Forms Designer. 
Definindo propriedades 
Após você adicionar um controle ao seu formulário, você pode usar a janela Properties para 
definir suas propriedades, como cor do plano de fundo e texto padrão. Os valores que você 
especificar na janela Properties são simplesmente os valores iniciais que serão atribuídos a 
essa propriedade quando o controle é criado em tempo de execução. Em muitos casos, esses 
valores podem ser acessados ou alterados programaticamente em tempo de execução 
simplesmente obtendo ou definindo a propriedade na instância da classe de controle em seu 
aplicativo. A janela Properties é útil em tempo de criação porque ela permite que você procure 
por todas as propriedades, eventos e métodos suportados por um controle. Para mais 
informações, consulte Janela Properties. 
Tratamento de eventos 
Programas com interfaces de usuário gráficas são principalmente direcionadas a eventos. Elas 
aguardam até que um usuário faça algo como inserir texto em uma caixa de texto, clicar em um 
botão, ou alterar uma seleção em uma caixa de listagem. Quando isso acontece, o controle, que é 
apenas uma instância de uma classe do .NET Framework, envia um evento para seu aplicativo. 
Você pode optar por manipular um evento escrevendo um método especial em seu aplicativo que 
será chamado quando o evento é recebido. 
Você pode usar a janela Properties para especificar que eventos deseja tratar em seu código; 
selecione um controle no designer e clique no botão Events, com o ícone de um raio, na barra 
de ferramentas da janela Properties para ver os seus eventos. O diagrama a seguir mostra o 
botão de eventos. 
 
Quando você adiciona um manipulador de eventos através da janela Properties, o designer 
automaticamente escreverá para você o corpo do método como vazio, e fica por sua conta 
Visual C# Consolidado 36
escrever o código para que o método faça algo útil. A maioria dos controles geram um número 
grande de eventos, mas na maioria dos casos, um aplicativo somente precisará manipular alguns 
deles, ou mesmo somente um. Por exemplo, você provavelmente precisa manipular um evento de 
Click de botão, mas não é necessário manipular seu evento Paint a menos que você deseje 
personalizar a aparência de alguma maneira avançada. 
Próximas Etapas 
Para obter mais informações sobre interfaces de usuário do Windows Forms, consulte os 
seguintes tópicos: 
• Criando aplicativos baseados no Windows 
• Passo a passo: Criando um formulário do Windows simples 
• Elementos de interface de usuário do Windows Forms Designer 
Na biblioteca de classe do. NET Framework, System.Windows.Forms e namespaces relacionados 
contém as classes usadas no desenvolvimento do Windows Forms. 
Editando Código 
Este é um conteúdo traduzido automaticamente que os membros da comunidade podem 
editar. Como tal, a Microsoft não pode garantir a exatidão ou fidelidade em relaçao ao 
conteúdo original. Você pode melhorá-lo usando os controles à direita. 
guest : fazer logon 
minhas configurações 
faq | sugerir alterações 
Ambiente de desenvolvimento do Visual C# 
Editando código (Visual C#) 
O Editor de códigos do Visual C# é um processador de texto para escrever código fonte. 
Assim como o Microsoft Word fornece suporte abrangente para frases, parágrafos, e 
gramática, o editor de códigos C# faz o mesmo para sintaxe C# e para o .NET 
Framework. Este suporte pode ser agrupado em cinco categorias principais: 
• O IntelliSense: Documentação continuamente atualizada sobre as classes .NET 
Framework e os métodos básicos à medida que você digita no editor, e a geração 
de código automática. 
• Refactoring: reestruturação inteligente de sua base de código à medida que ela 
evolui durante o período de um projeto de desenvolvimento. 
• Trechos de código: Você pode procurar uma biblioteca que contém padrões de 
código repetidos freqüentemente. 
• Sublinhado ondulado: Notificações visuais de palavras incorretas, erro de sintaxe e 
situações de aviso conforme você digita. 
• Auxílios de legibilidade: Estrutura de tópicos e colorização. 
O IntelliSense 
IntelliSense é o nome de um conjunto de recursos relacionados que são criados para 
minimizar o tempo gasto procurando por ajuda e para ajudar você a inserir código de 
forma mais precisa e eficiente. Todos esses recursos fornecem informações sobre 
palavras-chave de linguagem, tipos .NET Framework e assinaturas de método à medida 
que você digita no editor. As informações são exibidas em dicas de ferramentas, caixas 
de listagem, e marcas inteligentes. 
Visual C# Consolidado37
Observação 
Muitos dos recursos do IntelliSense são compartilhados com outras linguagens do Visual 
Studio e estão documentadas com ilustrações no nó Ajuda de Codificação da biblioteca 
do MSDN. As seções a seguir fornecem uma visão geral sobre o IntelliSense, com links 
para a documentação mais completa. 
Listas de conclusão 
Quando você insere código-fonte no editor, o IntelliSense exibe uma caixa de listagem 
que contém todas as palavras-chave C# e classes .NET Framework. Se ele encontrar 
uma correspondência na caixa de listagem para o nome que você está digitando, ele 
seleciona o item. Se o item selecionado for o que você deseja, simplesmente você pode 
teclar TAB e o IntelliSense terminará a digitação do nome ou palavra-chave para você. 
Para mais informações, consulte Listas de conclusão no C#. 
 
Informações rápidas 
Quando você passa o cursor sobre um tipo .NET Framework, o IntelliSense exibirá um 
Quick Info ToolTip que contém a documentação sobre esse tipo básico. Para mais 
informações, consulte Informações rápidas. 
Membros da lista 
Quando você inserir um tipo .NET Framework no Editor de Códigos, e então digitar o 
operador ponto ( . ), o IntelliSense exibe uma caixa de listagem que contém os membros 
do mesmo tipo. Quando você fizer uma seleção e pressionar TAB, o IntelliSense insere o 
nome membro. Para mais informações, consulte Membros da lista. 
Informações de parâmetro 
Quando você inserir um nome do método no Editor de códigos, e digitar um parênteses 
de abertura, o IntelliSense exibirá um parâmetro Info ToolTip que mostra a ordem e tipos 
de parâmetros do método. Se o método estiver sobrecarregado, você pode rolar para 
baixo através de todas as assinaturas sobrecarregadas. Para mais informações, consulte 
Informações de parâmetro. 
Visual C# Consolidado 38
 
Adicionando diretivas 'using' 
Às vezes, você pode tentar criar uma instância de uma classe .NET Framework sem um 
nome suficientemente qualificado. Quando isso acontece, o IntelliSense exibe uma marca 
inteligente após o identificador não resolvido. Quando você clicar a marca inteligente, o 
IntelliSense exibirá uma lista de diretivas using que permitirá que o identificador seja 
resolvido. Quando você seleciona um da lista, o IntelliSense adiciona a diretiva para a 
parte superior de seu arquivo de código fonte e você pode continuar a codificação em sua 
localidade atual. Para mais informações, consulte Adicionar diretivas 'using'. 
Refatoração 
Como uma base de código cresce e evolui durante o período de um projeto de 
desenvolvimento, às vezes é desejável fazer alterações para torná-lo mais legível para 
humanos ou mais portável. Por exemplo, convém dividir alguns métodos de backup em 
métodos menores ou alterar parâmetros do método, ou renomear identificadores. O 
recurso Refactoring, que é acessível clicando no Editor de códigos, faz tudo isso de uma 
maneira que é muito mais conveniente, inteligente, e completa que as ferramentas 
tradicionais como pesquisa e substituição. Para mais informações, consulte Refatoração. 
Trechos de código 
Trechos de código são unidades de uso comum em código fonte C# que você pode inserir 
rapidamente com precisão e com o pressionamentos de apenas algumas teclas. O menu 
trecho de código é acessado clicando no Editor de Códigos. Você pode navegar entre os 
muitos trechos fornecidos com o Visual C#, e você também pode criar seus próprios 
trechos. Para mais informações, consulte Trechos de código (C#). 
Sublinhado ondulado 
Sublinhado ondulado fornece comentários instantâneos sobre erros em seu código 
enquanto você digita. Um sublinhado ondulado vermelho identifica um erro de sintaxe 
como ponto-e-vírgula ausente ou chaves não correspondentes. Um sublinhado ondulado 
verde identifica um aviso de compilação em potencial, e azul identifica um problema Editar 
e Continuar. A ilustração a seguir mostra um sublinhado ondulado vermelho: 
 
Visual C# Consolidado 39
Ajuda de Legibilidade 
Estrutura de tópicos 
Automaticamente o Editor de Códigos trata namespaces, classes e métodos como 
regiões que você pode recolher para facilitar a localização e leitura de outras partes do 
arquivo de código fonte. Você também pode criar suas próprias regiões recolhíveis, 
envolvendo o código com as diretivas #region e #endregion 
 
Colorização 
O editor oferece diferentes cores a várias categorias de identificadores em um arquivo de 
código fonte C#. Para mais informações, consulte Colorização de Código . 
 
 
 
Visual C# Consolidado 40
NAVEGANDO E PROCURANDO 
 
O Visual C# fornece as seguintes ferramentas para ajudá-lo a navegar e pesquisar o 
código fonte, arquivos de projeto e janelas abertas. 
• Exibição de classe 
• Barras de navegação 
• Navegação CTRL+TAB 
• Localização em arquivos 
Exibição de classe 
A janela Class View fornece uma exibição do seu projeto com base nas classes em vez 
de usar arquivos, como no Solution Explorer. Você pode usar a Class View para 
navegar rapidamente para qualquer classe ou membro da classe em seu projeto. Para 
acessas a Class View, clique em Class View no menu View. 
 
Navegação CTRL+TAB 
A qualquer momento você pode ter várias janelas ativas em um projeto no Visual C#. 
Para navegar rapidamente para uma janela, pressione CTRL+TAB para exibir uma janela 
que lista todas as ferramentas ativas e janelas do código fonte. Mova as teclas de seta 
mantendo pressionada a tecla CTRL para selecionar a janela a exibir. 
Visual C# Consolidado 41
 
Barras de navegação 
Na parte superior de cada janela de código do editor está a barra de navegação, que 
consiste em duas caixas de listagem. A da esquerda lista todas as classes definidas no 
arquivo atual, e a da direita lista todos os membros para a classe que está selecionado na 
caixa da lista à esquerda. Você pode ir diretamente para um método selecionando-o na 
caixa de listagem da direita. 
 
Visual C# Consolidado 42
Localizar em arquivos 
Pressionando CTRL+SHIFT+F você pode abrir a caixa de diálogo Find in Files para 
executar pesquisa e substituir operações em um projeto inteiro. 
Observação 
Para renomear métodos ou tipos, ou alterar os parâmetros do método, use o recurso 
Refactoring, que é mais completo e inteligente do que pesquisar e substituir. Para mais 
informações, consulte Refactoração. 
 
 
Visual C# Consolidado 43
CRIANDO E DEPURANDO 
(VISUAL C#) 
No Visual C# você criar um aplicativo executável clicando em Build no menu Build (ou 
pressionando CTRL+SHIFT+B). Você pode criar e iniciar o aplicativo em uma operação 
pressionando F5 ou clicando em Run no menu Debug. 
O desenvolvimento implica a introdução dos seus arquivos de projeto no compilador C#, que 
converte seu código fonte no Microsoft Intermediate Language (MSIL) e depois associa o MSIL 
com os metadados, recursos, manifesto e outros módulos, se houver algum, para criar um 
assembly. Um assembly é um arquivo executável que normalmente tem uma extensão .exe ou.dll. 
À medida que você desenvolve seu aplicativo, você pode criar uma versão de depuração para 
testá-lo e ver como ele executa. Finalmente, quando tudo está correto, você criará um versão de 
lançamento para implantar aos clientes. 
Para obter mais informações sobre assemblies, consulte Visão Geral Sobre assemblies. 
Criar configurações 
Para especificar várias configurações de criação, clique com o botão direito do mouse no item de 
projeto no Solution Explorer e selecione o painel Build no Project Designer. Para obter 
mais informações, consulte Introdução ao Project Designer e Opções de Compilação C#. 
O Visual Studio usa a ferramenta MSBuild para criar assemblies. O MSBuild também pode ser 
executado a partir da linha de comando e pode ser personalizado de várias maneiras. Para mais 
informações, consulte MSBuild. 
Construir erros 
Se não há erros na sintaxe C#, ou identificadores que não podem ser resolvidos em um tipo 
conhecido ou membro, então a compilação não terá êxito e você verá uma lista de erros em que 
aparece, porpadrão, diretamente abaixo do editor de código. Você pode dar um clique duplo com 
o mouse na mensagem de erro para ir para a linha do seu código onde ocorreu o erro. 
 
Visual C# Consolidado 44
As mensagens de erro do compilador C# são geralmente muito claras e descritivas, mas se você 
não puder descobrir o problema, você pode ir para a página de Ajuda da mensagem, 
pressionando F1 com a mensagem de erro selecionada na lista de erro. A página de Ajuda 
contém informações adicionais úteis. Se você ainda não puder resolver o problema, então, a 
próxima etapa é fazer sua pergunta em um dos grupos de notícias ou fóruns do C#. Para acessar 
o fóruns, clique em Ask A Question no menu Community. 
Observação 
Se você encontrar uma página de ajuda de erro de compilação que não foi útil para o seu erro 
específico, você pode ajudar a Microsoft melhorar a documentação, enviando uma descrição do 
problema. Para enviar o email, clique no link na parte inferior da página de Ajuda que contém o 
erro. 
 
Configurações Versão vs. Depuração 
Enquanto você estiver trabalhando ativamente em seu projeto, você geralmente criará seu 
aplicativo usando a configuração de depuração, porque essa configuração permite que você exiba 
o valor de variáveis e controle a execução no depurador. Você também pode criar e testar 
compilações na versão de configuração para garantir que não introduziu quaisquer erros que 
somente só se manifestam em um tipo de compilação ou outro. Na programação do .NET 
Framework, esses erros são muito raros, mas eles pode acontecer. 
Quando você estiver pronto para distribuir seu aplicativo para usuários finais, crie uma versão de 
compilação, que será muito menor em tamanho e geralmente não terá melhor desempenho que a 
correspondente configuração de depuração. Você pode definir a configuração de compilação no 
painel Build do Project Designer, ou na barra de ferramentas Build. Para mais informações, 
consulte Compilar configurações. 
Depuração 
A qualquer momento que você estiver trabalhando no editor de código, você pode definir um 
ponto de interrupção (breakpoint) em uma linha de código, pressionando F9. Quando você 
pressionar F5 para executar seu aplicativo no depurador do Visual Studio, o aplicativo irá parar 
naquela linha e você poderá examinar o valor de qualquer variável, ou observar como ou quando 
a execução se liberta de um loop, passar pelo código linha a linha pressionando F10, ou 
configurar pontos de parada adicionais. 
 
Você também pode definir pontos de interrupção condicionais (tracepoints), que só irão parar a 
execução se uma condição especificada for satisfeita. Tracepoints são semelhantes aos pontos de 
Visual C# Consolidado 45
interrupção exceto que eles não param a execução, mas simplesmente gravam o valor da variável 
especificada para a janela de saída. Para mais informações, consulte Pontos de interrupção e 
Tracepoints. 
Quando a execução é interrompida em um ponto de interrupção, você pode focalizar sobre 
qualquer variável no escopo para exibir informações sobre essa variável. A ilustração a seguir 
mostra uma dica de dados no depurador: 
 
Você pode depurar seu código uma linha por vez pressionando F10 após o depurador ser 
interrompido em um ponto de interrupção. Você pode até corrigir determinados tipos de erros em 
seu código, e continuar a depuração sem precisar parar e recompilar o aplicativo 
O depurador do Visual Studio é uma ferramenta poderosa e é válido levar um tempo para ler a 
documentação para compreender diferentes conceitos como Edit e Continue, Exibir Dados no 
Depurador, Depuração Just-In-Time e Visualizadores. 
Visual C# Consolidado 46
MODELAGEM E ANÁLISE DE 
CÓDIGO (VISUAL C#) 
Não é incomum para desenvolvedores de software trabalhar com código fonte cuja arquitetura 
básica é desconhecida, pois ele foi escrito por outra pessoa, ou porque ele foi escrito há tanto 
tempo que seus criadores originais não mais recordam como ele funciona. Outro cenário comum é 
a necessidade de entender o conteúdo de uma biblioteca que só está disponível no formato 
binário. Visual C# fornece as seguintes ferramentas para ajudar você a modelar, analisar e 
compreender tipos e relacionamentos de tipos em código fonte como também em módulos 
binários (assemblies): 
• Classe Designer, para representar visualmente relacionamentos de herança e associação 
entre tipos. 
• Pesquisador de Objetos, para examinar os tipos, métodos e eventos exportados pelos 
assemblies do .NET Framework, e DLLs nativas incluindo os objetos COM. 
• Metadados como fonte, para exibir informações de tipo em módulos (assemblies) 
gerenciados como se fosse código fonte em seu próprio projeto. 
Além das ferramentas listadas acima, Visual Studio Team System inclui a ferramenta Análise de 
Código para Código Gerenciado que inspeciona seu código para uma variedade de problemas 
potenciais. 
Classe Designer 
A classe Designer é uma ferramenta gráfica para modelagem visual da relação entre tipos em um 
aplicativo de software ou componente; você também pode usá-la para criar novos tipos e refazer 
ou excluir tipos existentes. A ilustração a seguir mostra a criação de uma classe simples: 
 
Visual C# Consolidado 47
Para adicionar um diagrama de classe a um projeto, clique em Add New Item no menu 
Project , e em seguida, clique em Add Class Diagram. 
Para mais informações, consulte Projetando e exibindo classes e tipos. 
Pesquisador de Objetos 
O Pesquisador de Objetos permite que você veja informações de tipo em DLLs nativas e 
gerenciadas, incluindo objetos COM. Embora as informações que você vê no Pesquisador de 
Objetos sejam semelhantes as que você vê no Class View, você pode usar o Pesquisador de 
Objetos para examinar qualquer DLL em seu sistema, não apenas aquelas referenciadas no seu 
próprio projeto. Além disso, o Pesquisador de Objetos também exibe comentários da 
documentação XML para o tipo selecionado. A ilustração a seguir mostra como o Pesquisador de 
Objetos exibe informações de tipo em arquivos binários. 
 
Para mais informações, consulte Pesquisador de Objetos 
Os metadados como fonte: 
O recurso Metadata As Source (Metadados como fonte) permite que você veja informações de 
tipo das classes em módulos (assemblies) gerenciados como se eles fossem código fonte em seu 
próprio projeto. Essa é uma maneira conveniente para exibir as assinaturas para todos os 
métodos públicos em uma classe quando você não tem acesso ao código fonte real. 
Por exemplo, se você inserir a instrução System.Console.WriteLine() no editor de código, 
coloque o ponto de inserção no Console e clique com o botão direito do mouse e selecione Go 
To Definition, você verá algo parecido com um arquivo de código fonte que contém a 
declaração da classe Console. Essa declaração é construída a partir dos metadados no assembly 
usando Reflexão, e embora não exponha a implementação de todos os métodos, mostra 
comentários da documentação XML que estão presentes. 
Você também pode usar o recurso Metadata As Source, selecionando um tipo gerenciado no 
Pesquisador de Objetos, e clicando em Code Definition Window no menu View. 
Visual C# Consolidado 48
Para obter mais informações e uma ilustração, consulte Os metadados como fonte: 
Análise de código para código gerenciado 
A ferramenta de análise de código para código gerenciado analisa informações de assemblies 
gerenciados e relatórios assim como possíveis problemas de segurança, e violações de regras de 
programação e projeto definidas nas diretrizes de projeto do Microsoft .NET Framework. Essas 
informações são apresentadas como avisos. Você acessa a ferramenta no Designer de Projeto 
clicando com o botão direito do mouse em Properties no Solution Explorer, e selecionando 
Open. 
Visual C# Consolidado 49
ADICIONANDO E EDITANDO 
RECURSOS (VISUAL C#) 
Aplicativos do Visual C# geralmente incluem dados que não estão no código fonte. Esses dados 
são conhecidos como um project resource (recurso de projeto) e ele podeincluir dados binários, 
arquivos de texto, arquivos de áudio ou vídeo, tabelas de seqüência de caracteres, ícones, 
imagens, arquivos XML ou qualquer outro tipo de dados que seu aplicativo requer. Dados de 
recurso de projetos são armazenados em formato XML no arquivo resx. (chamado Resources.resx 
por padrão) que pode ser aberta no Solution Explorer. Para obter mais informações sobre os 
recursos de projeto, consulte Trabalhando com Arquivos de Recursos. 
Adicionando Recursos a Projetos 
Você pode adicionar recursos a um projeto clicando em Add Existing Item no menu Project, 
ou clicando no botão Add Resource na página Resources no Project Designer. 
Você pode adicionar recursos ao seu projeto como recursos vinculados, que são arquivos 
externos, ou como recursos incorporados, que são incorporados diretamente ao arquivo .resx. 
• Quando você adiciona um recurso vinculado, o arquivo resx. que armazena suas 
informações de recurso de projeto inclui apenas um caminho relativo para o arquivo de recurso 
no disco. Se você adicionar imagens, vídeos ou outros arquivos complexos como recursos 
vinculados, você pode editá-los usando um editor padrão no qual você associa a esse tipo de 
arquivo no Resource Designer. 
• Quando você adiciona um recurso incorporado, os dados são armazenados diretamente 
no arquivo de recurso (.resx) do projeto. Somente seqüências de caracteres podem ser 
armazenadas como recursos incorporados. 
Editando Recursos 
O Resource Designer permite que você adicione e modifique recursos de projeto durante o 
desenvolvimento ao associar um aplicativo padrão para editar cada recurso. Você acessa o 
Resource Designer clicando com o botão direito do mouse em Properties no Solution 
Explorer, clicando em Open e clicando na guia Resources em Project Designer. Para mais 
informações, consulte Páginas de Recursos, Project Designer. A ilustração a seguir mostra as 
opções de menu Resource Designer: 
 
Para editar recursos incorporados, você deve trabalhar diretamente no arquivo .resx para 
manipular os caracteres individuais ou bytes. Isto é porque ele é mais conveniente para 
armazenar tipos de arquivos complexos como recursos vinculados durante o desenvolvimento. 
Você pode usar o Binary Editor para editar arquivos de recursos, incluindo o arquivo .resx, no 
nível binário em formato hexadecimal ou ASCII. Você pode usar a Image Editor para editar ícones 
e cursores assim como arquivos JPEG e GIF, que são armazenados como recursos vinculados. 
Você também pode escolher outros aplicativos como editores para esses tipos de arquivo. Para 
mais informações, consulte Exibindo e Editando Recursos no Resource Editor. 
Visual C# Consolidado 50
Compilando Recursos em Assemblies 
Quando você cria seu aplicativo, o Visual Studio chama a ferramenta resgen.exe para converter 
os recursos do aplicativo em uma classe interna chamada Resources. Essa classe está contida 
no arquivo Resources.Designer.cs que está aninhado no arquivo Resources.resx no Solution 
Explorer. A classe Resources encapsula todos os recursos do projeto em propriedades get, 
somente-leitura estáticas, como uma forma de fornecer recursos fortemente tipados em tempo de 
execução. Quando você constrói através do Visual C# IDE, todos os dados de recurso 
encapsulados, incluindo os dois recursos que foram incorporados ao arquivo .resx e os arquivos 
vinculados, são compilados diretamente para o aplicativo assembly (o arquivo .exe ou .dll). Em 
outras palavras, o Visual C# IDE sempre usa a opção /resource de compilador. Se você constrói a 
partir da linha de comando, você pode especificar a opção de compilador /linkresource que 
permitirá implantar recursos em um arquivo separado do aplicativo assembly principal. Este é um 
cenário avançado e só é necessário em certas situações raras. Uma situação mais comum para 
implantação de recursos separadamente do aplicativo assembly principal é usar assemblies 
satélites conforme discutido abaixo. 
Acessando Recursos em Tempo de Execução 
Para acessar um recurso em tempo de execução, simplesmente referencie-o como você faria para 
qualquer outro membro da classe. O Exemplo a seguir mostra como recuperar um recurso bitmap 
que você nomeou para Image01. 
System.Drawing.Bitmap bitmap1 = Resources.Image01; 
Internamente a propriedade get utiliza a classe ResourceManager para criar uma nova instância 
do objeto. 
Para obter mais informações, consulte Recursos em Aplicativos e Gerador de Arquivos de 
Recurso (Resgen.exe). 
Recursos em Assemblies Satélites 
Se você estiver criando aplicativos que serão localizados (traduzidos) em vários idiomas, você 
pode armazenar cada conjunto de seqüência de caracteres específicos de cada cultura como um 
recurso em seu próprio assembly satélite. Quando você distribuir seu aplicativo, você incluirá o 
aplicativo assembly principal junto com qualquer montagem satélite adequada. Você pode 
adicionar assemblies satélite ou modificar arquivos existentes sem recompilar o aplicativo 
assembly principal. Para obter mais informações, consulte Criando Assemblies Satélites e 
Localizando e Usando Recursos para uma Cultura Específica. 
Visual C# Consolidado 51
OBTENDO AJUDA (VISUAL C#) 
A documentação da ajuda do Visual Studio está contida na Biblioteca MSDN, que você pode 
instalar localmente em seu próprio computador ou rede, e que também está disponível na Internet 
em http://msdn.microsoft.com/Library. A versão local da biblioteca consiste em uma coleção de 
compactada arquivos HTML com o formato.hxs. Você pode optar por instalar a biblioteca em sua 
máquina total ou parcialmente; a instalação completa do MSDN fica próxima de 2 GB em tamanho 
e inclui documentação para muitas tecnologias Microsoft. Você pode exibir a documentação 
MSDN local eonline usando o navegador do Visual Studio Help chamado Microsoft Document 
Explorer. 
Existem seis maneiras para acessar a ajuda enquanto trabalha no Visual C#: 
• Pesquisar F1 
• Pesquisa 
• Índice 
• Índice Analítico 
• Como Eu 
• Ajuda Dinâmica 
Ajuda Online versus Local 
Na página de propriedades Help Options no menu Options, você pode especificar as 
seguintes opções para o comportamento da pesquisa, inclusive a pesquisa F1: 
• Tente a Biblioteca MSDN on-line primeiro, depois a documentação local se nenhuma 
coincidência for encontrada. 
• Tente a Biblioteca MSDN local primeiro, depois a documentação on-line se nenhuma 
coincidência for encontrada. 
• Tente somente a Biblioteca MSDN local. 
Essas opções também serão exibidas na primeira vez você chamar qualquer pesquisa. A 
documentação MSDN on-line pode conter atualizações mais recentes que a documentação local. 
Portanto, se você tiver uma conexão Internet enquanto trabalha no Visual C#, é recomendável 
que você escolha a opção de pesquisa para testar a Biblioteca MSDN on-line primeiro. De tempos 
em tempos, atualizações para a documentação local podem ser disponibilizadas para download. 
Para obter mais informações sobre atualizações documentação, verifique o Visual Studio 
Developer Center. 
Pesquisa F1 
F1 fornece recursos de pesquisa contextual. No editor de código, você pode acessar a 
documentação da Ajuda para palavras-chave C# e classes do Framework .NET posicionando o 
cursor de inserção sobre ou imediatamente após a palavra-chave ou membro da classe e 
pressionando F1. Quando uma caixa de diálogo ou qualquer outra janela tiver o foco, você pode 
pressione F1 para obter ajuda sobre essa janela. 
Uma pesquisa F1 retorna não mais de uma página. Se nenhuma correspondência for encontrada, 
será exibida uma página informativa que fornece algumas dicas de solução de problemas. 
Pesquisa 
Use a interface de pesquisa para retornar todos os documentos que correspondam a qualquer 
termo especificado ou conjunto de termos. 
A interface de pesquisa tem esta aparência: 
Visual C# Consolidado 52
 
Você também pode usar a página Help Options no menu Options para especificar se você 
deseja para procurar sites Codezone além da BibliotecaMSDN. Sites Codezone são mantidos por 
parceiros da Microsoft e fornecem informações úteis sobre o C# e o .NET Framework. Somente 
conteúdo Codezone estará disponível on-line. 
As mesmas opções de busca online versus pesquisa local se aplicam às pesquisas F1 e comum. 
Na interface de pesquisa você pode restringir ou expandir sua pesquisa especificando quais tipos 
de documentos incluir. Existem três opções, Linguagem, Tecnologia, e Tipo de Tópico. Você 
geralmente obterá os melhores resultados marcando somente as opções que se aplicam a seu 
cenário desenvolvimento atual. 
Índice 
O índice fornece uma maneira rápida para localizar documentos na sua Biblioteca MSDN local. 
Não se trata de uma pesquisa do texto completo; ele procura somente as palavras-chave índice 
que tiverem sido atribuídas a cada documento. Uma pesquisa por índice é geralmente mais rápida 
e mais relevante que uma pesquisa de texto completo. Se mais de um documento contiver a 
palavra-chave que você especificar na a caixa de pesquisa de índice, depois uma janela de 
resolução de ambigüidade abre e permite que você selecione dentre as opções possíveis. 
A janela índice estará localizada, como padrão, no lado esquerdo do Document Explorer. Você 
pode acessá-la a partir do menu Help do Visual C#. 
Índice Analítico 
O índice analítico da Biblioteca MSDN mostra todos os tópicos na biblioteca numa estrutura 
hierárquica num modo de exibição de árvore. Ele é uma ferramenta útil para navegar através da 
documentação para ter uma idéia do que está contido na biblioteca, e para explorar documentos 
que você talvez não localize através do índice ou da pesquisa. Freqüentemente, quando você 
encontrar um documento pelo F1, índice ou pesquisa, é útil saber onde ele está localizado no 
índice analítico para que você possa ver qual outra documentação relacionada existe para um 
determinado tópico. Clique no botão Sync with Table of Contents na barra de ferramentas 
Document Explorer para ver onde a página atualmente exibida está localizada na Biblioteca 
MSDN. 
Como Fazer 
Visual C# Consolidado 53
Como Fazer é uma exibição filtrada da Biblioteca MSDN que principalmente inclui documentos 
chamados Como ou Explicação Passo-a-passo que mostram como realizar uma tarefa específica. 
Você pode acessar a ajuda Como Fazer na barra de ferramentas Document Explorer ou no 
menu Help, ou na página inicial. Cada linguagem no Visual Studio tem sua própria página Como 
Fazer, e a página que você vê dependerá do tipo de projeto que está atualmente ativo. 
Ajuda Dinâmica 
A janela de ajuda dinâmica exibe links para a documentação de referência do Framework .NET e 
a linguagem C# baseada na posição atual do ponto de inserção no editor de código. Para mais 
informações, consulte COMO: Personalizar a Ajuda Dinâmica. 
Visual C# Consolidado 54
IMPLANTANDO APLICATIVOS C# 
Implantação é o processo pelo qual você distribui um aplicativo concluído ou componente para ser 
instalado em outros computadores. Para aplicativos de console, ou aplicativos Smart Client com 
base em Windows Forms, duas opções de implantação estão disponíveis: ClickOnce e o Windows 
Installer. 
Implantação ClickOnce 
Implantação ClickOnce permite a você publicar aplicativos do Windows para um servidor Web ou 
para uma rede de compartilhamento de arquivos para instalação simplificada. Para a maioria dos 
cenários, ClickOnce é a opção recomendada para implantação porque permite a auto atualização 
de aplicativos baseados no Windows que podem ser instalados e executados com a mínima 
interação do usuário. 
Para configurar propriedades de implantação ClickOnce, você pode usar o Assistente de 
publicação (acessível no menu Build) ou a página Publicar no Designer de Projeto. Para 
mais informações, consulte Página Publicar, Designer de Projeto. Para mais informações sobre o 
ClickOnce, veja Implantação ClickOnce. 
O Windows Installer 
Implantação do Windows Installer permite a você criar pacotes de instalação a serem distribuídos 
aos usuários; o usuário executa o arquivo de instalação e segue passos com um assistente para 
instalar o aplicativo. Isso é feito, adicionando um projeto de instalação à sua solução; quando 
criado, ele cria um arquivo de instalação que você distribui para os usuários; o usuário executa o 
arquivo de instalação e etapas com um assistente para instalar o aplicativo. 
Para obter mais informações sobre o Windows Installer, consulte Implantação do Windows 
Installer. 
Recursos do Code Editor do Visual C# 
Fornece ferramentas que ajudam a editar e navegar pelo seu código Visual C#. 
Refatoração 
Refatoração é o processo de melhorar seu código depois ele foi gravado, alterando a estrutura 
interna do código sem alterar o comportamento do código externo. 
Visual C# fornece os seguintes comandos refactoring sobre o menu Refactoring: 
• Extrair o método 
• Renomear 
• Encapsular o campo 
• Extrair a interface 
• Promover variável local para parâmetro 
• Remover parâmetros 
• Reordenar parâmetros 
Multi-Project Refactoring 
O Visual Studio oferece suporte multi-Project refatoração. Todas as operações que Corrigir 
referências em arquivos refactoring corrigir essas referências em todos os projetos de mesmo 
idioma. Isso funciona para quaisquer referências projeto projeto-para-. Por exemplo, se você tiver 
um aplicativo de console que referencia uma biblioteca de classes, quando você renomeia um tipo 
Visual C# Consolidado 55
de biblioteca (usando a Rename operação refactoring), classe as referências para o tipo de 
biblioteca de classe no aplicativo do console também serão atualizadas. 
Caixa de diálogo Alterações de visualização 
Muitas operações refactoring fornecem uma oportunidade para você a revisar todas as alterações 
de referência que uma operação refactoring deve executar no seu código, antes de confirmar a 
essas alterações. Uma preview reference changes opção para estas operações 
refactoring, será exibido na caixa de diálogo refactoring. Após selecionar essa opção e aceitar a 
operação refactoring, o Caixa de diálogo Alterações de visualização será exibido. Observe que a 
Preview Changes caixa de diálogo tem duas exibições. A exibição inferior exibirá seu código 
com todas as atualizações de referência devido à operação refactoring. Na caixa Preview 
Changes de diálogo pressionando Cancel irá parar a operação refactoring, e nenhuma 
alteração será feita para o seu código. 
Tolerant erros Refactoring 
Refatoração é erro falhas. Em outras palavras, você pode executar um refatoração em um projeto 
que não é possível criar. O processo refactoring não Entretanto, nesses casos pode atualizar 
referências ambíguas corretamente. 
Trechos de códigos (C#) 
O Visual Studio fornece um novo recurso chamado trechos . de código Você pode usar trechos de 
código para digitar um alias curta, e então expandi-lo em uma construção de programação 
comuns. Por exemplo, o for trecho de código cria um loop vazia for. Alguns trechos de código 
são surround-com trechos de código, que permitem que você se selecionar linhas de código, 
escolha um trecho de código que irá incorporar as linhas de código selecionadas. Por exemplo, 
selecionar linhas de código depois ativar o for trecho de código cria um for loop com essas 
linhas de código dentro do bloco loop. Trechos de código podem tornar programa escrever código 
mais rápido, mais fácil, e mais confiável. 
Usando trechos de código 
Trechos de Código normalmente são usados no Editor do código pelo digitando um nome curto 
para o alias — um atalho — trecho de código e pressionar TAB. O menu IntelliSense também 
oferece um Insert Code Snippet Comando de menu, fornecendo uma lista de trechos de 
código disponível para ser inserida no Editor de Código. Você pode ativar a lista trecho de código, 
digitando Ctrl+K, depois X. Para obter mais informações, consulte COMO: Usar trechos de código 
(C#) e COMO: Usar trechos de código circunscritos. 
Após um trecho de código tenha sido escolhido, o texto do trechode código é inserido 
automaticamente na posição do cursor. Nesse ponto, os campos editáveis no trecho de código 
são realçados em amarelo, e o primeiro campo editável é selecionado automaticamente. O campo 
selecionado no momento é Boxed em vermelho. No for trecho de código, por exemplo, os 
campos editáveis estão a variável inicializador (i por padrão (length). e a expressão comprimento) 
por padrão 
Quando um campo é selecionado, os usuários podem digitar um novo valor para o campo. 
Pressionar TAB percorre os campos do trecho de código editáveis; pressionando SHIFT + TAB 
ciclos através de em ordem inversa. Clicar em um campo coloca o cursor no campo, e duas vezes 
em um campo selecioná-lo. Quando um campo estiver realçado, uma dica de ferramenta pode ser 
exibida, oferecendo uma descrição do campo. 
Somente a primeira instância de um determinado campo é editável; quando esse campo estiver 
realçado, as outras instâncias do campo são descritas. Quando você alterar o valor de um campo 
editável, esse campo é alterado em todos os lugares ele é usado no trecho de código. 
Pressionar ENTER ou ESC será cancelar a edição de campo e retorne o editor de código para 
Normal. 
Visual C# Consolidado 56
As cores padrão para campos trecho, códigos editáveis podem ser alteradas, modificando a 
Code Snippet Field configuração no painel Fonts and Colors da caixa Options de 
diálogo. Para obter mais informações, consulte Como alterar face da fonte, tamanho, e cores 
usadas no Editor:. 
Criar trechos de código 
Você pode criar e utilizar trechos de código personalizado, juntamente com os trechos de código 
que estão incluídos com o Visual Studio por padrão. Para obter mais informações sobre como 
criar trechos de código personalizado, consulte Criar trechos de código. 
Observação 
Para trechos de código C#, os caracteres que são válidos para especificar o < atalho > campo 
são: caracteres alfanuméricos, sinal numérico (#), o caractere til (~), o caractere de sublinhado (_), 
e o hífen traço caractere (-). 
Para obter mais informações sobre trechos de código que estão incluídos na Visual C# por 
padrão, consulte Trechos de código padrão. 
Código Colorization 
Editor de Código analisa tokens e código constrói para que sejam facilmente reconhecível e 
distinguishable de outros conteúdos de código no Editor de Código. Após o Editor de Código 
analisa seu código, ele colorizes construções de código adequadamente. 
Símbolos 
Editor de Código colorizes o seguinte token tipos. 
Comment 
Código excluído 
Identificador 
Keyword 
Número 
Operador 
Palavra-chave pré-processamento 
String 
Seqüência (C# @ Verbatim) 
Tipos de usuário 
Usuário tipos (tipos valor) 
Tipos de usuário (interface) 
Usuário tipos (enums) 
Usuário tipos (representantes) 
Seção CDATA XML 
Comentário XML 
Atributo doc XML 
Comentário XML doc 
Visual C# Consolidado 57
Marca doc XML 
Você pode modificar colorization padrão da configuração usando o Fontes e cores, Ambiente, 
caixa de diálogo Opções. 
Palavras-chave contextuais 
Editor de Código colorizes palavras-chave contextuais adequadamente. O Exemplo a seguir, o 
tipo yield está colorized turquesa, enquanto a palavra yield está azul colorized. 
 
Brace Colorization correspondência 
Editor de Código facilita colorization negrito ou colorization de realce para Brace correspondência. 
Negrito Colorization 
Quando você editar qualquer uma dos pares construção de código a seguir a seqüência, ou pares 
construção de código rapidamente são exibidos em negrito para indicar uma associação entre 
elas: 
" " Uma seqüência 
@" " Uma seqüência verbatim 
#if, #endif Pré-processamento diretivas para seções condicionais 
#region, #endregion Pré-processamento diretivas para seções condicionais 
case, break Palavras-chave instrução controle 
default, break Palavras-chave instrução controle 
for, break Palavras-chave expressão avaliação 
for, continue Palavras-chave expressão avaliação 
foreach, break Palavras-chave expressão avaliação 
foreach, continue Palavras-chave expressão avaliação 
while, break Palavras-chave expressão avaliação 
while, continue Palavras-chave expressão avaliação 
Visual C# Consolidado 58
Você pode desativar este recurso por unselecting a Automatic delimiter highlighting 
propriedade no Geral, editor de texto, caixa de diálogo Opções. 
Realçar Colorization 
Quando o cursor está posicionado imediatamente antes um delimitador inicial, ou imediatamente 
após um delimitador de término, retângulos cinza aparecem para realçar tanto inicial e final 
delimitadores para indicar uma associação entre eles. Esse recurso está disponível para os 
seguintes pares correspondentes: 
{ } Chaves 
[ ] Colchetes 
( ) Parêntese 
Exemplo 
Para ilustrar Brace correspondência colorization, digite fazer (Não copie e cole) o código a seguir 
no Editor de Código. 
class A { public A() { if(true) int x =0; else int x =1; } } 
Configurações colorization 
Configurações colorization são persistentes através de Configurações do Visual Studio. 
Metadados como fonte 
Metadados como fonte permite-lhe Exibir metadados que aparece como C# código-fonte em um 
buffer somente leitura. Isso permite que um modo de exibição das declarações dos tipos e 
membros (com nenhum implementações). Você pode exibir metadados como origem ao executar 
o Go To Definition Comando para tipos ou membros cujo código de fonte não está disponível 
do seu projeto ou solução. 
Observação 
Quando você tenta executar o Go To Definition Comando para tipos ou membros marcados 
como internos, o IDE (ambiente de desenvolvimento integrado) não exibe seus metadados como 
fonte, independentemente do se o conjunto de referência é um amigo ou não. 
Você pode exibir metadados como fonte no Editor de Código ou a Code Definition janela. 
Exibindo metadados como no Editor do código fonte 
Quando você executa o Go To Definition comando para um item cujo código de fonte não 
estiver disponível, um documento que contém uma exibição de metadados, esse item é exibido 
como fonte, com guias é exibida no editor do código. O nome do tipo, seguido por [from 
metadata], aparecerá na guia do documento. 
Por exemplo, se você executar o Go To Definition comando para Console metadados de 
Console aparece no Editor do código como código fonte C# que pareça como sua declaração, 
mas com nenhum implementação. 
Visual C# Consolidado 59
 
Exibindo metadados como fonte no Code Definition Window 
Quando a Code Definition janela estiver ativa ou visível, o IDE executa automaticamente o Go 
To Definition Comando para itens sob o cursor no Editor do código e para itens que estão 
selecionados no Class View ou o Object Browser. Se o código fonte não está disponível 
para esse item, o IDE exibirá metadados do item como origem na janela Code Definition. 
Por exemplo, se você colocar o cursor dentro a palavra Console no Editor do código, metadados 
para Console aparecerá como fonte na janela Code Definition. A fonte procura algo como a 
Console declaração, mas com nenhum implementação. 
Se você deseja ver a Declaração de um item que aparece na janela Code Definition, você 
deve usar o Go To Definition comando porque a Code Definition janela é apenas um nível 
de profundidade explicitamente 
Configurações do IDE Visual C# 
Visual configurações C# são uma configuração de janelas de ferramentas, menus e atalhos de 
teclado predefinida. Essas configurações são parte do recurso Configurações do Visual Studio, 
que você pode personalizar para ajustar seus hábitos de trabalho. 
Windows e modos de exibição 
Recurso Exibido por padrão? Observações 
Class View Não • Exibir de classe está disponível no menu 
View. 
• Filtragem está ativada. 
Janela de 
Comando 
Não 
Dynamic Help 
Window 
Não Pressionar a tecla F1 não exibe a janela da Ajuda 
dinâmica. 
Para obter mais informações sobre a janela Ajuda 
Visual C# Consolidado 60
dinâmico, consulte Como: Personalizar Ajuda dinâmica 
ou Como controlar a janelada Ajuda dinâmico:. 
Pesquisador de 
objetos 
Não • Não é exibida membros herdados por padrão. 
Janela Output Não 
Solution Explorer Sim Explorer de solução aparece encaixado no lado direito 
de IDE. 
Start Page Sim, quando você 
inicia o IDE 
A página inicial Exibe artigos na alimentação RSS 
MSDN no Visual C#. 
Lista de tarefas 
(Visual Studio) 
Não 
Toolbox Sim, quando você 
cria um aplicativo do 
Windows Forms 
A caixa de ferramentas aparece como uma janela que 
é encaixada no lado esquerdo de IDE recolhida. 
Teclado 
Recurso Comportamento 
Teclas de atalho Essas configurações de chave de atalho oferece suporte Visual C#: 
• Emulação breve 
• Emulação Emacs 
• Visual C++ 2,0 padrão teclas de atalho 
• Teclas de atalho padrão Studio 6.0 Visual 
Atalhos de Teclado Visual C# 
Visual C# fornece um número de atalhos de teclado que você pode usar para executar ações sem 
usar o mouse ou menus. 
Teclas de atalho 
O IDE (ambiente de desenvolvimento integrado) fornece vários esquemas de ligação do teclado 
predefinidos. Você pode criar seu próprio teclado personalizado esquemas de mapeamento do 
painel de ambiente opções na caixa de diálogo Opções teclado. Você pode acessar a caixa de 
diálogo Opções no menu Ferramentas. 
Os esquemas de ligação do teclado disponíveis incluem o seguinte: 
• 2003 Studio visual teclas de atalho padrão 
• 6,0 Studio visual teclas de atalho padrão 
• Breve teclas de atalho padrão 
• Teclas de atalho padrão Emacs 
• Teclas de Atalho Padrão do Visual Basic 6.0 
• Visual C++ 6.0 padrão teclas de atalho 
• Visual C++ 2,0 padrão teclas de atalho 
As combinações de teclas de atalho a seguir funcionam no IDE. Muitos são padrão combinações 
teclas usadas na maioria dos aplicativos Windows; a tabela lista a função específica que tem o 
pressionamento de teclas no IDE. 
Name (Nome) Teclas de Descrição 
Visual C# Consolidado 61
atalho 
Ativar menu 
aplicativo 
ALT + 
espaços 
Abre o menu Programa, permitindo ao usuário para gerenciar 
o estado da janela do aplicativo, por exemplo, mover ou 
redimensionar. 
Ativar menu 
Janela 
Documento 
ALT + HÍFEN Abre o menu de documento, permitindo ao usuário para 
gerenciar o estado da janela do documento ativo, por 
exemplo, mover ou redimensionar. Disponível somente 
enquanto no modo MDI de dentro uma janela de documento. 
Ativar ferramenta 
menu Janela 
ALT + HÍFEN Abre o menu Janela ferramenta, permitindo ao usuário para 
mover a janela ferramenta no IDE. Disponível somente ao 
dentro de uma janela ferramenta. 
Aplicativo de 
fechamento 
ALT + F4 Fecha o IDE. 
Fechar 
documento 
CTRL+F6 Fecha o documento aplicativo ativo. 
Recolher Todos 
os nós de árvore 
Num +- Recolhe todos os nós no modo de exibição de árvore atual. 
Expandir todos os 
nós de árvore 
Num + * Expande todos os nós no modo de exibição de árvore atual. 
Mover para Barra 
de menus 
ALT Ativa a barra de menus IDE principal. 
Mova para 
ferramentas 
próxima 
CTRL + TAB Move para a próxima barra de ferramentas visível. Disponível 
somente enquanto a barra de menus principal estiver ativa. 
Mover para Barra 
de ferramentas 
anterior 
CTRL + 
SHIFT + TAB 
Move para a barra de ferramentas visível anterior. Disponível 
somente enquanto a barra de menus principal estiver ativa. 
Mova para 
ferramentas 
Janela ferramenta 
SHIFT + ALT Ativa a barra de ferramentas Janela ferramenta. Disponível 
somente em uma janela ferramenta contendo uma barra de 
ferramentas. 
Mover o foco de 
árvore abaixo 
CTRL + 
DOWN. 
Move o foco em modo de exibição de árvore para baixo sem 
alterar a seleção. Este atalho pode ser utilizado para 
selecionar vários itens na árvore. 
Move o foco de 
árvore cima 
CTRL + UP Move o foco em modo de exibição de árvore backup sem 
alterar a seleção. Este atalho pode ser utilizado para 
selecionar vários itens na árvore. 
Menu de atalho SHIFT + F10 Exibe o menu de atalho. 
Alternar 
visibilidade lista 
drop-down 
F4 Oculta e mostra uma lista drop-down. Disponível somente de 
uma lista drop-down. 
Alternar seleção 
foco de árvore 
CTRL + 
SPACEBAR 
Alterna uma seleção para o foco atual em modo de exibição 
de árvore. 
Visual C# Consolidado 62
Teclas de atalho padrão configurações Development gerais 
Os tópicos a seguir listam as combinações de teclas padrão disponíveis para o esquema de 
mapeamento do teclado Visual Studio 2003. 
• Lista Global teclas de atalho, definições gerais de desenvolvimento comuns 
combinações de teclas de atalho, bem como combinações de teclas que podem ser usadas em 
uma variedade de locais dentro do IDE. 
• Lista Designer de HTML teclas de atalho, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao trabalhar no modo Design e modo de exibição 
de HTML do Designer de HTML. 
• Lista XML teclas de atalho do criador, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao trabalhar em exibição Esquema de designer 
XML. 
• Lista Teclas de aceleração para o Editor de diálogo as combinações de teclas de atalho 
disponíveis ao trabalhar no Editor de diálogo. 
• Lista Teclas de aceleração para o editor de imagem as combinações de teclas de atalho 
disponíveis ao trabalhar no editor de imagem. 
• Lista Depuração teclas de atalho, definições gerais de desenvolvimento as combinações 
de teclas de atalho disponíveis ao usar o depurador. 
• Lista Pesquisar e substituir teclas de atalho, definições gerais de desenvolvimento o 
atalho chave combinações disponíveis ao usar a localizar Localizar, substituir, em arquivos, e 
substituir nas caixas de diálogo Arquivos. 
• Lista Dados teclas de atalho, definições gerais de desenvolvimento as combinações de 
teclas de atalho disponíveis ao usar o Query Designer ou designer de banco de dados. 
• Lista Controlar manipulação teclas de atalho, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis para mover e redimensionar controles em uma 
superfície de design. 
• Lista Texto teclas de atalho de navegação, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao mover dentro de código em um documento 
aberto. 
• Lista Texto teclas de atalho de seleção, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao selecionar texto em um documento aberto. 
• Lista Texto teclas de atalho de manipulação, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis quando movendo, excluindo ou formatar texto em 
um documento aberto. 
• Lista Janela teclas de atalho de gerenciamento, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis para mover, Fechar, ou navegar em janelas 
ferramenta e documentos. 
• Lista Integrada teclas de atalho da Ajuda, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao exibir e procurar tópicos da Ajuda. 
• Lista Objeto teclas de atalho do navegador, definições gerais de desenvolvimento as 
combinações de teclas de atalho disponíveis ao trabalhar no Pesquisador de objetos. 
• Lista Macro teclas de atalho, definições gerais de desenvolvimento as combinações de 
teclas de atalho disponíveis para trabalhar com macros. 
• Lista Ferramenta janela teclas de atalho, definições gerais de desenvolvimento as 
combinações de teclas de atalho que exibem as janelas ferramenta vários. 
• Lista Projeto teclas de atalho, definições gerais de desenvolvimento as combinações de 
teclas de atalho que podem ser usadas para adicionar novos itens a um projeto, criar um 
projeto, ou abrir arquivos ou Projetos. 
Visual C# Consolidado 63
• Lista Acelerador e teclas de atalho Editor de seqüência, definições gerais de 
desenvolvimento as combinações de teclas de atalho disponíveis ao trabalhar em 
componente editor, editor STRING, e Accelerator editor. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Visual C#Consolidado 64
ESCREVENDO APLICATIVOS COM 
O VISUAL C# 
C# é uma linguagem Type-Safe, orientada a objetos que é simples mas sofisticada, permitindo 
que os programadores para criem um abrangência dos aplicativos. Combinado com o Framework 
.NET, o Visual C# permite a criação de aplicativos Windows, Web Services, ferramentas de banco 
de dados, componentes, controles e mais. 
Esta seção contém informações sobre várias tecnologias da plataforma Microsoft nas quais você 
pode basear aplicativos C#. 
 
Usando a Biblioteca de Classe do .NET Framework (Visual C#) 
A maioria dos projetos de desenvolvimento Visual C# usam amplamente a Biblioteca de Classe do 
.NET Framework para tudo desde acesso ao sistema de arquivos e manipulação de seqüência a 
controles de interface de usuário do Windows Forms e do ASP.NET. 
A biblioteca de classe é organizada em namespaces, cada um deles contém um conjunto de 
classes relacionadas e estruturas. Por exemplo, o namespace System.Drawing contém vários 
tipos que representam fontes, canetas, linhas, formas, cores, e assim por diante. 
Diretivas de uso e Referências 
Antes de você poder usar as classes de um dado namespace em um programa C#, você deve 
adicionar uma diretiva de uso para aquele namespace no seu arquivo de origem C#. Em alguns 
casos, você também deve adicionar uma referência para a DLL que contém o namespace; Visual 
C# adiciona automaticamente referências para as DLLs de biblioteca de classe mais comumente 
usadas. Você pode ver quais referências foram adicionadas em Solution Explorer sob o nó 
References. Para mais informações, consulte Criando um Projeto (Visual C#). 
Após ter adicionado a diretiva using para um namespace, você pode criar instâncias de seus 
tipos, chamar métodos, e responder a eventos no momento que eles forem declarados no seu 
próprio código fonte. No editor de código Visual C#, você também pode colocar o ponto de 
inserção sobre membro de nome ou tipo, e pressionar F1 para ver a documentação de Ajuda. 
Você também pode usar a ferramenta Pesquisador de Objetos e o recurso Metadata As 
Source para ver informações de tipo em classes e estruturas do .NET Framework. Para mais 
informações, consulte Modelagem e Analise de Código (Visual C#). 
Para mais informações 
• Para obter mais informações sobre a biblioteca de classe do .NET Framework, consulte 
Visão geral da estrutura da biblioteca de classe .NET e Programação no .NET Framework. 
• Para obter mais informações sobre a arquitetura .NET Framework, consulte Visão Geral do 
.NET Framework. 
• Na Internet, o .NET Framework Developer Center possui vários artigos e exemplos de 
código sobre a biblioteca de classe. 
• Para obter informações sobre como executar tarefas específicas usando as bibliotecas de 
classe, consulte Como fazer em C# ou clique em How Do I no menu Help do Visual C#. 
 
Visual C# Consolidado 65
Criando aplicativos do Windows Forms (Visual C#) 
Windows Forms é a tecnologia que você usa em Visual C# para criar aplicativos de cliente 
inteligente baseados no Windows que executa em .NET Framework. Quando você cria um projeto 
de aplicativos Windows, você está criando um aplicativo baseado no Windows Forms. Você usará 
o o Windows Forms Designer para criar a interface do usuário, e você terá acesso a outros 
recursos de design em tempo de execução, incluindo: 
• Implantação ClickOnce. 
• Suporte rico a banco de dados com o controle DataGridView . 
• Barras de ferramentas e outros elementos de interface do usuário que podem ter a 
aparência e o comportamento do Microsoft ® Windows ® XP, do Microsoft Office, ou do 
Microsoft Internet Explorer. 
Para obter mais informações, consulte Criando uma interface de usuário (Visual C#) e Windows 
Forms. 
Criando Aplicativos de Console (Visual C#) 
C# pode ser usado para criar aplicativos de linha de comando que possuam entrada e exibam a 
saída no console. Esses aplicativos são ideais para aprender o desenvolvimento C# porque a 
interface do usuário é muito simples. Aplicativos console são também muito úteis para programas 
utilitários que requeiram pouca ou nenhuma interação do usuário. 
Para criar um aplicativo do console em no Visual C#, clique em New no menu File e selecione 
Project. Clique em em um modelo de projeto de aplicativo de console C#, forneça os nomes de 
arquivos que você deseja, e clique em OK. 
Use a classe System.Console 
Use a classe Console para ler e escrever caracteres a partir do console, individualmente ou como 
uma linha inteira. A saída pode ser formatada de diferentes maneiras. Para mais informações, 
consulte Visão Geral Sobre Formatação. 
Argumentos da linha comando podem ser acessados usando a matriz de seqüência de caracteres 
opcional associada ao método Main. Para mais informações, consulte Argumentos da Linha 
Comando (Guia de Programação C#). 
Exemplos 
• Como criar um cliente de aplicativo de console: 
Exemplo de parâmetros da linha de comando 
 
Acessar e exibir dados (Visual C#) 
Em aplicativos Visual C#, você normalmente se conectará a bancos de dados usando a tecnologia 
ADO.NET conforme exposto no System.Data e namespaces relativos à biblioteca de classes do 
.NET Framework. Para obter mais informações sobre como trabalhar com dados, consulte 
Acessando dados (Visual Studio). 
Em aplicativos do Windows Forms, o controle principal de interface do usuário para exibir dados 
recuperados de bancos de dados é o DataGridView. Para mais informações, consulte 
DataGridView Control (Windows Forms). Conectar fontes de dados a controles de interface do 
usuário tais como caixas de texto e caixas de listagem é muito simples através de um recurso 
conhecido como vinculação de dados. Automaticamente, quando você vincula um controle a um 
campo em uma fonte de dados, as alterações feitas em um serão refletidas no outro. Para mais 
informações, consulte Vinculação de dados do Windows Forms. 
Visual C# Consolidado 66
Para obter mais informações sobre a criação e gerenciamento de bancos de dados, escrever 
procedimentos de armazenamento e outras informações relacionadas, consulte Projetos de 
Servidor SQL, Livros on-line sobre Servidor SQL e Tutoriais do Servidor SQL. 
Os seguintes links contêm informações sobre como usar Visual Studio para acessar dados: 
• Criando aplicativos de dados com Visual Studio 
• Ferramentas de Banco de DadosVisual 
Na Internet, o Data Access and Storage Developer Center está sempre atualizado com novos 
artigos e exemplos. 
 
Criando Aplicativos Móveis e Incorporados (Visual C#) 
O Microsoft Visual Studio 2005 oferece suporte rico e integrado para desenvolvimento de software 
compatível com dispositivos inteligentes baseados em Windows CE como Pocket PCs e 
Smartphones. Você pode usar o Visual C# para escrever aplicativos gerenciados que executam 
no .NET Compact Framework. Você irá usar a mesma interface de Editor de Códigos, designers e 
depurador que você usaria ao desenvolver para o PC. Simplesmente selecione de um dos 
modelos de projeto Smart Device disponíveis para o idioma de sua escolha, e comece a 
codificar. 
O Visual Studio também fornece emuladores para dispositivos inteligentes que permitem que você 
execute e depure seu código no seu computador de desenvolvimento, e ferramentas que 
simplificam o processo de compactação do seu aplicativo e seus recursos em arquivos CAB para 
implantação em dispositivos de usuário final. Para mais informações, consulte Dispositivos 
inteligentes. 
Você também pode usar o Visual Web Developer para desenvolver aplicativos Web móvel com 
base no ASP.NET Para mais informações, consulte Introdução aos Formulários Móveis da Web. 
Visual C# Consolidado 67
CRIANDO E ACESSANDO 
SERVIÇOS DA WEB (VISUAL C#) 
XML Web Services fornecem a aplicativos a possibilidade de se comunicarem em um ambiente 
fracamente acoplado usando troca mensagens predefinidas construídas em torno de protocolos 
padrão como HTTP, XML, XSD, SOAP e WSDL. Como os protocolos e as especificações são 
públicose não específicos de plataforma, XML Web Services podem ser usados para habilitar a 
comunicação entre aplicativos que residem no mesmo computador ou não, mesmo que eles 
estejam em plataformas ou dispositivos diferentes. 
Você não precisa entender detalhadamente cada especificação para criar ou consumir serviços da 
Web. As classes do .NET Framework e os assistentes do Visual Studio ajudam você a criar ou 
interagir com XML Web Services usando um modelo familiar de programação orientada a objetos. 
Para obter mais informações sobre XML Web Services, consulte Visão Geral sobre XML Web 
Services. 
Para obter informações sobre a criação e o acesso a XML Web Services usando ASP.NET, 
consulte XML Web Services Usando ASP.NET. 
Para obter informações sobre as ferramentas que o Visual Studio fornece para ajudar a criar e 
consumir facilmente XML Web Services, consulte XML Web Services (Visual Studio). 
Para obter mais informações sobre como criar e acessar XML Web Services, consulte XML Web 
Services em Código Gerenciado. 
O Web Services Developer Center na MSDN Online possui artigos e recursos adicionais. 
 
Visual C# Consolidado 68
CRIANDO COMPONENTES 
(VISUAL C#) 
O termo componente na indústria de software é freqüentemente usado para fazer referência a 
um objeto reutilizável que expõe uma ou mais interfaces para clientes de uma maneira 
padronizada. Um componente pode ser implementado como uma classe única, ou como um 
conjunto de classes; o requisito primário é que a interface pública básica seja bem definida. Por 
exemplo, em um contexto de programação nativa do Windows, o COM (Component Object Model) 
requer que todos os componentes implementem a interface IUnknown além das outras interfaces 
especializadas. 
No contexto do .NET Framework, um componente é uma classe ou conjunto de classes que 
implementa a interface IComponent ou deriva diretamente ou indiretamente de uma classe que 
implementa esta interface. A implementação da classe base padrão da interface IComponent é 
Component. 
Alguns dos componentes mais comumente usados em programação no .NET Framework são os 
controles visuais que você adiciona ao Windows Forms como o Controle de Botão (Windows 
Forms), Controle de Caixa de Combinação (Windows Forms) e assim por diante. Componentes 
não visuais incluem o Controle de Timer, SerialPort, e ServiceController entre outros. 
Quando você cria um componente em C#, ele pode ser usado por clientes escritos em qualquer 
outra linguagem que está em conformidade com a Common Language Specification. 
Para criar seus próprios componentes no Visual C#, você pode usar o Component Designer para 
montar classes de componentes não visuais da mesma maneira que você monta no Windows 
Forms. Para mais informações, consulte Explicação passo a passo: Criando um aplicativo de 
serviço Windows no Designer de Componente. 
Para obter mais informações sobre programação de componente usando o Visual Studio, consulte 
Componentes no Visual Studio. 
 
Desenvolvendo na Plataforma do Office (Visual C#) 
O Microsoft Visual Studio 2005 Tools para o Microsoft Office System permite a você personalizar 
documentos do Microsoft Office e o Microsoft Office Outlook usando código gerenciado. O Visual 
Studio Tools para o Office adiciona novas funcionalidades ao Visual Studio, tais como hospedar o 
Microsoft Office Word e o Microsoft Office Excel como designers no ambiente de desenvolvimento 
do Visual Studio, a habilidade de programar diretamente em objetos de dados e de apresentação 
e a habilidade de usar os controles do Windows Forms em documentos dentro do painel de 
tarefas Document Actions. 
Programação do Office (Como Fazer em C#) 
Esta página fornece referência a ajuda sobre tarefas amplamente executadas de programação do 
Office. Para exibir outras categorias de tarefas populares abordados na Ajuda Como Fazer em C#. 
Gerais 
COMO: Atualizar Soluções de Ferramentas do Visual Studio Tools para Office 
Explica o procedimento que você deve executar manualmente para concluir a atualização 
para o Microsoft Visual Studio 2005 Tools para Office. 
O Excel Usando Explicações Passo-a-passo 
Visual C# Consolidado 69
Demonstra três tipos básicos de tarefas: automatizar Microsoft Office Excel 2003, executar 
análises de dados, e trabalhar com controles. 
O Word Usando Explicações Passo-a-passo 
Demonstra maneiras de usar as ferramentas para o Microsoft Office 2003 para automatizar 
projetos do Microsoft Office Word 2003. 
COMO: Automatizar Aplicativos do Office que não Word, Excel, ou o Outlook 
Fornece as etapas a serem executadas em seus projetos existentes para que possa 
chamar código não gerenciado usando o Visual Basic ou C#. 
COMO: Adicionar Controles a Documentos do Office 
Explica como adicionar controles a documentos Office em tempo de design ou em tempo 
de execução. 
Aplicativos Word e Excel 
COMO: Executar Cálculos do Excel por Programação 
Explica como executar cálculos por programação para um intervalo ou para o aplicativo 
inteiro. 
COMO: Criar Menus do Office por Programação 
Fornece um Exemplo que cria um menu chamado New Menu na barra de menus no Microsoft 
Office Excel 2003. 
COMO: Criar Barras de Ferramentas do Office por Programação 
Fornece um Exemplo que cria uma barra de ferramentas denominada Teste no Microsoft Office 
Word 2003. Ele aparece próximo ao meio do documento e contém dois botões. Quando um botão 
é clicado, uma caixa de mensagem aparece. 
COMO: Manipular Erros em Projetos do Office 
Explica como configurar o depurador para paralisar em exceções do tempo de execução 
de linguagem comum. 
Como: Atualizar soluções das Ferramentas do Visual Studio 
para o Office 
Após a atualização para Microsoft Visual Studio 2005 Tools for the Microsoft Office System, você 
pode abrir e executar seus projetos existentes no Visual Studio e eles serão atualizados para 
funcionam da mesma forma que eles tinham ao usar Visual Studio Tools for Office, Versão 2003. 
No entanto, para concluir a atualização para que você pode tirar proveito do novo sistema do 
projeto e ferramentas, você deve executar algumas etapas atualização manualmente. Para obter 
mais informações, consulte Atualizando Overview soluções do Office. 
Para atualizar um Ferramentas do Visual Studio para solução Office 
1. Abra uma solução existente no Visual Studio com Visual Studio 2005 Tools for Office 
instalado. 
O Visual Studio Conversion Wizard aparece. 
2. Leia as informações e avisos na primeira tela, e clique em Next. 
3. Se você desejar criar um backup de sua solução, selecione Yes, create a backup 
before converting e especifique um local para os arquivos de backup. Se você não 
faça desejar criar um backup, selecione No. 
4. Clique em Next. 
5. Clique em Finish se tudo na página de resumo está correto. 
Visual C# Consolidado 70
Uma caixa de diálogo aparece com informações sobre propriedades padrão para 
depuração do projeto. 
6. Clique Yes para atualizar para o novo projeto depuração propriedades padrão. O projeto 
se você clicar em No, não será compilado até que você faça alterações manualmente. 
7. Clique no link para o relatório de conversão para ver detalhes sobre o status de conversão, 
ou então clique em Close. 
A solução abre com o novo sistema do projeto visível no Solution Explorer, mais os 
arquivos da versão antiga da solução. 
8. Mover o código do arquivo classe principal antigo para o novo ThisDocument, 
ThisWorkbook,. e Sheet Classes 
9. Excluir o arquivo classe principal antigo após remover todo o código. 
10. Atualizar qualquer referência não qualificada para aplicativos com espaço para nome 
System.Windows.Forms.Application totalmente qualificado. Para obter mais informações, 
consulte " Atualizando O código " no Atualizando Overview soluções do Office. 
11. Substituir todos os controles ActiveX no documento ou pasta de trabalho por controles 
gerenciados do Visual Studio Toolbox. 
 
Visual C# Consolidado 71
O EXCEL USANDO EXPLICAÇÕESPASSO-A-PASSO 
Walkthroughs fornecem instruções passo a passo para cenários comuns e são um bom lugar para 
começar aprendendo sobre Microsoft Visual Studio 2005 Tools for the Microsoft Office System. 
Orientações as seguir demonstram vários tipos básicos de tarefas: automatizar o Microsoft Office 
Excel 2003, executar análise de dados, trabalhar com controles, soluções, implantação e definindo 
a segurança. 
Coleta de dados usando um formulário do Windows 
Walkthrough 
Essa explicação passo a passo demonstra como abrir um formulário Windows de um planilha do 
Microsoft Office Excel 2003, coletar informações do usuário, e gravar essas informações em uma 
célula da planilha. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Excel 
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 um novo projeto 
Nesta etapa, você irá criar um projeto de aplicativos do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome WinFormInput. Verifique 
que Create a new document está selecionada. Para obter mais informações, consulte 
Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o 
WinFormInput projeto para Solution Explorer. 
Adicionar um controle NamedRange para a planilha 
Para adicionar um intervalo nomeado para Sheet1 
1. Selecione a célula A1 no Sheet1. 
2. Na caixa Name, digite formInput. 
A Name caixa está localizada à esquerda da barra de fórmulas, logo acima coluna A da 
planilha. 
3. Pressione ENTER. 
Um NamedRange controle é adicionado à célula A1. Não há nenhuma indicação visível na 
planilha, mas formInput aparece na caixa Name (logo acima a planilha no lado 
esquerdo). e na Properties janela quando a célula A1 é selecionada 
Visual C# Consolidado 72
Adicionar um formulário do Windows ao projeto 
Criar um formulário do Windows para o usuário forneça informações prompt. 
Para adicionar um formulário do Windows 
1. Selecione o projeto WinFormInput no Solution Explorer. 
2. No menu Project, clique em Add Windows Form. 
3. Nome do formulário GetInputString.vb ou GetInputString.cs. e, em seguida 
clique em Add 
O novo formulário é aberto no designer. 
4. Adicionar um TextBox e um Button. para o formulário 
5. Selecione o botão, localizar a propriedade Text na janela Properties, e alterar o texto 
OK. 
Em seguida, adicione código para ThisWorkbook.vb ou ThisWorkbook.cs para coletar 
informações do usuário. 
Exibindo o formulário do Windows e coletando informações 
Criar uma instância do formulário GetInputString Windows e exibi-lo, e em seguida, escrever as 
informações do usuário em uma célula na planilha. 
Para exibir o formulário e coletar informações 
1. Clique com o botão direito do mouse ThisWorkbook.vb ou ThisWorkbook.cs em 
Solution Explorer e selecione View Code. 
2. No manipulador Open de eventos de ThisWorkbook, adicione o seguinte código para 
declarar uma variável para o formulário GetInputString e depois exibir o formulário: 
Observação 
Em C#, você deve adicionar um manipulador de eventos como mostrado no Startup evento 
abaixo. Para obter informações sobre como criar manipuladores de eventos, consulte Como criar 
manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
private void ThisWorkbook_Startup(object sender, System.EventArgs e) { this.Open += new 
Microsoft.Office.Interop.Excel.WorkbookEvents_OpenEventHandler(ThisWorkbook_Open); } 
private void ThisWorkbook_Open() { GetInputString inputForm = new GetInputString(); 
inputForm.Show(); } 
3. Criar um método chamado WriteStringToCell que grave texto em um intervalo nomeado. 
Esse método é chamado do formulário, e entrado serão passadas para o NamedRange 
controle, formInput o usuário,. na célula A1 
C# 
public void WriteStringToCell(string formData) { Globals.Sheet1.formInput.Value2 = formData; 
} 
Próxima adicionar código ao formulário para lidar com clique o botão na evento. 
Enviar informações para a planilha 
Para enviar informações para a planilha 
1. Clique com o botão direito do mouse GetInputString em Solution Explorer, e 
selecione View Designer. 
Visual C# Consolidado 73
2. Clique duas vezes no botão para abrir o arquivo de código com manipulador de eventos do 
botão Click adicionado. 
3. Adicione código ao manipulador de eventos para levar a entrada da caixa de texto, enviá-lo 
para a função WriteStringToCell, e depois feche o formulário. 
C# 
Globals.ThisWorkbook.WriteStringToCell(this.textBox1.Text); this.Dispose(); 
Testando 
Agora você pode testar sua pasta de trabalho para certificar-se de que o formulário Windows 
aparecer, e se a entrada aparece nesta planilha. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Confirme se o formulário Windows aparece. 
3. Digite Hello World na caixa de texto e clique em OK. 
4. Confirme que Hello World aparece na célula A1 da planilha. 
Próximas etapas 
Essa explicação passo a passo mostra os fundamentos básicos do mostrando um Windows Form 
e dados passagem para uma planilha. Outras tarefas pode desejar executar incluem: 
• Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de 
solução usando o Publish Wizard. 
Alterando planilha formatação usando controles CheckBox 
Walkthrough: 
Essa explicação passo a passo mostra os fundamentos básicos do uso caixas de seleção em um 
planilha do Microsoft Office Excel 2003 para alterar a formatação. Você usará Microsoft Visual 
Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu projeto. 
Para ver o resultado como uma amostra completa, consulte Exemplo do Excel de controles. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicione texto e controles para uma planilha. 
• Formate o texto quando uma opção é selecionada. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• Microsoft Office Excel 2003. 
Criando o projeto 
Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do 
Excel. 
Visual C# Consolidado 74
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Formatting. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel 
Formatting projeto para Solution Explorer. 
Adicionar texto e controles a planilha 
Para essa explicação passo a passo, você precisará três CheckBox controles e algum texto em 
um NamedRange controle. 
Para adicionar três caixas de seleção 
1. Verifique se a pasta de trabalho está abra no designer visual studio e que Sheet1 está 
aberto. 
2. Na guia Common Controls da Toolbox, arraste um CheckBox controle para ou 
próxima célula B2 na Sheet1. 
3. No menu View, selecione Properties Janela. 
4. Certifique-se de que que Checkbox1 esteja visível na caixa de listagem Nome de objeto 
da janela Properties, e altere as propriedades a seguir: 
Propriedade Value (Valor) 
Name applyBoldFont 
Text Negrito 
5. Arraste uma segundacaixa de seleção ou próxima célula B4 e alterar as seguintes 
propriedades: 
Propriedade Value (Valor) 
Name applyItalicFont 
Text Itálico 
6. Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes 
propriedades: 
Propriedade Value (Valor) 
Name applyUnderlineFont 
Text Sublinhado 
7. Selecione todos os controles caixa de seleção três mantendo a tecla CTRL. 
8. Na barra de ferramentas do Excel, clique em Align Lefts e, em seguida clique em Make 
Vertical Spacing Equal. 
Os controles caixa de seleção três agora tem igual espaçamento vertical e são alinhados no 
lado esquerdo, na posição do primeiro controle que você selecionou. 
Você em seguida, será arrastar um NamedRange controle para a planilha. 
Observação 
Você também pode adicionar o NamedRange controle digitando textFont na caixa Name. 
Visual C# Consolidado 75
Para adicionar texto a um controle NamedRange 
1. Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à 
célula B9. 
2. Verificar que $B$9 aparece na caixa de texto editável, e essa célula B9 estiver 
selecionada. Se não estiver, clique em Célula B9 para selecioná-lo. 
3. Clique em OK. 
4. Célula B9 se torna um intervalo nomeado NamedRange1. 
Não há nenhuma indicação visível na planilha, mas NamedRange1 aparece no. (logo 
acima a planilha no lado esquerdo) quando Célula B9 estiver selecionada a Name box 
5. Certifique-se de que que NamedRange1 esteja visível na caixa de listagem Nome de 
objeto da janela Properties, e altere as propriedades a seguir: 
Propriedade Value (Valor) 
Name textFont 
Value2 Clique em uma caixa de seleção para alterar a formatação de texto. 
Em seguida, escreva o código para formatar o texto quando uma opção é selecionada. 
Formatação quando a opção um texto é selecionado 
Você nesta seção, vai escrever código para que quando o usuário seleciona uma opção de 
formatação, o formato do texto na planilha for alterado. 
Para alterar a formatação quando uma caixa de seleção é marcada 
1. Clique com o botão direito do mouse Sheet1 e clique View Code no menu de atalho 
2. Adicione o seguinte código ao manipulador Click de eventos da caixa applyBoldFont de 
seleção: 
C# 
private void applyBoldFont_Click(object sender, EventArgs e) { this.textFont.Font.Bold = 
this.applyBoldFont.Checked; } 
3. Adicione o seguinte código ao manipulador Click de eventos da caixa applyItalicFont de 
seleção: 
C# 
private void applyItalicFont_Click(object sender, EventArgs e) { this.textFont.Font.Italic = 
this.applyItalicFont.Checked; } 
4. Adicione o seguinte código ao manipulador Click de eventos da caixa 
applyUnderlineFont de seleção: 
C# 
private void applyUnderlineFont_Click(object sender, EventArgs e) { if 
(this.applyUnderlineFont.Checked == true) { this.textFont.Font.Underline = 
Excel.XlUnderlineStyle.xlUnderlineStyleSingle; } else { this.textFont.Font.Underline = 
Excel.XlUnderlineStyle.xlUnderlineStyleNone; } } 
5. Em C#, adicione manipuladores de eventos para as caixas de seleção para o Startup 
evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
C# 
Visual C# Consolidado 76
Copiar Código 
this.applyBoldFont.Click += new EventHandler(applyBoldFont_Click); 
this.applyItalicFont.Click += new EventHandler(applyItalicFont_Click); 
this.applyUnderlineFont.Click += new EventHandler(applyUnderlineFont_Click); 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que o texto está formatado 
corretamente quando você marca ou desmarca uma caixa de seleção. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Marque ou desmarque uma caixa de seleção. 
3. Confirme que o texto está formatado corretamente. 
Próximas etapas 
Essa explicação passo a passo mostra as noções básicas de usando caixas de seleção e formatar 
texto em planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Usando um botão para preencher uma caixa de texto. Para obter mais informações, 
consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão 
Walkthrough:. 
Exibindo texto em uma caixa de texto em uma planilha usando 
um botão Walkthrough: 
Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto 
em planilhas Microsoft Office Excel 2003, e como criar projetos Excel usando Microsoft Visual 
Studio 2005 Tools for the Microsoft Office System. Para ver o resultado como uma amostra 
completa, consulte Exemplo do Excel de controles. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar controles a uma planilha. 
• Preencher uma caixa de texto quando um botão é clicado. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• Excel. 
Criando o projeto 
Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do 
Excel. 
Para criar um novo projeto 
Visual C# Consolidado 77
• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Button. Verifique 
que Create a new document está selecionada. Para obter mais informações, consulte 
Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel 
Button projeto para Solution Explorer. 
Adicionar controles a planilha 
Para essa explicação passo a passo, será necessário um botão e uma caixa de texto na primeira 
planilha. 
Para adicionar um botão e uma caixa de texto 
1. Verifique se a My Excel Button.xls pasta de trabalho é aberta no designer visual 
studio, com Sheet1 exibido. 
2. Na guia Common Controls da caixa de ferramentas, arraste para Sheet1. um TextBox 
3. No menu View, selecione Properties Window. 
4. Certifique-que TextBox1 está visível na caixa Properties drop-down janela e alterar a 
Name propriedade da caixa de texto para displayText. 
5. Arraste um Button controle até Sheet1 e alterar as seguintes propriedades: 
Propriedade Value (Valor) 
Name insertText 
Text Inserir texto 
Agora Escreva o código a ser executado quando o botão é clicado. 
Preencher a caixa de texto quando o botão é Clicked 
Sempre que o usuário clica no botão, Hello World! é acrescentada à caixa de texto. 
Para escrever para a caixa de texto quando o botão é clicado 
1. Na Solution Explorer, clique com o botão direito do mouse Sheet1 e, em seguida 
clique View Code no menu de atalho. 
2. Adicione o seguinte código ao manipulador Click de eventos do botão: 
C# 
private void insertText_Click(object sender, EventArgs e) { this.displayText.Text += "Hello 
World! "; } 
3. Em C#, adicione um manipulador de eventos para o Startup evento como mostrado abaixo. 
Para obter informações sobre como criar manipuladores de eventos, consulte Como criar 
manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
this.insertText.Click += new EventHandler(insertText_Click); 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que a mensagem Hello World! 
aparece na caixa de texto quando você clica no botão. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Clique no botão. 
Visual C# Consolidado 78
3. Confirme que Hello World! aparece na caixa de texto. 
Próximas etapas 
Essa explicação passo a passo mostra os fundamentos básicos douso botões e caixas de texto 
em planilhas do Excel. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de 
solução usando o Publish Wizard. 
• Usar caixas de seleção para alterar a formatação. Para obter mais informações, consulte 
Alterando planilha formatação usando controles CheckBox Walkthrough:. 
Programação contra eventos de um controle NamedRange 
Walkthrough: 
Essa explicação passo a passo demonstra como adicionar um NamedRange controle a um 
planilha do Microsoft Office Excel 2003 e programa contra seus eventos usando Microsoft Visual 
Studio 2005 Tools for the Microsoft Office System. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar um NamedRange controle para uma planilha. 
• Programa contra NamedRange Eventos de controle. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• Microsoft Office Excel 2003. 
Criando o projeto 
Nesta etapa, você irá criar pasta de trabalho Excel usando Visual Studio Tools for Office Um do 
projeto. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Named Range 
Events. Verifique que Create a new document está selecionada. Para obter mais 
informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Named 
Range Events projeto para Solution Explorer. 
Adicionar texto e pipes intervalos para a planilha 
Porque controles host são estendidos objetos do Office, você poderá adicioná-los para o 
documento em da mesma maneira, você adicionar o objeto nativo. Por exemplo, você pode 
adicionar um controle Excel NamedRange a uma planilha ao abrir o Insert menu apontando 
para Name, e escolher Define. Você também pode adicionar um NamedRange controle, 
arrastando-a partir para a planilha. o Toolbox 
Visual C# Consolidado 79
Nesta etapa, você irá adicionar dois controles Intervalo Nomeado da planilha usando a e adicione 
texto para a planilha. o Toolbox, 
Para adicionar um intervalo para a planilha 
1. Verifique se a My Named Range Events.xls pasta de trabalho é aberta no designer 
visual studio, com Sheet1 exibido. 
2. Na guia Excel Controls da caixa de ferramentas, arraste um NamedRange controle à 
célula A1 no Sheet1. 
A Add NamedRange Control caixa de diálogo será exibida. 
3. Verificar que $A$1 aparece na caixa de texto editável, e essa célula A1 estiver 
selecionada. Se não estiver, clique em Célula A1 para selecioná-lo. 
4. Clique em OK. 
Célula A1 se torna um intervalo nomeado namedRange1. Não há nenhuma indicação 
visível na planilha, mas namedRange1 aparece na caixa Name (localizada logo acima da 
planilha no lado esquerdo). Quando Célula A1 estiver selecionada 
5. Adicionar um outro NamedRange controle a célula B3. 
6. Verificar que $B$3 aparece na caixa de texto editável, e essa célula B3 estiver 
selecionada. Se não estiver, clique em Célula B3 para selecioná-lo. 
7. Clique em OK. 
Célula B3 se torna um intervalo nomeado namedRange2. 
Para adicionar texto a sua planilha 
1. Na célula A1, digite o seguinte texto: 
Este é um Exemplo de um controle NamedRange. 
2. Na célula A3 (para a esquerda de namedRange2), digite o seguinte texto: 
Eventos: 
Você nas seções a seguir, será escrever código que insere texto em namedRange2 e modifica 
propriedades do controle namedRange2 em resposta à BeforeDoubleClick, Change., e 
SelectionChange eventos de namedRange1 
Adicionar código para responder ao evento BeforeDoubleClick 
Para inserir texto em NamedRange2 com base no Evento 
BeforeDoubleClick 
1. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs. e selecione View Code 
2. Adicione código para o namedRange1_BeforeDoubleClick manipulador de eventos é 
semelhante ao seguinte: 
C# 
private void namedRange1_BeforeDoubleClick( Microsoft.Office.Interop.Excel.Range Target, 
ref bool Cancel) { this.namedRange2.Value2 = "The BeforeDoubleClick event occurred."; 
this.namedRange2.Font.Color = 
System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Red); 
this.namedRange2.Font.Italic = true; } 
3. Em C#, você deve adicionar manipuladores de eventos para o intervalo nomeado como 
mostrado no Startup evento abaixo. Para obter informações sobre como criar 
Visual C# Consolidado 80
manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas 
do Visual Studio do Office:. 
C# 
this.namedRange1.BeforeDoubleClick += new Microsoft.Office.Interop.Excel. 
DocEvents_BeforeDoubleClickEventHandler(namedRange1_BeforeDoubleClick); 
this.namedRange1.Change += new Microsoft.Office.Interop.Excel. 
DocEvents_ChangeEventHandler(namedRange1_Change); this.namedRange1.SelectionChange 
+=new Microsoft.Office.Interop.Excel. 
DocEvents_SelectionChangeEventHandler(namedRange1_SelectionChange); 
Adicionar código para responder ao evento de alteração 
Para inserir texto em namedRange2 com base no evento Change 
• Adicione código para o NamedRange1_Change manipulador de eventos é semelhante ao 
seguinte: 
C# 
private void namedRange1_Change(Microsoft.Office.Interop.Excel.Range Target) { 
this.namedRange2.Value2 = "The Change event occurred."; this.namedRange2.Font.Color = 
System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Blue); 
this.namedRange2.Font.Italic = false; } 
Observação 
Como duas vezes em uma célula em um intervalo do Excel entra no modo de edição, um Change 
evento ocorre quando a seleção é movida fora do intervalo mesmo que nenhuma alteração ao 
texto ocorreu. 
Adicionar código para responder ao evento SelectionChange 
Para inserir texto em namedRange2 com base no evento 
SelectionChange 
• Adicione código para o NamedRange1_SelectionChange manipulador de eventos é 
semelhante ao seguinte: 
C# 
private void namedRange1_SelectionChange(Microsoft.Office.Interop.Excel.Range Target) { 
this.namedRange2.Value2 = "The SelectionChange event occurred."; 
this.namedRange2.AddComment("SelectionChange always occurs before BeforeDoubleClick."); 
this.namedRange2.Font.Color = 
System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Black); } 
Observação 
Porque faz duas vezes em uma célula em um intervalo do Excel com a seleção para mover para o 
intervalo, um SelectionChange evento ocorre antes de ocorrer o BeforeDoubleClick evento. 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para verificar texto que descreve os eventos de um 
NamedRange controle que será inserido no outro intervalo nomeado quando os eventos são 
aumentados. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Coloque o cursor no namedRange1, e verificar que o texto sobre o SelectionChange 
evento é inserido e que um comentário é inserido na planilha. 
Visual C# Consolidado 81
3. Duplo clique dentro namedRange1, e verifique se o texto sobre BeforeDoubleClick 
eventos está inserido com texto em itálico em namedRange2 vermelho. 
4. Clique fora do namedRange1 e observe que o evento de alteração ocorre quando sair 
Modo Edição mesmo que nenhuma alteração para o texto foi feita. 
5. Alterar o texto dentro namedRange1. 
6. Clique fora do namedRange1, e verifique se o texto sobre Change evento está inserido 
com texto em namedRange2 azul. 
Próximas etapas 
Essa explicação passo a passo mostra noções básicas de programação contra eventos de um 
NamedRange controle. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantarsoluções do 
Office:. 
• Programação contra eventos dos XMLNode controles modo. Para obter mais informações, 
consulte Alterando o painel de ações de acordo com contexto do usuário Walkthrough:. 
 
Passo-a-passo: Concedendo e removendo permissões para uma 
solução do Office 
Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual 
Studio 2005 Tools for the Microsoft Office System. 
Durante este explicação passo a passo, você aprenderá como: 
• Remova a configuração de segurança padrão. 
• Adicionar um novo conjunto de permissões. 
• Testar seu projeto. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• Microsoft Office Excel 2003. 
Criando o projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security 
Test projeto para Solution Explorer. 
Adicionar código para trás a planilha 
Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha. 
Para adicionar uma caixa de mensagem a um evento de inicialização 
1. Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual 
studio, com Sheet1 exibido. 
Visual C# Consolidado 82
2. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs,. e, em seguida clique View Code no menu de atalho 
3. Adicione o seguinte código para o Startup método dentro classe Sheet1 para mostrar uma 
caixa de mensagem durante a inicialização. 
C# 
private void Sheet1_Startup(object sender, System.EventArgs e) { MessageBox.Show("Security 
settings are correct."); } 
4. No menu File, clique em Save All. 
5. Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location. 
6. Clique em Save. 
7. Pressione F5 para executar o projeto. 
O Excel é iniciado e aparecerá a caixa de mensagem. 
8. Fechar a caixa de mensagem. 
9. Feche o Excel. 
10. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 
11. Feche My Security Test.xls (a superfície do design de planilha Excel) no designer do 
Visual Studio. 
Feche todos os instâncias do Excel antes de alterar a diretiva de segurança. 
Quando você criado o projeto de pasta de trabalho do Excel, o assistente adicionado um novo 
grupo de código de segurança e um grupo de códigos filho à diretiva de segurança Runtime no 
nível do usuário. 
Em seguida, você removerá o grupo de códigos que criou o assistente. 
Remover o grupo de códigos padrão 
Localize e remova o grupo de código padrão que foi criado. 
Para remover um grupo de códigos 
1. No Painel de Controle, abra Administrative Tools. 
2. Executar Microsoft .NET Framework 2.0 Configuration. 
3. No modo de exibição de árvore no lado esquerdo, expanda .NET Framework 2.0 
Configuration,, expandir Runtime Security Policy, expandir User, expandir Code 
Groups, Expandido All_Code e My Computer expanda VSTOProjects. 
Não é um GUID para cada projeto tenha criado. Expanda cada GUID para ver o caminho 
para o documento associado. 
4. Clique com o botão direito do mouse o GUID de C:\Walkthroughs\My Security 
Test\My Security Test\bin\My Security Test.xls grupo de códigos, e, em 
seguida clique Delete no menu de atalho. 
Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir 
este grupo de códigos. 
5. Clique em Yes. 
6. Voltar para Visual Studio, e pressione F5 para executar o projeto meu teste de segurança. 
Será exibida informando a atual política de segurança .NET permite que não não que a 
personalização para executar uma mensagem de erro. 
7. Clique em OK. 
Visual C# Consolidado 83
8. Feche o Excel. 
O conjunto não pode ser executado se ele não tiver permissão explícita na Diretiva de Segurança 
Microsoft .NET. 
Em seguida, conceda permissão para o conjunto usando um nome forte em vez de uma URL para 
prova. 
Dando um nome de alta segurança para o conjunto 
Um nome forte é geralmente mais seguro que uma URL como prova. Será criar e atribuir um 
nome forte o conjunto nas próximas etapas. 
Para criar um nome forte 
1. No menu Project no Visual Studio, clique em My Security Test Properties. 
2. Clique na Signing guia. 
3. Selecione Sign the assembly. 
4. No, o Choose a strong name key file list clique New. 
5. Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa 
Key file name. 
6. Desmarque a Protect my key file with a password caixa de seleção. 
7. Clique em OK. 
O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer. 
8. No menu Build, clique em Build Solution Para criar o conjunto contra o par de chaves 
nome forte. 
Conceder confiança com base no nome de alta segurança 
Agora adicionar um novo grupo de código para conceder confiança total para o conjunto com base 
no nome forte. 
Para conceder confiança com base em nome forte 
1. Abra Microsoft .NET Framework 2.0 Configuration novamente. 
2. Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de 
atalho 
3. Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique 
em Next. 
4. Na lista Choose the condition type for this code group, clique Strong Name. 
5. Clique em Import. 
6. Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My 
para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança 
Test\bin\debug\My no C#, e clique em Open. 
7. Clique em Next. 
8. Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish. 
9. Fechar Microsoft .NET Framework 2.0 Configuration. 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado 
quando a pasta de trabalho é aberta. 
Para testar sua pasta de trabalho 
Visual C# Consolidado 84
1. Pressione F5 para executar o projeto. 
2. Confirme se a caixa de mensagem aparece. 
Passo-a-passo: Ligando uma célula de planilha a um campo de 
banco de dados 
Essa explicação passo a passo demonstra noções básicas de vinculação um único campo de 
dados em um banco de dados do SQL Server a um intervalo nomeado no Microsoft Office Excel 
2003. Ele inclui adicionar controles que permitem que você para percorrer todos os registros da 
tabela. 
Durante este explicação passo a passo, você aprenderá como: 
• Criar uma fonte de dados para um projeto do Excel. 
• Adicionar controles a uma planilha. 
• Rolar pelos registros do banco de dados. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Microsoft Office Excel 2003. 
Acesso a um servidor com o Exemplo de SQL Server do Northwind. 
• Permissões para ler e gravar no banco de dados do SQL Server. 
Criando um novo projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Simple Data Binding, 
usando o Visual Basic ou C#. Verifique que Create a new document está selecionada. 
Para obter mais informações, consulte Como criar Ferramentas do Visual Studio para projetos 
do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Simple 
Data Binding projetopara Solution Explorer. 
Criando o DataSet 
Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto. 
Para criar o DataSet 
1. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data 
menu. 
Observação 
Se Show Data Sources clique dentro a pasta de trabalho do Excel e depois verificar novamente. 
Visual C# Consolidado 85
não estiver disponível, 
2. Clique Add New Data Source Para iniciar o Data Source Configuration 
Wizard. 
3. Selecione Database e, em seguida clique em Next. 
Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou 
adicionar uma nova conexão com o New Connection botão. 
4. Após uma conexão foi selecionado ou criado, clique em Next. 
5. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 
6. Expanda o Tables nó na janela Database objects. 
7. Marque a caixa de seleção ao lado da Customers tabela. 
8. Clique em Finish. 
O assistente adicionará a Customers tabela para a Data Sources janela. Ele também 
adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. 
Adicionar controles a planilha 
Para essa explicação passo a passo, você precisa de dois intervalos nomeados e quatro botões 
na primeira planilha. Primeiro, adicione os dois intervalos nomeados a partir da Data Sources 
janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os 
botões da Toolbox. 
Para adicionar dois intervalos nomeados 
1. Verifique se a My Simple Data Binding.xls pasta de trabalho é aberta no designer 
visual studio, com Sheet1 exibido. 
2. Abra a Data Sources janela e expanda o Customers nó. 
3. Selecione a CompanyName coluna, e clique na seta suspensa que aparece. 
4. Selecione NamedRange na lista drop-down, e arraste a CompanyName coluna à 
célula A1. 
Um NamedRange controle denominado companyNameNamedRange é criado na célula 
A1. Ao mesmo tempo, nomeado customersBindingSource, um adaptador de tabela, e 
uma DataSet instância são adicionados ao projeto. um BindingSource O controle é 
acoplado que por sua vez está vinculado a DataSet instância. o BindingSource, 
5. Selecione a CustomerID coluna na janela Data Sources, e clique na seta suspensa 
que aparece. 
6. Clique NamedRange na lista drop-down, e arraste a CustomerID coluna à célula B1. 
7. É criado na célula B1, e vinculado a outro NamedRange controle chamado 
customerIDNamedRange o BindingSource. 
Para adicionar quatro botões 
1. Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o 
Toolbox, 
É nome Button1 este botão. 
2. Adicionar mais três botões às seguintes células nesta ordem, para que os nomes são 
conforme mostrado: 
Célula (Nome) 
Visual C# Consolidado 86
B3 Button2 
C3 Button3 
D3 Button4 
A próxima etapa é para adicionar texto para os botões, e em C# Adicionar manipuladores de 
eventos. 
Inicializando as controles 
Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento. 
Para inicializar os controles 
1. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código para o Sheet1_Startup método para definir o texto para cada 
botão. 
C# 
this.button1.Text = "|<"; this.button2.Text = "<"; this.button3.Text = ">"; this.button4.Text = 
">|"; 
3. Para C# só, adicionar manipuladores de eventos para o botão clique eventos para o 
Sheet1_Startup método. 
C# 
this.button1.Click += new EventHandler(button1_Click); this.button2.Click += new 
EventHandler(button2_Click); this.button3.Click += new EventHandler(button3_Click); 
this.button4.Click += new EventHandler(button4_Click); 
Agora, adicione código para manipular os Click eventos dos botões para que o usuário pode 
procurar pelos registros. 
Adicionar código para ativar rolagem através dos registros 
Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros. 
Para mover para o primeiro registro 
• Adicionar um manipulador de eventos para o Click Evento do botão Button1, e adicione o 
código para mover para o primeiro registro a seguir: 
C# 
private void button1_Click(object sender, System.EventArgs e) { 
this.customersBindingSource.MoveFirst(); } 
Para mover para o registro anterior 
• Adicionar um manipulador de eventos para o Click Evento do botão Button2, e adicione 
o código a seguir para mover a posição de volta em um: 
C# 
private void button2_Click(object sender, System.EventArgs e) { 
this.customersBindingSource.MovePrevious(); } 
Para mover para o próximo registro 
• Adicionar um manipulador de eventos para o Click Evento do botão Button3, e adicione 
o código a seguir para avançar a posição em um: 
C# 
Visual C# Consolidado 87
private void button3_Click(object sender, System.EventArgs e) { 
this.customersBindingSource.MoveNext(); } 
Para mover para o último registro 
• Adicionar um manipulador de eventos para o Click Evento do botão Button4, e adicione 
o código a seguir para mover para o último registro: 
C# 
private void button4_Click(object sender, System.EventArgs e) { 
this.customersBindingSource.MoveLast(); } 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que você pode navegar através 
dos registros no banco de dados. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Confirme se o primeiro registro aparece nas células A1 e B1. 
3. Clique em e B1. (Button3) botão e confirme se o registro seguinte aparece na célula A1 
a > 
4. Clique nos outros botões de rolagem para confirmar que o registro muda conforme o 
esperado. 
Próximas etapas 
Essa explicação passo a passo mostra os fundamentos básicos do vinculando um intervalo 
nomeado a um campo em um banco de dados. Aqui estão algumas tarefas que podem vie em 
seguida: 
• Cache os dados para que ele possa ser usado off-line. Para obter mais informações, 
consulte Como dados de cache para uso off-line ou em um servidor:. 
• Vincular células para várias colunas em uma tabela, em vez da um campo. Para obter 
mais informações, consulte Walkthrough: vinculação células para várias colunas em uma 
tabela. 
• Usar um BindingNavigator controle para percorrer os registros. Para obter mais 
informações, consulte COMO: Navegar em dados com o controle BindingNavigator do 
Windows Forms. 
Walkthrough: vinculação células para várias colunas em uma 
tabela 
Essa explicação passo a passo demonstra noções básicas de vinculação várias células em uma 
planilha do Microsoft Office Excel 2003 a campos no banco de dados Northwind do SQL Server. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar controles a uma planilha. 
• Salva qualquer alteração de dados de volta para o banco de dados. 
• Testar seu projeto. 
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. 
Visual C# Consolidado 88
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Microsoft Office Excel 2003. 
Acesso a um servidor com o Exemplo de SQL Server do Northwind. 
• Permissões para ler e gravar no banco de dados do SQL Server. 
Criando um novo projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Complex Data 
Binding, usando o Visual Basic ou C#. Verifique que Create a new document está 
selecionada. Para obter mais informações, consulte Como criar Ferramentas do Visual Studio 
para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalhodo Excel no designer e adiciona o My 
Complex Data Binding projeto para Solution Explorer. 
Criando o DataSet 
Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto. 
Para criar o DataSet 
1. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data 
menu. 
Observação 
Se Show Data Sources clique dentro a pasta de trabalho do Excel e depois verificar novamente. 
não estiver disponível, 
2. Clique Add New Data Source Para iniciar o Data Source Configuration 
Wizard. 
3. Selecione Database e, em seguida clique em Next. 
Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou 
adicionar uma nova conexão com o New Connection botão. 
4. Após uma conexão foi selecionado ou criado, clique em Next. 
5. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 
6. Expanda o Tables nó na janela Database objects. 
7. Marque a caixa de seleção ao lado da Employees tabela. 
8. Clique em Finish. 
O assistente adicionará a Employees tabela para a Data Sources janela. Ele também 
adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. 
Adicionar controles a planilha 
Para essa explicação passo a passo, você precisa um ListObject controle e um Button controle na 
primeira planilha. Primeiro, adicione o ListObject controle a partir da Data Sources janela 
para que ela está vinculada automaticamente à fonte de dados. Em seguida, adicione o Button 
controle da Toolbox. 
Para adicionar um ListObject 
Visual C# Consolidado 89
1. Verifique se a My Complex Data Binding.xls pasta de trabalho é aberta no designer 
visual studio, com Sheet1 exibido. 
2. Abra a Data Sources janela e selecione o Employees nó. 
3. Clique na seta suspensa que aparece. 
4. Selecione ListObject na lista drop-down, e arraste a Employees tabela à célula A6. 
Um ListObject controle denominado EmployeesListObject é criado na célula A6. Ao 
mesmo tempo, nomeado EmployeesBindingSource, um adaptador de tabela, e uma 
DataSet instância são adicionados ao projeto. um BindingSource O controle é acoplado que 
por sua vez está vinculado a DataSet instância. o BindingSource, 
Para adicionar um botão 
• Na guia Common Controls Da adicionar um Button controle a célula A4 da planilha. 
o Toolbox, 
A próxima etapa é para adicionar texto ao botão quando a planilha abre. 
Inicialização do controle 
Adicionar texto ao botão no manipulador Startup de eventos. 
Ao inicializar o controle 
1. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código para o Sheet1_Startup método para definir o texto para o b 
utton. 
C# 
this.button1.Text = "Save"; 
3. C# somente, para adicionar um manipulador de eventos para o Click evento para o 
Sheet1_Startup método. 
C# 
this.button1.Click += new EventHandler(button1_Click); 
Agora, adicione código para manipular o Click Evento do botão. 
Salvar alterações no banco de dados 
As alterações tenham sido feitas o dados existe somente no dataset local até que eles são salvos 
explicitamente volta para o banco de dados. 
Para salvar as alterações feitas o banco de dados 
• Adicionar um manipulador de eventos para o Click evento do b utton, e adicione o código 
a seguir para confirmar todas as alterações que foram feitas no dataset volta para o banco de 
dados: 
C# 
private void button1_Click(object sender, EventArgs e) 
{ try 
{ this.employeesTableAdapter.Update(this.northwindDataSet.Employees); 
} 
catch (System.Data.DataException ex) 
{ MessageBox.Show(ex.Message); } } 
Visual C# Consolidado 90
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se de que os dados aparecem como 
esperado, e que você pode manipular os dados de um objeto lista. 
Para testar a vinculação de dados 
• Pressione F5. 
Verifique que quando abrir a pasta de trabalho, o objeto lista é preenchido com dados da 
tabela Employees. 
Para modificar dados 
1. Clique em Célula B7, que deve conter o nome Davolio. 
2. Digite o nome Anderson, e pressione ENTER. 
Para modificar um cabeçalho de coluna 
1. Clique na célula que contém no cabeçalho LastName da coluna. 
2. Digitar Last Name, incluindo um espaço entre as duas palavras, e pressione ENTER. 
Para salvar dados 
1. Clique Save na planilha. 
2. Feche a pasta de trabalho. Clique em No Quando solicitado a salvar as alterações feitas. 
3. Pressione F5 para executar o projeto novamente. 
O objeto lista é preenchido com dados da tabela Employees. 
4. Observe que o nome na célula B7 é ainda Anderson, que é a alteração de dados que 
você feitas e salvas volta para o banco de dados. No cabeçalho LastName da coluna foi 
alterado para seu formato original sem nenhum espaço, porque no cabeçalho da coluna 
não está vinculado ao banco de dados e você não foi salvar as alterações feitas para a 
planilha. 
Para adicionar novas linhas 
1. Selecione uma célula dentro do objeto lista. 
Uma nova linha aparece na parte inferior da lista, com um asterisco (*.) na primeira célula 
da nova linha 
2. Adicionar as informações a seguir na linha vazia: 
CódigoDoFuncionário Sobrenome FirstName Título 
10 ITO Shu Gerenciador de vendas 
Para excluir linhas 
1. Selecionar linha 16, que deve conter a nova linha que você adicionou, clicando no número 
16 no lado esquerdo da planilha. 
2. No menu Edit, clique em Delete. 
Para classificar as linhas na lista 
1. Selecione uma célula dentro da lista. 
Botões de seta aparecem em cada cabeçalho de coluna. 
2. Clique no botão SETA no cabeçalho da Last Name coluna. 
3. Clique em Sort Ascending. 
Visual C# Consolidado 91
As linhas são classificadas em ordem alfabética por sobrenome. 
Para filtrar informações 
1. Selecione uma célula dentro da lista. 
2. Clique no botão SETA no cabeçalho da Title coluna. 
3. Clique em Sales Representative. 
A lista mostra somente as linhas que têm Sales Representative na coluna Title. 
4. Clique no botão SETA no cabeçalho da Title coluna novamente. 
5. Clique em (All). 
Filtragem é removida e todas as linhas aparecem. 
Próximas etapas 
Essa explicação passo a passo mostra os fundamentos básicos do vinculando uma tabela em um 
banco de dados a um objeto de lista. Aqui estão algumas tarefas que podem vie em seguida: 
• Cache os dados para que ele possa ser usado off-line. Para obter mais informações, 
consulte Como dados de cache para uso off-line ou em um servidor:. 
• Implantar a solução. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Criar uma relação mestre / detalhes entre um campo e uma tabela. Para obter mais 
informações, consulte Criando uma relação mestre / detalhes usando um DataSet em cache 
Walkthrough:. 
Criando uma relação mestre / detalhes usando um DataSet em 
cache Walkthrough: 
Essa explicação passo a passo demonstra criar uma relação mestre / detalhes em uma planilha, e 
cache os dados para que a solução pode ser usada off-line. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar controles a uma planilha. 
• Configurar um DataSet para ser armazenados em uma planilha. 
• Adicione código para Habilitar rolagem pelos registros. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Microsoft Office Excel 2003. 
Acesso ao Exemplo de SQL Server do Northwind. O banco de dados pode ser no seu computador 
de desenvolvimento ou em um servidor. 
• Permissões para ler e gravar no banco de dados do SQL Server.Visual C# Consolidado 92
Criando um novo projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Master-Detail, usando 
o Visual Basic ou C#. Verifique que Create a new document está selecionada. Para obter 
mais informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Master-
Detail projeto para Solution Explorer. 
Criando o DataSet 
Use a Data Sources janela para adicionar um DataSet digitado ao seu projeto. 
Para criar o DataSet 
1. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data 
menu. 
2. Clique Add New Data Source Para iniciar o Data Source Configuration 
Wizard. 
3. Selecione Database e, em seguida clique em Next. 
Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou 
adicionar uma nova conexão usando o New Connection botão. 
4. Após selecionar ou criar uma conexão, clique em Next. 
5. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 
6. Expanda o Tables nó na janela Database objects. 
7. Selecione a Orders tabela e a Order Details tabela. 
8. Clique em Finish. 
O assistente adicionará as duas tabelas para a Data Sources janela. Ele também adiciona um 
DataSet digitado ao seu projeto que está visível no Solution Explorer. 
Adicionar controles a planilha 
Nesta etapa, você adicionará um intervalo nomeado, um objeto de lista, e dois botões à primeira 
planilha. Primeiro, adicionar o intervalo nomeado e o objeto lista a partir da Data Sources 
janela para que automaticamente eles são vinculados à fonte de dados. Em seguida, adicione os 
botões da Toolbox. 
Para adicionar um intervalo nomeado e um objeto de lista 
1. Verifique se a My Master-Detail.xls pasta de trabalho é aberta no designer visual 
studio, com Sheet1 exibido. 
2. Abra a Data Sources janela e expanda o Orders nó. 
3. Selecione a OrderID coluna, e clique na seta suspensa que aparece. 
4. Clique NamedRange na lista drop-down, e arraste a OrderID coluna à célula A2. 
Um NamedRange controle denominado OrderIDNamedRange é criado na célula A2. Ao 
mesmo tempo, nomeado OrdersBindingSource, um adaptador de tabela, e uma DataSet 
instância são adicionados ao projeto. um BindingSource O controle é acoplado que por sua 
vez está vinculado a DataSet instância. o BindingSource, 
5. Role para baixo após as colunas que estão sob a Orders tabela. Na parte inferior da lista 
é a Order Details tabela; ele é aqui porque ele é um filho da Orders tabela. Selecionar 
Visual C# Consolidado 93
esta Order Details Tabela, não a um que seja no mesmo nível como a Orders Tabela, 
e clique a seta suspensa que aparece. 
6. Clique ListObject na lista drop-down, e arraste a Order Details tabela à célula A6. 
7. Um ListObject controle denominado Order_DetailsListObject é criado na célula A6, 
e vinculado à BindingSource. 
Para adicionar dois botões 
1. Na guia Common Controls Da adicionar um Button controle a célula A3 da planilha. o 
Toolbox, 
É nome Button1 este botão. 
2. Adicionar um outro Button controle a célula B3 da planilha. 
É nome Button2 este botão. 
Em seguida, marcar DataSet para ser armazenado em cache no documento. 
Cache o DataSet 
Marcar DataSet para ser armazenado em cache no documento, tornar DataSet públicos e 
definindo a CacheInDocument propriedade. 
Armazenar em cache DataSet 
1. Selecione NorthwindDataSet No bandeja de componentes. 
2. Na janela Properties, alterar a Modifiers propriedade para Public. 
DataSets deverá ser pública antes cache está ativado. 
3. Alterar a CacheInDocument propriedade para True. 
A próxima etapa é para adicionar texto a botões, e no C# adicione código para ligar os 
manipuladores de eventos. 
Inicializando as controles 
Definir o texto do botão e adicionar manipuladores de eventos durante o Startup evento. 
Ao inicializar os dados e os controles 
1. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código para o Sheet1_Startup método para definir o texto para os 
botões. 
C# 
this.button1.Text = "<"; this.button2.Text = ">"; 
3. Para C# só, adicionar manipuladores de eventos para o botão clique eventos para o 
Sheet1_Startup método. 
C# 
this.button1.Click += new EventHandler(button1_Click); this.button2.Click += new 
EventHandler(button2_Click); 
Adicionar código para ativar rolagem através dos registros 
Adicione código ao manipulador Click de eventos de cada botão para percorrer os registros. 
Para percorrer os registros 
1. Adicionar um manipulador de eventos para o Click evento de Button1, e adicione o 
código a seguir para percorrer os registros para trás: 
Visual C# Consolidado 94
C# 
private void button1_Click(object sender, EventArgs e) { 
this.ordersBindingSource.MovePrevious(); } 
2. Adicionar um manipulador de eventos para o Click evento de Button2, e adicione o 
código a seguir para avançar pelos registros: 
C# 
private void button2_Click(object sender, EventArgs e) { this.ordersBindingSource.MoveNext(); 
} 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se de que os dados aparecem como 
esperado, e que você pode usar a solução off-line. 
Para testar o cache de dados 
1. Pressione F5. 
2. Verifique que o intervalo nomeado e o objeto lista são preenchidos com dados da fonte de 
dados. 
3. Rolar pelos alguns dos registros clicando nos botões. 
4. Pasta de trabalho, salve e feche a pasta de trabalho e Visual Studio. 
5. Desativar a conexão ao banco de dados. Desconecte o cabo de rede do seu computador 
se o banco de dados estiver localizado em um servidor, ou parar o serviço SQL Server se o 
banco de dados for no seu computador de desenvolvimento. 
6. Abra o Excel, e abra My Master-Detail.xls a partir do diretório \bin (\My Detail\bin 
mestre-no Visual Basic) ou \My Detail\bin\debug mestre-em C#. 
7. Rolar pelos alguns dos registros para ver que a planilha opera normalmente quando 
desconectado. 
8. Reconectar-se ao banco de dados. Conectar-se seu computador à rede novamente se o 
banco de dados estiver localizado em um servidor, ou inicia o serviço SQL Server se o 
banco de dados for no seu computador de desenvolvimento. 
Próximas etapas 
Essa explicação passo a passo mostra as noções básicas de criar uma relação mestre / detalhes 
de dados em uma planilha e cache um DataSet. Aqui estão algumas tarefas que podem vie em 
seguida: 
• Implantar a solução. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Recuperar dados de cache para outro projeto. Para obter mais informações, consulte 
Como recuperar dados de uma pasta de trabalho em um servidor em cache:. 
 
Walkthrough: atualizando um gráfico em uma planilha usando botões de 
opção 
Essa explicação passo a passo mostra os fundamentos básicos do alterando estilos do gráfico 
usando botões de opção em um planilha do Microsoft Office Excel 2003. Para ver o resultado 
como uma amostra completa, consulte Exemplo do Excel de controles. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar um controle de usuário para uma planilha. 
Visual C# Consolidado 95
• Alterar o estilo do gráfico quando uma opção está selecionada. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Microsoft Office Excel 2003. 
Adicionarum gráfico a uma planilha 
Você pode criar um projeto de pasta de trabalho do Excel usando uma pasta de trabalho 
existente. Nessa explicação passo a passo, irá adicionar um gráfico à pasta de trabalho e Usar 
pasta de trabalho no Excel uma nova solução. A fonte de dados nessa explicação passo a passo 
é uma planilha chamada Data for Chart. 
Para adicionar os dados 
1. Abra o Excel 2003. 
Abre uma nova pasta de trabalho. 
2. Clique com o botão direito do mouse na Sheet3 guia e, em seguida clique Rename no 
menu de atalho. 
3. Renomear a planilha para Data for Chart. 
4. Adicionar dados Data for Chart Os seguir com célula A4 sendo a parte superior 
esquerda E8 Canto, e o canto inferior direito: 
 Q1 Q2 Q3 Q4 
Oeste 500 550 550 600 
Leste 600 625 675 700 
Norte 450 470 490 510 
Sul 800 750 775 790 
Em seguida, adicione o gráfico para a primeira planilha. 
Para adicionar um gráfico 
1. No menu Insert, clique em Chart. 
O Chart Wizard abre. 
2. Clique em Next, deixando os padrões selecionados. 
3. Clique na caixa Data Range e desmarque qualquer seleção padrão. 
4. Na planilha Data for Chart, selecionar o bloco de células que contém os números, que 
inclui A4 no canto esquerdo superior para E8 no canto direito inferior. 
5. Para aceitar todos os padrões para Step 3, clique Next em Next novamente. 
6. No Step 4, garantir que As object in: está selecionado. 
Visual C# Consolidado 96
7. Na lista As object in:, selecione Sheet1. 
8. Clique em Finish. 
9. Reposicionar o gráfico para que o canto direito superior alinhe com Célula E2. 
10. Salve o arquivo para a unidade C: e nomeá-la ExcelChart.xls. 
11. Feche o Excel. 
Criando um novo projeto 
Nesta etapa, você irá criar um projeto usando Visual Studio Tools for Office pasta de trabalho do 
Excel. 
Para criar um novo projeto 
1. Criar um projeto de pasta de trabalho do Excel com o nome My Excel Chart. Verifique 
que Copy an existing document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
2. Clique no Browse botão e vá para a pasta de trabalho que você criou anteriormente 
nessa explicação passo a passo. 
3. Clique em OK. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel 
Chart projeto para Solution Explorer. 
Definindo Propriedades do gráfico 
Quando você criar um novo projeto pasta de trabalho do Excel usando uma pasta de trabalho 
existente, controles host automaticamente são criados para intervalos nomeados, objetos lista, e 
gráficos que existem dentro da pasta de trabalho. Você pode alterar o nome do controle Chart 
usando a Properties janela 
Para alterar o nome do controle gráfico 
• Selecione o Chart controle no designer e alterar as seguintes propriedades na janela 
Properties: 
Propriedade Value (Valor) 
Name dataChart 
HasLegend False 
Adicionar um controle de usuário ao projeto 
Para adicionar um controle de usuário 
1. Selecione o My Excel Chart projeto no Solution Explorer. 
2. No menu Project, clique em Add New Item. 
3. Na caixa Add New Item de diálogo, clique User Control, nome do controle 
ChartOptions, e clique em Add 
Para adicionar controles Windows Form ao controle de usuário 
1. Se o controle de usuário estiver não visível no designer, clique duas vezes em 
ChartOptions no Solution Explorer. 
2. Na guia Common Controls Da arraste um Radio Button controle para o controle de 
usuário, e alterar as seguintes propriedades: o Toolbox, 
Propriedade Value (Valor) 
Visual C# Consolidado 97
Name columnChart 
Text Gráfico de coluna 
3. Adicionar um botão de opção segundo para o controle de usuário, e alterar as 
propriedades a seguir: 
Propriedade Value (Valor) 
Name barChart 
Text Gráfico de barras 
4. Adicionar um botão de opção terceiro para o controle de usuário, e alterar as propriedades 
a seguir: 
Propriedade Value (Valor) 
Name lineChart 
Text Gráfico de linha 
5. Adicionar um botão de opção quarto para o controle de usuário, e alterar as propriedades a 
seguir: 
Propriedade Value (Valor) 
Name areaBlockChart 
Text Gráfico bloquear de área 
Em seguida, escreva o código para atualizar o gráfico quando um botão de opção é clicado. 
Alterar o gráfico estilo quando um botão de opção é selecionada 
Nesta seção, você será criar um evento público sobre o controle de usuário, adicionar uma 
propriedade para definir o tipo de seleção, e criar um manipulador de eventos para o 
CheckedChanged evento de cada um dos botões de opção. 
Para criar um evento e propriedade em um controle de usuário 
1. No Solution Explorer, clique com o botão direito do mouse no controle de usuário e 
selecione View Code. 
2. Adicione código para criar um SelectionChanged evento e a Selection propriedade para a 
ChartOptions classe: 
C# 
public event EventHandler SelectionChanged; 
private Microsoft.Office.Interop.Excel.XlChartType selectedType = 
Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; 
public Microsoft.Office.Interop.Excel.XlChartType Selection 
{ 
 get { return this.selectedType; } 
set { this.selectedType = value; } 
} 
Para manipular o evento CheckedChanged dos botões de opção 
Visual C# Consolidado 98
1. Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão 
areaBlockChart de opção e depois gerar o evento. 
C# 
private void areaBlockChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Excel.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
2. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart 
de opção. 
C# 
private void barChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Excel.XlChartType.xlBarClustered; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
3. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão 
columnChart de opção. 
C# 
private void columnChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; if (this.SelectionChanged != 
null) { this.SelectionChanged(this, EventArgs.Empty); } } } 
4. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart 
de opção. 
C# 
private void lineChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Excel.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
5. Em C#, você deve adicionar manipuladores de eventos para os botões de opção. Adicione 
o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, 
conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
C# 
public ChartOptions() { InitializeComponent(); areaBlockChart.CheckedChanged += new 
EventHandler(areaBlockChart_CheckedChanged); barChart.CheckedChanged += new 
EventHandler(barChart_CheckedChanged); columnChart.CheckedChanged += new 
EventHandler(columnChart_CheckedChanged); lineChart.CheckedChanged += new 
EventHandler(lineChart_CheckedChanged); } 
Adicionar o controle de usuário a planilha 
Quando você cria a solução, o novo controle de usuário é automaticamente adicionado à 
Toolbox. Você pode, então, arrastar o controle da Toolbox. para seu Worksheet 
Para adicionar o controle do usuário sua planilha 
1. No menu Build, clique em Build Solution. 
O ChartOptions controle de usuário é adicionado à Toolbox. 
2. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs. e selecione View DesignerVisual C# Consolidado 99
3. Do Toolbox arraste o ChartOptions controle de para a planilha. 
Um novo controle chamado ChartOptions1 é adicionado ao seu projeto. 
Alterar o tipo de gráfico 
Nesta seção, criar um manipulador de eventos para alterar o tipo de gráfico acordo para a opção 
selecionada no controle de usuário. 
Para alterar o tipo de gráfico que é exibido na planilha 
1. Adicionar o manipulador de eventos a seguir para a Sheet1 classe. 
C# 
private void ChartOptions1_SelectionChanged(object sender, EventArgs e) { try { 
dataChart.ChartType = this.ChartOptions1.Selection; } catch (Exception ex) { 
MessageBox.Show(ex.ToString()); } } 
2. Em C#, adicione um manipulador de eventos para o controle de usuário para o Startup 
evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
C# 
this.ChartOptions1.SelectionChanged += new 
EventHandler(ChartOptions1_SelectionChanged); 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que o gráfico tiver estilo 
corretamente quando você seleciona um botão de opção. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Selecione vários botões de opção. 
3. Confirme que o estilo do gráfico altera para correspondem à seleção. 
Próximas etapas 
Essa explicação passo a passo mostra noções básicas sobre como usar botões de opção e estilos 
do gráfico nas planilhas do Excel 2003. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Usando um botão para preencher uma caixa de texto. Para obter mais informações, 
consulte Exibindo texto em uma caixa de texto em uma planilha usando um botão 
Walkthrough:. 
• Alterar a formatação em uma planilha usando caixas de seleção. Para obter mais 
informações, consulte Alterando planilha formatação usando controles CheckBox 
Walkthrough:. 
 
Vinculação de Dados para controles em um painel Ações do Excel 
Walkthrough: 
Essa explicação passo a passo demonstra vinculação de dados a controles em um painel Ações 
no Microsoft Office Excel 2003. Os controles demonstram uma Relação mestre / detalhes entre 
tabelas em um banco de dados do SQL Server. 
Durante este explicação passo a passo, você aprenderá como: 
Visual C# Consolidado 100
• Adicionar controles a uma planilha. 
• Criar um controle painel Ações. 
• Adicionar controles Windows Forms ligados a dados a um controle painel Ações. 
• Mostrar painel de ações quando abre o aplicativo. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• Microsoft Office Excel 2003. 
Acesso a um servidor com o Exemplo de SQL Server do Northwind. 
• Permissões para ler e gravar no banco de dados do SQL Server. 
Criando o projeto 
A primeira etapa é para criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Actions Pane. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Excel 
Actions Pane projeto para Solution Explorer. 
Adicionar uma nova fonte de dados ao projeto 
Para adicionar uma nova fonte de dados para o projeto 
1. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data 
menu. 
Observação 
Se Show Data Sources clique dentro na planilha do Excel e depois verificar novamente. não 
estiver disponível, 
2. Clique Add New Data Source Para iniciar o Data Source Configuration 
Wizard. 
3. Selecione Database e, em seguida clique em Next. 
Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou 
adicionar uma nova conexão com o New Connection botão. 
4. Clique em Next. 
5. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 
6. Expanda o Tables nó na janela Database objects. 
Visual C# Consolidado 101
7. Marque a caixa de seleção ao lado da Suppliers tabela. 
8. Expandir a Products tabela e selecione ProductName, SupplierID, 
QuantityPerUnit. e UnitPrice 
9. Clique em Finish. 
O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele 
também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. 
Adicionar controles a planilha 
Em seguida, adicione um NamedRange controle e um ListObject controle à primeira planilha. 
Para adicionar um NamedRange e um controle ListObject 
1. Verifique se a My Excel Actions Pane.xls pasta de trabalho é aberta no designer 
visual studio, com Sheet1 exibido. 
2. Na janela Data Sources , expanda a Suppliers tabela. 
3. Clique na seta suspensa no nó Company Name, e selecione NamedRange. 
4. Arraste Company Name a partir da Data Sources janela para na Sheet1 Célula A2. 
Um NamedRange controle denominado CompanyNameNamedRange é criado, e o 
<CompanyName> de texto aparece na célula A2. Ao mesmo tempo, nomeado 
suppliersBindingSource, um adaptador de tabela, e um DataSet são adicionados ao 
projeto. um BindingSource O controle é acoplado que por sua vez está vinculado a 
DataSet instância. o BindingSource, 
5. Na janela Data Sources, role para baixo após as colunas que estão sob a Suppliers 
tabela. Na parte inferior da lista é a Products tabela; ele é aqui porque ele é um filho da 
Suppliers tabela. Selecionar esta Products Tabela, não a um que seja no mesmo nível 
como a Suppliers Tabela, e clique a seta suspensa que aparece. 
6. Clique ListObject na lista drop-down, e arraste a Products tabela para células A6 em 
Sheet1. 
Um ListObject controle denominado ProductNameListObject é criado na célula A6. Ao 
mesmo tempo, e um adaptador de tabela são adicionados ao projeto. nomeado 
productsBindingSource, um BindingSource O controle é acoplado que por sua vez 
está vinculado a DataSet instância. o BindingSource, 
7. No C# somente, selecione suppliersBindingSource No bandeja de componentes, e 
alterar a Modifiers propriedade para Internal na janela Properties. 
Adicionar controles ao painel de ações 
Em seguida, você precisa um controle painel Ações que contenha uma caixa de combinação. 
Para adicionar um controle painel Ações 
1. Selecione o My Excel Actions Pane projeto no Solution Explorer. 
2. No menu Project, selecione Add New Item. 
3. Na caixa Add New Item de diálogo, selecione Actions Pane Control, nomeá-la 
ActionsControl e clique em Add 
Para adicionar controles Windows Forms ligados a dados a um controle 
painel Ações 
1. Das Common Controls guias da Toolbox, arraste um ComboBox controle para o 
controle painel Ações. 
Visual C# Consolidado 102
2. Alterar a Size propriedade para 171, 21. 
3. Redimensionar o controle de usuário para ajustar os controles. 
Vinculando o controle no painel Ações a dados 
Neste seção, você será definir a fonte de dados de à mesma fonte de dados como o 
NamedRange controle em uma planilha.. com a mesma fonte de dados que o NamedRange 
controle em uma planilha o ComboBox o ComboBox 
Para definir propriedades de vinculação de dados do controle 
1. Clique com o botão direito do mouse no controle painel Ações e selecione View Code a 
partir do menu de atalho 
2. Adicione o seguinte código ao evento Load do controle painel Ações: 
C# 
private void ActionsControl_Load(object sender, EventArgs e) { this.comboBox1.DataSource= 
Globals.Sheet1.suppliersBindingSource; this.comboBox1.DisplayMember = "CompanyName"; } 
3. Em C#, você deve criar um manipulador de eventos para o ActionsControl. Você pode 
colocar este código no construtor ActionsControl como mostrado abaixo. Para obter mais 
informações sobre como criar manipuladores de eventos, consulte Como criar 
manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
public ActionsControl() { InitializeComponent(); this.Load += new 
EventHandler(ActionsControl_Load); } 
Mostrando o Painel de Ações 
Você nesta seção, vai escrever código para mostrar o painel Ações. O painel Actions ficará visível 
depois controles são adicionados a ele. 
Para mostrar o painel Ações 
1. Clique com o botão direito do mouse ThisWorkbook.vb no Solution Explorer, ou 
ThisWorkbook.cs,. e, em seguida clique View Code no menu de atalho 
2. Criar uma nova instância do controle do usuário na classe ThisWorkbook, da seguinte 
maneira: 
C# 
ActionsControl actions = new ActionsControl(); 
No manipulador Startup de eventos de ThisWorkbook, adicione código de forma que ele tenha como 
no Exemplo a seguir: 
C# 
private void ThisWorkbook_Startup(object sender, System.EventArgs e) { 
this.ActionsPane.Controls.Add(actions); } 
Testar o aplicativo 
Agora você pode testar seu documento para verificar o painel Ações que é aberto quando o 
documento for aberto. Você testará para a relação mestre / detalhes entre os controles no painel 
de ações e os controles da planilha. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Confirme se o painel Actions está visível. 
Visual C# Consolidado 103
3. Selecione uma empresa na caixa Lista. Verifique se o nome da empresa está listado no 
controle NamedRange e se os detalhes do produto estão listados no ListObject 
controle. 
4. Selecione várias empresas para verificar o nome da empresa e Detalhes do Produto altere 
conforme apropriado. 
Próximas etapas 
Essa explicação passo a passo mostra as noções básicas de vinculação de dados a controles em 
um painel Ações no Excel. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Ligação de dados a controles no Word. Para obter mais informações, consulte Vinculação 
de Dados para controles em um painel Ações do Word Walkthrough:. 
• Mostrar e ocultar controles no painel de ações. Para obter mais informações, consulte 
Alterando o painel de ações de acordo com contexto do usuário Walkthrough: 
 
Implantando um Word ou Solution do Excel usando um manifesto 
Deployment Walkthrough: 
Essa explicação passo a passo demonstra como implantar uma solução o Microsoft Office Excel 
ou Microsoft Office Word em um compartilhamento de rede em um servidor. Será posicionado no 
final do explicação passo a passo, o possível para executar a solução no servidor do seu 
computador de desenvolvimento. 
Em um ambiente de produção, uma Microsoft Visual Studio 2005 Tools for the Microsoft Office 
System solução geralmente é publicada primeiro a um servidor de teste, e depois ele é 
reimplantado em um servidor de produção depois que o departamento de TI aprovar-. Você nessa 
explicação passo a passo, será emular esse processo, publicando uma solução em um local 
temporário no seu computador de desenvolvimento, e então redeploying a solução do local de 
publicação para um servidor. Para obter mais informações sobre as opções para implantar a 
solução, consulte Modelos de implantação. 
Durante este explicação passo a passo, você aprenderá como: 
• Do Publish Wizard uso para publicar sua solução em um local no seu computador de 
desenvolvimento. 
• Manualmente relançamento a solução do seu computador local para um compartilhamento 
de rede em um servidor. 
• Modificar o manifesto do aplicativo que está incorporado no documento para apontar para 
o novo local manifesto de implantação programaticamente. 
• Editar a manifesto de implantação para apontar para a nova localização do manifesto do 
aplicativo externos. 
• Editar o manifesto do aplicativo externo para apontar para o novo local do conjunto e a 
manifesto de implantação. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. 
Observação 
Visual C# Consolidado 104
Essa explicação passo a passo pressupõe que você estiver implantando uma solução Word. Se 
você quiser executar explicação passo a passo com uma solução Excel, o substitua o nome do 
projeto do Word com o nome do seu projeto do Excel em todos os códigos e exemplos XML. 
• Acesso a um servidor de rede para implantação. Essa explicação passo a passo 
pressupõe que você são redeploying sua solução para o \\DeployServer\ShareFolder 
compartilhamento de rede. 
• Privilégios de administrador no computador de desenvolvimento, para que você possa 
definir a diretiva de segurança para um local de rede. 
Criando o projeto 
Nesta etapa, você irá criar um projeto Documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome WordDeployment. Verifique que 
Create a new document está selecionada. Para obter mais informações, consulte Como 
criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o WordDeployment projeto para 
Solution Explorer o Visual Studio. 
Adicionar código para trás o documento 
Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos do 
documento. Isso permitirá que você para verificar se a solução está funcionando quando você 
abre o documento rapidamente. 
Para adicionar uma caixa de mensagem a um evento de inicialização 
1. Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou 
ThisDocument.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisDocument 
classe para mostrar uma caixa de mensagem durante a inicialização. 
C# 
private void ThisDocument_Startup(object sender, System.EventArgs e) { 
MessageBox.Show("The document is deployed correctly."); } 
3. Pressione F5 para executar o projeto. 
Inicia o Word e a caixa de mensagem aparece. 
4. Fechar a caixa de mensagem. 
5. Sair do Word. 
Em seguida, você publicará nesta solução. 
Publicando a solução 
Nesta etapa, você publicará a solução em um local temporário no computador local. 
Para publicar a solução 
1. Clique com o botão direito do mouse o nó de projeto no Solution Explorer. 
2. Clique Publish no menu de atalho. 
O Publish Wizard aparece. 
3. Na caixa Specify the location to publish this application, digite 
C:\TestDeploy. 
4. Clique em Finish. 
Visual C# Consolidado 105
O documento de Solução e manifesto de implantação são copiados para C:\TestDeploy. 
O conjunto de solução, atualizado manifesto do aplicativo, e cópias do documento de 
Solução e manifesto de implantação são copiadas para 
C:\TestDeploy\WordDeployment_1.0.0.0. Para obter mais informações, consulte 
Implantando o Word e Excel Solutions. 
5. Feche o WordDeployment projeto no Visual Studio. 
Observação 
O conjunto não tem permissão para executar ainda, para que ele se você tentar executar a 
solução será lançar um erro. Você irá atualizar sua diretiva de segurança para conceder 
permissão de confiança total ao conjunto em uma etapa posterior. 
Quando você publicar uma solução, o manifesto do aplicativo incorporado no aponta de 
documento de solução para o caminho completo da manifesto de implantação. Se você 
relançamento os arquivos de solução para outro local, deverá atualizar o manifesto do aplicativo 
incorporado para apontar para a nova localização da manifesto de implantação. Você também 
deve atualizar a manifesto de implantação e o manifesto do aplicativo externo para apontar para 
os novos locais de arquivo. 
Atualizando omanifesto Application incorporados 
Para editar o manifesto do aplicativo incorporado, use a ServerDocument classe que Visual Studio 
Tools for Office fornece. Quando você usa a ServerDocument classe, você deve executar o 
código em um novo projeto (não a Visual Studio Tools for Office Solução), como um projeto de 
console, e o Visual Studio Tools for Office documento de solução deve ser fechado. 
Observação 
Inclui Visual Studio Tools for Office um Exemplo que demonstre como criar uma ferramenta que 
pode ser usada para editar o manifesto do aplicativo incorporado. Para obter mais informações, 
consulte Aplicativo Manifest Exemplo Editor. 
Para atualizar o manifesto do aplicativo incorporado 
1. Criar um novo projeto Console Application. 
2. Do Microsoft.VisualStudio.Tools.Applications.Runtime Adicionar referências para e 
System.Windows.Forms montagens para este projeto. 
3. Abra o arquivo Program.cs ou Module1.vb, e adicione a seguinte Imports ou using 
instrução para o topo do arquivo. 
C# 
using Microsoft.VisualStudio.Tools.Applications.Runtime; 
4. Copie o código a seguir para a Main função. Este código cria uma ServerDocument 
que fornece acesso ao manifesto do aplicativo incorporado de seu documento de solução. 
O código atribui o novo caminho manifesto de implantação para a DeployManifestPath 
propriedade, e salva e fecha o ServerDocument.. o ServerDocument 
C# 
ServerDocument sd = null; 
try { sd = new ServerDocument(@"C:\TestDeploy\WordDeployment.doc"); 
sd.AppManifest.DeployManifestPath = 
@"\\DeployServer\ShareFolder\WordDeployment.application"; sd.Save(); } finally { if (sd != 
null) { sd.Close(); } } 
5. Pressione F5 para executar o projeto. 
Visual C# Consolidado 106
Uma janela do console aparece rapidamente enquanto o manifesto do aplicativo 
incorporado está sendo atualizado, e fecha a janela do console. 
Atualizando o manifesto de implantação 
Agora que você atualizou o manifesto do aplicativo incorporado no documento Visual Studio Tools 
for Office de solução, você deve atualizar a manifesto de implantação para apontar para a nova 
localização do manifesto do aplicativo externos. 
Para atualizar a manifesto de implantação 
1. Abra a manifesto de implantação em um editor de texto, como o Bloco de notas. A 
manifesto de implantação é denominado WordDeployment.application, e está 
localizado na pasta C:\TestDeploy de publicação. 
2. Defina o codebase atributo do elemento <dependentAssembly> como o caminho 
completo da localização implantação final do manifesto do aplicativo externos. Para obter 
mais informações, consulte &lt;dependentAssembly&gt; Element (Visual Studio Tools for 
Office Reference).O atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly codebase="\\DeployServer\ShareFolder\ 
WordDeployment_1.0.0.0\WordDeployment.dll.manifest" 
3. Salve e feche o arquivo manifesto de implantação. 
Atualizando o manifesto de aplicativos externos 
Além disso, para atualizar a manifesto de implantação, você também deve editar o manifesto do 
aplicativo externo para apontar para os locais implantação final do conjunto de solução e a 
manifesto de implantação. Sempre que você publicar uma Visual Studio Tools for Office solução, 
um novo manifesto do aplicativo externo é gerado que aponta para a versão atual do conjunto de 
solução. 
Para atualizar o manifesto do aplicativo externo 
1. Abra o manifesto do aplicativo em um editor de texto, como o Bloco de notas. O manifesto 
do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na 
pasta C:\TestDeploy\WordDeployment_1.0.0.0 de publicação. 
2. Localize o <installFrom> elemento que está o filho do elemento <dependency>, e 
defina o codebase atributo como o caminho completo da montagem de solução atual. Para 
obter mais informações, consulte <installFrom> Element (Visual Studio Tools for Office 
Reference).O atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly codebase="\\DeployServer\ShareFolder\ 
WordDeployment_1.0.0.0\WordDeployment.dll" 
3. Localize o <installFrom> elemento que está o filho do elemento <assembly>, e defina o 
codebase atributo para o caminho completo do manifesto de implantação. Para obter mais 
informações, consulte <installFrom> Element (Visual Studio Tools for Office Reference).O 
atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly 
codebase="\\DeployServer\ShareFolder\WordDeployment.application" 
4. Salve e feche o arquivo manifesto do aplicativo. 
Copiando os arquivos da solução para o servidor 
Agora que você tiver editado os manifestos, você está pronto para copiar os arquivos de solução 
para o servidor. 
Para copiar os arquivos de solução para o servidor 
1. Crie uma WordDeployment_1.0.0.0 pasta sob a 
\\DeployServer\ShareFolder compartilhamento de arquivos de rede. 
Visual C# Consolidado 107
2. Copiar o documento de Solução e a manifesto de implantação para 
\\DeployServer\ShareFolder. 
3. Copiar o conjunto de solução e o manifesto do aplicativo para 
\\DeployServer\ShareFolder\WordDeployment_1.0.0.0. 
Conceder confiança total para a pasta de rede 
Para execute sua Visual Studio Tools for Office solução a partir da pasta de rede, você deve 
conceder confiança total para a pasta de rede na sua diretiva de segurança no computador de 
desenvolvimento. Você pode modificar a diretiva de segurança de um prompt de comando usando 
a ferramenta Diretiva de Segurança para Acesso ao Código (Caspol.exe). Para conceder 
confiança para um local de rede, você deve ter privilégios de administrador e você deverá alterar a 
diretiva de segurança no nível do computador. 
Observação 
Este procedimento é destinado a fim de executar essa explicação passo a passo. Não use este 
procedimento para conceder confiança a conjuntos ou diretórios se não tiver certeza que sejam 
segura e protegida. Para obter mais informações sobre concessão e remover permissões, 
consulte HOW TO: conceder permissões para pastas e montagens e Como remover permissões 
de pastas e montagens:. 
Para conceder confiança total para a pasta de rede 
• Digite o seguinte comando no prompt de comando Studio visual: 
caspol -m -ag LocalIntranet_Zone -url \\DeployServer\ShareFolder\* FullTrust -n "Remote 
Deployment" -d "Deployment Walkthrough" 
Testando a solução 
Agora você pode testar sua solução para certificar-se que seu código seja executado quando você 
abre o documento a partir do computador de desenvolvimento. 
Para testar a implantação 
1. No computador de desenvolvimento, abra o WordDeployment.doc arquivo no 
\\DeployServer\ShareFolder\. 
2. Confirme se a caixa de mensagem aparece. 
Próximas etapas 
Você também pode implantar a solução usando um arquivo do Microsoft Windows Installer (.msi). 
Para obter mais informações, consulte Implantando um Word ou Solution do Excel usando um 
arquivo do Windows Installer Walkthrough:. 
 
Implantando um Word ou Solution do Excel usando um arquivo do 
Windows Installer Walkthrough: 
Essa explicação passo a passo demonstra como criar um arquivo do Microsoft Windows Installer 
(.msi) que pode ser usado para implantar uma solução Microsoft Office Excel 2003 ou Microsoft 
Office Word 2003. 
Durante este explicação passo a passo, você aprenderá como: 
• Criar um projeto de instalação que você pode usar para criar um arquivo do Windows 
Installer. 
• Modifique o projeto de instalação para que o arquivo Windows Installer instala sua 
Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução. 
Visual C# Consolidado 108
• Adicionar uma etapa para o projeto de instalação para que Arquivo do Windows Installer 
edita o manifesto do aplicativo incorporados no Visual Studio Tools for Office documento de 
solução. 
Essa explicação passo a passo pressupõe que o computador de destino já tiver os pré-requisitos 
instalados para executar Visual Studio Tools for Office soluções. Você cria o arquivo Windows 
Installer nãoo verificar ou instalar esses pré-requisitos. Para obter mais informações sobre os pré-
requisitos para executar Visual Studio Tools for Office soluções, consulte Como se preparar 
computadores de usuário final para executar soluções do Office:. 
Observação 
Conjuntos em Visual Studio Tools for Office Soluções devem ser concede confiança total na 
diretiva de segurança do usuário final antes da solução seja executado. O arquivo Windows 
Installer você criar nessa explicação passo a passo não Não implantar a diretiva de segurança 
necessário para executar a solução. Para obter mais informações sobre segurança em Visual 
Studio Tools for Office soluções, consulte Requisitos de segurança para executar soluções do 
Office e Práticas recomendadas para segurança no Office Solutions. Para obter informações 
sobre como configurar a diretiva de segurança por usuário final computadores, consulte 
Implantação de diretiva de segurança. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. 
Observação 
Essa explicação passo a passo inclui etapas para criar uma solução simples que você pode usar 
em explicação passo a passo o Excel. Se você deseja executar o explicação passo a passo com 
uma solução Word ou Excel existente, começarão o explicação passo a passo no título criando o 
Project a instalação, " " e certifique-se substituir o nome ExcelDeployment do projeto com o 
nome do seu projeto em todos os exemplos de código e instruções. 
Criando o projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o 
ExcelDeployment projeto para Solution Explorer. 
Adicionar código para trás a pasta de trabalho 
Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos da 
pasta de trabalho. Isso permite que você para verificar se a solução está funcionando quando 
você abre o documento rapidamente. 
Para adicionar uma caixa de mensagem a um evento de inicialização 
1. Clique com o botão direito do mouse ThisWorkbook.vb no Solution Explorer, ou 
ThisWorkbook.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisWorkbook 
classe para mostrar uma caixa de mensagem durante a inicialização. 
C# 
Visual C# Consolidado 109
private void ThisWorkbook_Startup(object sender, System.EventArgs e) { 
MessageBox.Show("The workbook is deployed successfully."); } 
3. Pressione F5 para executar o projeto. 
O Excel é iniciado e aparecerá a caixa de mensagem. 
4. Fechar a caixa de mensagem. 
5. Saia do Excel. 
Em seguida, você adicionará um projeto de instalação para sua solução. 
Criar um projeto de instalação 
Nesta etapa, você irá criar um projeto de instalação que você pode compilar para criar um arquivo 
do Windows Installer para sua solução. Para obter mais informações, consulte Configurar projetos. 
Para criar um projeto de instalação para a solução 
1. Clique com o botão direito do mouse no nó na Solution Explorer solução. 
2. Aponte para Add no menu de atalho, e clique em New Project. 
A Add New Project caixa de diálogo será exibida. 
3. No painel Project types, expanda Other Project types e selecione Setup and 
Deployment. 
4. No painel Templates, selecione Setup project. 
5. Nome do projeto ExcelSetup. 
6. Clique em OK. 
O projeto instalação aparece no Solution Explorer. Por padrão, o arquivo que você irá 
criar usando este projeto instalação Windows Installer inclui uma caixa de diálogo que 
permite ao usuário final que especifique o local de instalação da solução. Para obter mais 
informações, consulte Caixa de diálogo interface do usuário da pasta de instalação. 
Adicionar o pasta de trabalho e assembly da solução para o Project da instalação 
Nesta etapa, você adicionará a saída do projeto ExcelDeployment principal para o projeto de 
instalação. A saída do projeto ExcelDeployment principal consiste de pasta de trabalho e o 
conjunto de solução. 
Para adicionar o documento e conjunto ao projeto de instalação 
1. Clique com o botão direito do mouse no ExcelSetup project nó em Solution 
Explorer. 
2. Selecione View no menu de atalho, e depois clique em File System. 
3. Clique com o botão direito do mouse Application Folder no painel esquerdo. 
4. Aponte para Add no menu de atalho, e clique em Project Output. 
5. Selecione ExcelDeployment na caixa Project. 
6. Selecione Primary output na lista de tipos de saída. 
7. Clique em OK. 
A saída do projeto e dependências aparecem no painel direito. 
8. No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó 
de projeto. 
9. Clique com botão direito mouse cada dependência, exceto para Microsoft .NET 
Framework, e clique Exclude no menu de atalho. 
Visual C# Consolidado 110
Criar um projeto de ação personalizada 
Nesta etapa, você irá criar um projeto que contém ações personalizadas para o projeto de 
instalação. Ações personalizadas são um recurso do Windows Installer que permitem a você para 
executar código no final de uma instalação para executar ações que não podem ser executadas 
durante a instalação. Para obter mais informações, consulte Ações Personalizadas. 
Para criar um projeto ação personalizada 
1. Clique com o botão direito do mouse no nó na Solution Explorer solução. 
2. Aponte para Add no menu de atalho, e clique em New Project. 
A Add New Project caixa de diálogo será exibida. 
3. No painel Project types, expanda o nó para a linguagem de programação, e selecione 
Windows. 
4. No painel Templates, selecione Class Library. 
5. Nome do projeto ExcelCustomAction. 
6. Clique em OK. 
O novo projeto aparece na Solution Explorer. 
7. No Solution Explorer, clique com o botão direito do mouse Class1.vb ou Class1.cs sob 
o ExcelCustomAction projeto e, em seguida, clique em Delete. Este arquivo é 
desnecessário para essa explicação passo a passo. 
Criar uma ação personalizada que salvas o manifesto de aplicativo 
Quando você executava seu projeto anteriormente nessa explicação passo a passo pelo 
pressionamento F5, a processo de criação editado o manifesto do aplicativo incorporado na pasta 
de trabalho para aponte para o caminho relativo do conjunto. Se a pasta de trabalho e o conjunto 
permanecer na mesma pasta após a instalação, então você não precisam modificar o manifesto 
do aplicativo incorporado, e você pode ignorar esta seção. No entanto, se você quiser que o 
usuário possa mover a pasta de trabalho para uma pasta diferente após a instalação, você deve 
editar o manifesto do aplicativo para apontar para o caminho completo da montagem. 
Você deve atualizar o manifesto do aplicativo que está incorporado no Visual Studio Tools for 
Office documento de Solução ao executar uma ação personalizada após a instalação, porque o 
local do conjunto de solução é desconhecido até que o usuário especifica o local durante a 
instalação. Editar o manifesto do aplicativo incorporado, usando a ServerDocument classe. Para 
usar a ServerDocument classe no projeto de instalação, adicione código para uma Installer 
classe dentro do projeto ação personalizada. 
Para criar uma ação personalizada que edita o manifesto do aplicativo 
1. Clique com o ExcelCustomAction projeto no Solution Explorer. 
2. Aponte para Add no menu de atalho, e clique em New Item. 
A Add New Item caixa de diálogo será exibida. 
3. Selecionar Installer Class, e nome da classe ManifestEditor. 
4. Adicione uma referência ao conjunto Microsoft.VisualStudio.Tools.Applications.Runtime 
para o ExcelCustomAction projeto. 
5. Do ManifestEditor.cs cliquecom o botão direito do mouse no Solution Explorer, 
ou ManifestEditor.vb arquivo e clique em View Code. 
6. Adicione a instrução seguinte Imports ou using para o topo do arquivo de código. 
C# 
using Microsoft.VisualStudio.Tools.Applications.Runtime; 
Visual C# Consolidado 111
7. Copie o código a seguir para a ManifestEditor classe. 
Esse código substitui o Install método, que é usado para executar ações Instalação 
personalizada. O código define o local de instalação especificado pelo usuário para a 
AssemblyPath propriedade. O caminho de instalação especificado pelo usuário e os nomes 
do documento e conjunto são obtidas a partir da Parameters propriedade. 
C# 
// Override the Install method to update the customization location 
// in the application manifest. 
public override void Install(System.Collections.IDictionary stateSaver) { 
UpdateApplicationManifest(); 
base.Install(stateSaver); } 
// Update the application manifest according to the the install location. private void 
UpdateApplicationManifest() 
{ // Get the parameters passed to the task. string targetDir = 
this.Context.Parameters["targetdir"]; 
string documentName = this.Context.Parameters["documentname"]; 
string assemblyName = this.Context.Parameters["assemblyname"]; 
// Get the application manifest from the document. 
string documentPath = System.IO.Path.Combine(targetDir, documentName); ServerDocument 
serverDocument1 = new ServerDocument(documentPath, System.IO.FileAccess.ReadWrite); 
try { AppManifest appManifest1 = serverDocument1.AppManifest; 
string assemblyPath = System.IO.Path.Combine(targetDir, assemblyName); 
appManifest1.Dependency.AssemblyPath = assemblyPath; serverDocument1.Save(); } finally 
{ if (serverDocument1 != null) 
{ serverDocument1.Close(); } } } 
8. Clique com o ExcelCustomAction projeto no Solution Explorer, e, em seguida 
clique em Build. 
Adicionando a ação personalizada ao projeto de instalação 
Nesta etapa, você adicionará a saída do projeto ExcelCustomAction principal para o projeto 
de instalação. Isso permite que o arquivo Windows Installer para executar a ação personalizada 
que edita o manifesto do aplicativo. 
Para adicionar a saída primária do projeto ação personalizada ao projeto 
de instalação 
1. Clique com o botão direito do mouse no ExcelSetup project nó em Solution 
Explorer. 
2. Aponte para View no menu de atalho, e clique em Custom Actions. 
3. O Custom Actions Editor, clique com botão direito no nó e Install Clique em Add 
Custom Action. 
4. Na caixa Look In Selecionar Application Folder, e clique em Add Output 
5. Selecione ExcelCustomAction na caixa Project. 
6. Selecione Primary output na lista de tipos de saída, e depois clique em OK. 
7. Verifique que Primary output from ExcelCustomAction (Active) foi adicionado 
à lista de saídas primária para o projeto de instalação e clique em OK 
Visual C# Consolidado 112
8. Em expandir Install. o Custom Actions Editor, 
9. Clique com o botão direito do mouse Primary output from ExcelCustomAction 
(Active) e, em seguida clique em Properties Window. 
10. Na janela Properties, defina a CustomActionData propriedade para a seguinte 
seqüência: 
/targetdir="[TARGETDIR]/" /documentname="ExcelDeployment.xls" 
/assemblyname="ExcelDeployment.dll" 
Para obter informações sobre a CustomActionData propriedade, consulte Propriedade 
CustomActionData. 
11. Clique com o botão direito do mouse e, em seguida clique em Build. Em Solution 
Explorer, o ExcelSetup project 
Teste a instalação 
Agora você pode testar a solução para garantir que sua solução é instalada quando você executar 
o arquivo do Windows Installer no seu computador de desenvolvimento. 
Para testar a instalação 
1. Clique com o botão direito do mouse e, em seguida clique em Run. Em Solution 
Explorer, o ExcelSetup project 
2. Siga as instruções no Assistente de Instalação, e especificar uma pasta de instalação no 
seu computador de desenvolvimento. 
3. Abrir a pasta de trabalho do Excel a partir da pasta de instalação. 
4. Confirme se a caixa de mensagem aparece. 
 
Passo-a-passo: Concedendo e removendo permissões para uma solução 
do Office 
Essa explicação passo a passo demonstra as noções básicas de segurança no Microsoft Visual 
Studio 2005 Tools for the Microsoft Office System. 
Durante este explicação passo a passo, você aprenderá como: 
• Remova a configuração de segurança padrão. 
• Adicionar um novo conjunto de permissões. 
• Testar seu projeto. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• Microsoft Office Excel 2003. 
Criando o projeto 
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel. 
Para criar um novo projeto 
• Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
Visual C# Consolidado 113
O Visual Studio abre a nova pasta de trabalho do Excel no designer e adiciona o My Security 
Test projeto para Solution Explorer. 
Adicionar código para trás a planilha 
Nesta etapa, você adicionará uma caixa de mensagem a um evento de inicialização da planilha. 
Para adicionar uma caixa de mensagem a um evento de inicialização 
1. Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual 
studio, com Sheet1 exibido. 
2. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou 
Sheet1.cs,. e, em seguida clique View Code no menu de atalho 
3. Adicione o seguinte código para o Startup método dentro classe Sheet1 para mostrar uma 
caixa de mensagem durante a inicialização. 
C# 
private void Sheet1_Startup(object sender, System.EventArgs e) { MessageBox.Show("Security 
settings are correct."); } 
4. No menu File, clique em Save All. 
5. Na caixa Save Project de diálogo, digite C:\Walkthroughs na caixa Location. 
6. Clique em Save. 
7. Pressione F5 para executar o projeto. 
O Excel é iniciado e aparecerá a caixa de mensagem. 
8. Fechar a caixa de mensagem. 
9. Feche o Excel. 
10. No designer do Visual Studio, localize e selecione na guia para My Security Test.xls. 
11. Feche My Security Test.xls (a superfície do design de planilha Excel) no designer do 
Visual Studio. 
Feche todos os instâncias do Excel antes de alterar a diretiva de segurança. 
Quando você criado o projeto de pasta de trabalho do Excel, o assistente adicionado um novo 
grupo de código de segurança e um grupo de códigos filho à diretiva de segurança Runtime no 
nível do usuário. 
Em seguida, você removerá o grupo de códigos que criou o assistente. 
Remover o grupo de códigos padrão 
Localize e remova o grupo de código padrão que foi criado. 
Para remover um grupo de códigos 
1. No Painel de Controle, abra Administrative Tools. 
2. Executar Microsoft .NET Framework 2.0 Configuration. 
3. No modo de exibição de árvore no lado esquerdo, expanda .NET Framework 2.0 
Configuration,, expandir Runtime Security Policy, expandir User, expandir Code 
Groups, Expandido All_Code e My Computer expanda VSTOProjects. 
Não é um GUID para cada projeto tenha criado. Expanda cada GUID para ver o caminho 
para o documento associado. 
4. Clique com o botão direito do mouse o GUID de C:\Walkthroughs\My Security 
Test\My Security Test\bin\My Security Test.xls grupo de códigos, e, em 
seguida clique Delete no menu de atalho. 
Visual C# Consolidado 114
Será exibida uma caixa de diálogo perguntando se você tiver certeza que deseja excluir 
este grupo de códigos. 
5. Clique em Yes. 
6. Voltar para Visual Studio, e pressione F5 para executar o projeto meu teste de segurança. 
Será exibida informando a atual política de segurança .NET permite que não não que a 
personalização para executar uma mensagem de erro. 
7. Clique em OK. 
8. Feche o Excel. 
O conjunto não pode ser executado se ele não tiver permissão explícita na Diretivade Segurança 
Microsoft .NET. 
Em seguida, conceda permissão para o conjunto usando um nome forte em vez de uma URL para 
prova. 
Dando um nome de alta segurança para o conjunto 
Um nome forte é geralmente mais seguro que uma URL como prova. Será criar e atribuir um 
nome forte o conjunto nas próximas etapas. 
Para criar um nome forte 
1. No menu Project no Visual Studio, clique em My Security Test Properties. 
2. Clique na Signing guia. 
3. Selecione Sign the assembly. 
4. No, o Choose a strong name key file list clique New. 
5. Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa 
Key file name. 
6. Desmarque a Protect my key file with a password caixa de seleção. 
7. Clique em OK. 
O arquivo SecurityTestKey.snk de chave aparece no Solution Explorer. 
8. No menu Build, clique em Build Solution Para criar o conjunto contra o par de chaves 
nome forte. 
Conceder confiança com base no nome de alta segurança 
Agora adicionar um novo grupo de código para conceder confiança total para o conjunto com base 
no nome forte. 
Para conceder confiança com base em nome forte 
1. Abra Microsoft .NET Framework 2.0 Configuration novamente. 
2. Clique com o botão direito do mouse no VSTOProjects nó e clique New no menu de 
atalho 
3. Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique 
em Next. 
4. Na lista Choose the condition type for this code group, clique Strong Name. 
5. Clique em Import. 
6. Procure C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança Test\bin\My 
para Visual Basic ou C:\Walkthroughs\My segurança Test\My segurança Test.dll segurança 
Test\bin\debug\My no C#, e clique em Open. 
Visual C# Consolidado 115
7. Clique em Next. 
8. Clique Next para aceitar o FullTrust conjunto de permissões e clique em Finish. 
9. Fechar Microsoft .NET Framework 2.0 Configuration. 
Testar o aplicativo 
Agora você pode testar sua pasta de trabalho para certificar-se que seu código seja executado 
quando a pasta de trabalho é aberta. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Confirme se a caixa de mensagem aparece. 
 
Visual C# Consolidado 116
O WORD USANDO EXPLICAÇÕES 
PASSO-A-PASSO 
Walkthroughs fornecem instruções passo a passo para cenários comuns e são um bom lugar para 
começar aprendendo sobre Microsoft Visual Studio 2005 Tools for the Microsoft Office System. 
As orientações a seguir demonstram formas você pode usar as ferramentas do Microsoft Office 
2003 para automatizar projetos Microsoft Office Word 2003, para implantar suas soluções, e para 
definir a segurança. 
Walkthrough: Changing Document formatação usando controles 
CheckBox 
Essa explicação passo a passo demonstra os fundamentos básicos do uso controles em um 
documento do Microsoft Office Word 2003 para alterar a formatação de texto. Você usará 
Microsoft Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao 
seu projeto. Para ver o resultado como uma amostra completa, consulte Exemplo de controles do 
Word. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicione texto e um controle a um documento. 
• Formate o texto quando uma opção é selecionada. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Microsoft Office Word 2003. 
Criando o projeto 
Neste procedimento, você irá criar projeto usando Visual Studio Tools for Office um documento do 
Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Word Formatting. Verifique 
que Create a new document está selecionada. Para obter mais informações, consulte 
Como criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Word Formatting projeto 
para Solution Explorer o Visual Studio. 
Adicionar texto e controles ao documento do Word 
Para essa explicação passo a passo, você precisará três caixas de seleção e algum texto em um 
Bookmark controle no documento do Word. 
Visual C# Consolidado 117
Para adicionar três caixas de seleção 
1. Verifique se o documento está aberto no designer visual studio. 
2. Na Common Controls guia e arraste-o para o documento. da Toolbox, arraste um 
CheckBox 
3. No menu View, selecione Properties Window. 
4. Certifique-se de que que Checkbox1 esteja visível na caixa de listagem Nome de objeto 
da janela Properties, e altere as propriedades a seguir: 
Propriedade Value (Valor) 
Name applyBoldFont 
Text Negrito 
5. Pressione Enter para mover o ponto de inserção abaixo da primeira caixa de seleção. 
6. Adicionar uma segunda caixa de seleção para o documento abaixo da ApplyBoldFont 
caixa de seleção e alterar as propriedades a seguir: 
Propriedade Value (Valor) 
Name applyItalicFont 
Text Itálico 
7. Pressione Enter para mover o ponto de inserção abaixo da segunda caixa de seleção. 
8. Adicionar uma caixa de seleção terceira para o documento abaixo da ApplyItalicFont 
caixa de seleção e alterar as propriedades a seguir: 
Propriedade Value (Valor) 
Name applyUnderlineFont 
Text Sublinhado 
9. Você em seguida, será arrastar o Bookmark controle para o documento. 
Observação 
Você também pode adicionar o Bookmark controle usando a Bookmark caixa de diálogo, 
encontrada no menu Insert. 
Para adicionar texto e um controle indicador 
1. Mover o ponto de inserção abaixo os controles caixa de seleção e digite o seguinte texto 
no documento: 
Clique em uma caixa de seleção para alterar a formatação de texto. 
2. Na guia Word Controls na Toolbox, arraste um Bookmark controle para o 
documento. 
A Add Bookmark Control caixa de diálogo será exibida. 
3. Selecione o texto é adicionado ao documento e clique em OK. 
Um Bookmark controle denominado Bookmark1 é adicionado ao texto selecionado no 
documento. 
4. Certifique-se de que que Bookmark1 esteja visível na caixa de listagem Nome de objeto 
da janela Properties, e alterar a propriedade Nome para fontText. 
Visual C# Consolidado 118
Em seguida, escreva o código para formatar o texto quando uma caixa de seleção é marcada ou 
desmarcada. 
Formatação a caixa de texto quando a verificação é checked ou Cleared 
Quando o usuário seleciona uma opção de formatação, alterar o formato do texto no documento. 
Para alterar a formatação quando uma caixa de seleção é marcada 
1. Clique com o botão direito do mouse ThisDocument no Solution Explorer, e, em 
seguida clique View Code no menu de atalho. 
2. No C# somente, adicionar as constantes a seguir para a ThisDocument classe: 
C# 
Copiar Código 
const int WordTrue = -1; const int WordFalse = 0; 
3. Adicione o seguinte código ao manipulador Click de eventos da caixa applyBoldFont de 
seleção: 
C# 
private void applyBoldFont_Click(object sender, System.EventArgs e) { if 
(this.applyBoldFont.Checked == true) { this.fontText.Bold = WordTrue; } else { 
this.fontText.Bold = WordFalse; } } 
4. Adicione o seguinte código ao manipulador Click de eventos da caixa applyItalicFont de 
seleção: 
C# 
private void applyItalicFont_Click(object sender, System.EventArgs e) { if 
(this.applyItalicFont.Checked == true) { this.fontText.Italic = WordTrue; } else { 
this.fontText.Italic = WordFalse; } } 
5. Adicione o seguinte código ao manipulador Click de eventos da caixa 
applyUnderlineFont de seleção: 
C# 
private void applyUnderlineFont_Click(object sender, System.EventArgs e) { if 
(this.applyUnderlineFont.Checked == true) { this.fontText.Underline = 
Word.WdUnderline.wdUnderlineSingle; } else { this.fontText.Underline = 
Word.WdUnderline.wdUnderlineNone;} } 
6. Em C#, adicione manipuladores de eventos para as caixas de texto para o Startup evento 
como mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
C# 
this.applyBoldFont.Click += new EventHandler(applyBoldFont_Click); 
this.applyItalicFont.Click += new EventHandler(applyItalicFont_Click); 
this.applyUnderlineFont.Click += new EventHandler(applyUnderlineFont_Click); 
Testar o aplicativo 
Agora você pode testar seu documento para certificar-se que o texto está formatado corretamente 
quando você marca ou desmarca uma caixa de seleção. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Marque ou desmarque uma caixa de seleção. 
Visual C# Consolidado 119
3. Confirme que o texto está formatado corretamente. 
Próximas etapas 
Essa explicação passo a passo mostra as noções básicas de usando caixas de seleção e 
programaticamente alterar texto formatação em documentos do Word. Aqui estão algumas tarefas 
que podem vie em seguida: 
• Implantação do projeto. Para obter mais informações, consulte Como: Implantar arquivos 
de solução usando o Publish Wizard. 
• Usando um botão para preencher uma caixa de texto. Para obter mais informações, 
consulte Exibindo texto em uma caixa de texto em um documento usando um botão 
Walkthrough:. 
Exibindo texto em uma caixa de texto em um documento usando 
um botão Walkthrough: 
Essa explicação passo a passo demonstra noções básicas de usando botões e caixas de texto em 
documentos do Microsoft Office Word 2003,, bem como usar Microsoft Visual Studio 2005 Tools 
for the Microsoft Office System para criar um projeto. Durante este explicação passo a passo, 
você aprenderá como: 
• Adicionar controles ao documento do Word. 
• Preencher uma caixa de texto quando um botão é clicado. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Microsoft Office Word 2003. 
Criando o projeto 
Nesta etapa, você irá criar projeto usando Visual Studio Tools for Office um documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Word Button. Verifique que 
Create a new document está selecionada. Para obter mais informações, consulte Como 
criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Word Button projeto para 
Solution Explorer o Visual Studio. 
Adicionar controles ao documento do Word 
Nesta seção, você adicionará um botão e uma caixa de texto para o documento Word. 
Para adicionar um botão e uma caixa de texto 
1. Verifique se o documento está aberto no designer visual studio. 
2. Na guia Common Controls da Toolbox, arraste um TextBox controle para o 
documento. 
Visual C# Consolidado 120
Observação 
No Word, controles são ignorados na linha com texto por padrão. Você pode modificar, controles 
forma, bem como objetos forma, são inseridos na guia Edit da caixa Options de diálogo. 
3. No menu View, selecione Properties Window. 
4. Certifique-que TextBox1 está visível na caixa Properties drop-down janela e alterar a 
Name propriedade da caixa de texto para displayText. 
5. Arraste um Button controle para o documento e alterar as seguintes propriedades: 
Propriedade Value (Valor) 
Name insertText 
Text Inserir texto 
Agora Escreva o código a ser executado quando o botão é clicado. 
Preencher a caixa de texto quando o botão É Clicked 
Sempre que o usuário clica no botão, Hello World! é acrescentada à caixa de texto. 
Para escrever para a caixa de texto quando o botão é clicado 
1. Na Solution Explorer, clique com o botão direito do mouse ThisDocument e, em 
seguida clique View Code no menu de atalho. 
2. Adicione o seguinte código ao manipulador Click de eventos do botão: 
C# 
private void insertText_Click(object sender, EventArgs e) { this.displayText.Text += "Hello 
World!"; } 
3. Em C#, adicione um manipulador de eventos para o botão para o Startup evento como 
mostrado abaixo. Para obter informações sobre como criar manipuladores de eventos, 
consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
this.insertText.Click += new EventHandler(insertText_Click); 
Testar o aplicativo 
Agora você pode testar seu documento para certificar-se que a mensagem Hello World! 
aparece na caixa de texto quando você clica no botão. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Clique no botão. 
3. Confirme que Hello World! aparece na caixa de texto. 
Próximas etapas 
Essa explicação passo a passo mostra os fundamentos básicos do uso botões e caixas de texto 
em documentos do Word. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como: Implantar arquivos de 
solução usando o Publish Wizard. 
• Usando uma caixa de combinação para alterar a formatação. Para obter mais informações, 
consulte Walkthrough: Changing Document formatação usando controles CheckBox. 
Visual C# Consolidado 121
Walkthrough: Criando menus de atalho para indicadores 
Essa explicação passo a passo demonstra a criação de menus de atalho para Bookmark 
controles. Você irá escrever código no evento BeforeRightClick do indicador para que quando o 
usuário clica com o botão direito do mouse o texto dentro do indicador, um menu de atalho 
contendo itens de menu para formatar o texto apareça. 
Durante este explicação passo a passo, você aprenderá como: 
• Criar um menu de atalho. 
• Escrever código para responder a com o botão direito do mouse texto em um indicador. 
• Verifique se há sobreposição indicadores. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• O Microsoft Office Word 2003. 
Criando o projeto 
Nesta etapa, você irá criar um projeto Documento do Word no Visual Studio. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Bookmark Shortcut Menu. 
Verifique que Create a new document está selecionada. Para obter mais informações, 
consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Bookmark Shortcut Menu 
projeto para Solution Explorer o Visual Studio. 
Adicionar texto e indicadores ao documento 
Nesta etapa, você será adicionar texto ao seu documento do Word e depois adicionar dois 
indicadores. 
Para adicionar texto ao seu documento 
• Digite o seguinte texto em um documento do Word: 
Este é um Exemplo de criar um menu de atalho quando você clica com o 
botão direito do mouse texto em um indicador. 
Para adicionar um controle indicador ao seu documento 
1. Na guia Word Controls da Toolbox, arraste um Bookmark controle para o 
documento. 
A Add Bookmark Control caixa de diálogo será exibida. 
2. Selecione as palavras creating a shortcut menu when you right-click the 
text no seu documento e clique em OK. 
é bookmark1 adicionado ao documento. 
Visual C# Consolidado 122
3. Adicionar outro Bookmark controle com as palavras right-click the text in a 
bookmark. 
é bookmark2 adicionado ao documento.Observação 
As palavras right-click the text aparecerão no bookmark1 e bookmark2. 
Quando você adicionar indicadores aos seus documentos Office Word 2003 no tempo de criação, 
um Bookmark controle é criado que permite a você para programa contra vários eventos do 
indicador. Você pode escrever código no evento BeforeRightClick do indicador para que 
quando o usuário clica com o botão direito do mouse o texto dentro do indicador, um menu de 
atalho contendo itens de menu apareça. 
Criando o menu curto 
Para criar o menu de atalho 
1. No Solution Explorer, clique com o botão direito do mouse ThisDocument e 
selecione View Code. 
2. Declarar as CommandBar variáveis e uma variável do indicador no nível de classe: 
C# 
private Office.CommandBar commandBar; private Office.CommandBarButton boldText; private 
Office.CommandBarButton italicText; private Microsoft.Office.Tools.Word.Bookmark 
selectedBookmark; const int WordTrue = -1; const int WordFalse = 0; 
3. Adicionar um método para criar o menu: 
C# 
private void AddPopUp() { commandBar = Application.CommandBars.Add("FormatText", 
Office.MsoBarPosition.msoBarPopup, missing, true); // Add a button and set the style, caption, 
icon and tag. boldText = (Office.CommandBarButton)commandBar.Controls.Add(1, missing, 
missing, missing, missing); boldText.Style = Office.MsoButtonStyle.msoButtonCaption; 
boldText.Caption = "Bold"; boldText.FaceId = 113; boldText.Tag = "0"; // Add a button and set 
the style, caption, icon and tag. italicText = 
(Office.CommandBarButton)commandBar.Controls.Add(1, missing, missing, missing, missing); 
italicText.Style = Office.MsoButtonStyle.msoButtonCaption; italicText.Caption = "Italic"; 
italicText.FaceId = 114; italicText.Tag = "1"; // Handle the click events with the ButtonClick 
procedure. boldText.Click += new Microsoft.Office.Core 
._CommandBarButtonEvents_ClickEventHandler(ButtonClick); italicText.Click += new 
Microsoft.Office.Core ._CommandBarButtonEvents_ClickEventHandler(ButtonClick); } 
4. Chamada AddPopup a partir do Startup evento de ThisDocument: 
C# 
private void ThisDocument_Startup(object sender, System.EventArgs e) { AddPopUp(); } 
Para formatar o texto contido no indicador 
1. Adicionar um ButtonClick manipulador de eventos para aplicar formatação para o 
indicador. 
C# 
private void ButtonClick(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool 
CancelDefault) { if (Ctrl.Caption == "Bold") { if (selectedBookmark.Bold == WordTrue) { 
selectedBookmark.Bold = WordFalse; } else { selectedBookmark.Bold = WordTrue; } } else if 
(Ctrl.Caption == "Italic") { if (selectedBookmark.Italic == WordTrue) { selectedBookmark.Italic 
= WordFalse; } else { selectedBookmark.Italic = WordTrue; } } } 
Visual C# Consolidado 123
2. Adicionar um showPopupMenu manipulador de eventos para manipular o 
BeforeRightClick evento de dois indicadores: 
Observação 
Você deve escrever código para manipular o caso em que se sobrepõem indicadores. Se você 
não fizer isso, por padrão, o código se chamará para cada indicador dentro da seleção. 
C# 
private void showPopupMenu(object sender, Microsoft.Office.Tools.Word.ClickEventArgs e) { int 
startPosition = 0; // If bookmarks overlap, get bookmark closest to cursor. for (int i = 1; i <= 
e.Selection.Bookmarks.Count; i++) { object o = i; if (e.Selection.Bookmarks.get_Item(ref o).Start > 
startPosition) { startPosition = e.Selection.Bookmarks.get_Item(ref o).Start; } } // If closest 
bookmark is the sender, show the popup. if (((Word.Bookmark)sender).Start == startPosition) { 
selectedBookmark = (Microsoft.Office.Tools.Word.Bookmark)sender; 
commandBar.ShowPopup(missing, missing); e.Cancel = true; } } 
3. Em C#, você deve adicionar manipuladores de eventos para os controles do indicador ao 
Startup evento como mostrado abaixo. Para obter informações sobre como criar 
manipuladores de eventos, consulte Como criar manipuladores de eventos em Ferramentas 
do Visual Studio do Office:. 
C# 
this.bookmark1.BeforeRightClick += new Microsoft.Office.Tools.Word. 
ClickEventHandler(showPopupMenu); this.bookmark2.BeforeRightClick += new 
Microsoft.Office.Tools.Word. ClickEventHandler(showPopupMenu); 
Testar o aplicativo 
Nesta seção, você irá testar seu documento para certificar-se de que os itens de menu negrito e 
itálico apareçam no menu de atalho quando clicar com o botão direito do mouse texto em um 
indicador e o texto que está formatado corretamente. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Clique com o botão direito do mouse dentro do indicador e selecione Bold primeiro. 
3. Verificar se todos os o texto no bookmark1 é formatados como negrito. 
4. Clique com o botão direito do mouse dentro do texto dos indicadores sobrepostos e 
selecione Italic. 
5. Verificar se todos os o texto no bookmark2, mas somente essa parte do texto em 
bookmark1 que se sobreponha bookmark2 é formatados como itálico. 
Próximas etapas 
Essa explicação passo a passo mostra como criar menus de atalho em indicadores. Aqui estão 
algumas tarefas que podem vie em seguida: 
• Escrever código para responder a eventos de controles host no Excel. Para obter mais 
informações, consulte Programação contra eventos de um controle NamedRange 
Walkthrough:. 
• Use uma caixa de seleção para alterar formatação em um indicador. Para obter mais 
informações, consulte Walkthrough: Changing Document formatação usando controles 
CheckBox. 
Visual C# Consolidado 124
Walkthrough: atualizando um gráfico em um documento usando 
botões de opção 
Essa explicação passo a passo demonstra os fundamentos básicos do alterando estilos do gráfico 
usando botões de opção em um documento do Microsoft Office Word 2003. Você usará Microsoft 
Visual Studio 2005 Tools for the Microsoft Office System para criar e adicionar código ao seu 
projeto. Para ver o resultado como uma amostra completa, consulte Exemplo de controles do 
Word. 
Durante este explicação passo a passo, você aprenderá como: 
• Adicionar um gráfico a um documento. 
• Adicionar um controle de usuário a um documento. 
• Alterar o estilo do gráfico quando uma opção está selecionada. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Microsoft Office Word 2003. 
Criando o projeto 
Nesta etapa, você irá criar projeto usando Visual Studio Tools for Office um documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Chart Options. Verifique que 
Create a new document está selecionada. Para obter mais informações, consulte Como 
criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Chart Options projeto para 
Solution Explorer o Visual Studio. 
Adicionar um gráfico ao documento 
Em seguida, adicione um gráfico para o documento. 
Para adicionar um gráfico 
1. No menu Insert, clique em Object. 
A Object caixa de diálogo será aberta. 
Observação 
Se o Insert menu não estiver visível, você deverá primeiro clicar em dentro do documento para 
que ele foco. Para obter mais informações consulte, Menus do Office no ambiente do Visual 
Studio. 
2. Na lista Object type da guia Create New, selecione Microsoft Graph Chart e 
clique em OK 
Visual C# Consolidado 125
Um gráfico é adicionado ao documento no ponto de inserção, e a Datasheet janela é 
exibida com alguns dados padrão. 
3. Feche a Datasheet janela para aceite os valores padrão no gráfico e clique dentro do 
documento para mover foco fora do gráfico. 
4. Clique com o botão direito do mouse no gráfico e selecione Format Object. 
5. Na guiaLayout da caixa de diálogo, selecione Square e Format Object Clique em 
OK. 
Adicionar um controle de usuário ao projeto 
Para adicionar um controle de usuário 
1. Selecione o My Chart Options projeto no Solution Explorer. 
2. No menu Project, clique em Add New Item. 
3. Na caixa Add New Item de diálogo, clique User Control, nome do controle 
ChartOptions, e clique em Add 
Para adicionar controles Windows Form ao controle de usuário 
1. Se o controle de usuário estiver não visível no designer, clique duas vezes em 
ChartOptions no Solution Explorer. 
2. Na guia Common Controls Da arraste um Radio Button controle para o controle de 
usuário, e alterar as seguintes propriedades: o Toolbox, 
Propriedade Value (Valor) 
Name columnChart 
Text Gráfico de coluna 
3. Adicionar um segundo Radio Button ao controle de usuário, e alterar as seguintes 
propriedades: 
Propriedade Value (Valor) 
Name barChart 
Text Gráfico de barras 
4. Adicionar um terceiro Radio Button ao controle de usuário, e alterar as seguintes 
propriedades: 
Propriedade Value (Valor) 
Name lineChart 
Text Gráfico de linha 
5. Adicionar um quarto Radio Button ao controle de usuário, e alterar as seguintes 
propriedades: 
Propriedade Value (Valor) 
Name areaBlockChart 
Text Gráfico bloquear de área 
Adicionar Referências 
Visual C# Consolidado 126
Para acessar o gráfico do controle de usuário em um documento, você deve ter uma referência à 
11.0 biblioteca objeto do Graph Microsoft no seu projeto. 
Para adicionar uma referência à 11.0 biblioteca objeto do Graph 
Microsoft 
1. No menu Project, clique em Add Reference. 
A Add Reference caixa de diálogo será exibida. 
2. Clique na COM guia. 
3. Selecione Microsoft Graph 11.0 Object Library na lista Component Name e 
clique em OK 
Alterar o estilo gráfico quando o botão de opção é selecionada 
Nesta seção, você será criar um evento público sobre o controle de usuário, adicionar uma 
propriedade para definir o tipo de seleção, e criar um procedimento para o CheckedChanged 
evento de cada um dos botões de opção. 
Para criar um evento e propriedade em um controle de usuário 
1. No Solution Explorer, clique com o botão direito do mouse no controle de usuário e 
selecione View Code. 
2. Adicione código para criar um SelectionChanged evento e a Selection propriedade para a 
ChartOptions classe: 
C# 
public event EventHandler SelectionChanged; private 
Microsoft.Office.Interop.Graph.XlChartType selectedType = 
Microsoft.Office.Interop.Graph.XlChartType.xlColumnClustered; public 
Microsoft.Office.Interop.Graph.XlChartType Selection { get { return this.selectedType; } set { 
this.selectedType = value; } } 
Para manipular o evento CheckedChange dos botões de opção 
1. Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão 
areaBlockChart de opção e depois gerar o evento. 
C# 
private void areaBlockChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Graph.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
2. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart 
de opção. 
C# 
private void barChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Graph.XlChartType.xlBarClustered; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
3. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão 
columnChart de opção. 
C# 
private void columnChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Visual C# Consolidado 127
Microsoft.Office.Interop.Graph.XlChartType.xlColumnClustered; if (this.SelectionChanged != 
null) { this.SelectionChanged(this, EventArgs.Empty); } } } 
4. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart 
de opção. 
C# 
private void lineChart_CheckedChanged(object sender, EventArgs e) { if 
(((RadioButton)sender).Checked) { this.selectedType = 
Microsoft.Office.Interop.Graph.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) { 
this.SelectionChanged(this, EventArgs.Empty); } } } 
5. Em C#, você deve adicionar manipuladores de eventos para os botões de opção. Adicione 
o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, 
conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
C# 
public ChartOptions() { InitializeComponent(); areaBlockChart.CheckedChanged += new 
EventHandler(areaBlockChart_CheckedChanged); barChart.CheckedChanged += new 
EventHandler(barChart_CheckedChanged); columnChart.CheckedChanged += new 
EventHandler(columnChart_CheckedChanged); lineChart.CheckedChanged += new 
EventHandler(lineChart_CheckedChanged); } 
Adicionando o controle de usuário ao documento 
Quando você cria a solução, o novo controle de usuário é automaticamente adicionado à 
Toolbox. Do Toolbox Você pode, então, arrastar o controle de ao seu documento. 
Para adicionar o controle de usuário do documento 
1. No menu Build, clique em Build Solution. 
O ChartOptions controle de usuário é adicionado à Toolbox. 
2. Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou 
ThisDocument.cs. e selecione View Designer 
3. Do Toolbox arraste o ChartOptions controle de para o documento. 
Um novo controle chamado ChartOptions1 é adicionado ao seu projeto. 
Alterar o tipo de gráfico 
Nesta seção, criar um manipulador de eventos para alterar o tipo de gráfico acordo para a opção 
selecionada no controle de usuário. 
Para alterar o tipo de gráfico que é exibido no documento 
1. Adicionar o manipulador de eventos a seguir para a ThisDocument classe. 
C# 
private void ChartOptions1_SelectionChanged(object sender, EventArgs e) { try { //first object 
is the runtime storage control object index = 2; Word.Shape shape = this.Shapes.get_Item(ref 
index); //Activate the shape shape.Activate(); Microsoft.Office.Interop.Graph.Chart dataChart = 
(Microsoft.Office.Interop.Graph.Chart)shape.OLEFormat.Object; dataChart.ChartType = 
this.ChartOptions1.Selection; //Deactivate the shape this.ChartOptions1.Select(); } catch 
(Exception ex) { MessageBox.Show(ex.Message); } } 
2. Em C#, adicione um manipulador de eventos para o controle de usuário para o Startup 
evento como mostrado abaixo. Para obter informações sobre como criar manipuladores de 
eventos, consulte Como criar manipuladores de eventos em Ferramentas do Visual Studio 
do Office:. 
Visual C# Consolidado 128
C# 
this.ChartOptions1.SelectionChanged += new 
EventHandler(ChartOptions1_SelectionChanged); 
Testar o aplicativo 
Agora você pode testar seu documento para certificar-se que o estilo do gráfico é atualizado 
corretamente quando você seleciona um botão de opção. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Selecione vários botões de opção. 
3. Confirme que o estilo do gráfico altera para correspondem à seleção. 
Próximas etapas 
Essa explicação passo a passo mostra noções básicas de usando botões de opção e 
programaticamente alterando estilos do gráfico em documentos do Word 2003. Aqui estão 
algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do 
Office: 
• Usando um botão para preencher uma caixa de texto. Para obter mais informações, 
consulte Exibindo texto em uma caixa de texto em um documento usando um botão 
Walkthrough:. 
• Alterar formatação, selecionando um estilo da caixa de combinação. Para obter mais 
informações, consulte Walkthrough: Changing Document formatação usando controles 
CheckBox. 
Vinculação de Dados para controles em um painel Açõesdo 
Word Walkthrough: 
Essa explicação passo a passo demonstra vinculação de dados a controles em um painel Ações 
no Microsoft Office Word 2003. Os controles serão demonstram uma Relação mestre / detalhes 
entre tabelas em um banco de dados do SQL Server. 
Durante este explicação passo a passo, você aprenderá como: 
• Criar um controle painel Ações para o painel Ações. 
• Adicionar controles que são acoplados a dados a um controle painel Ações Windows 
Forms. 
• Use uma Relação mestre / detalhes quando exibir dados nos controles. 
• Mostrar painel de ações quando abre o aplicativo. 
• Testar seu projeto. 
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 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
Visual C# Consolidado 129
• O Microsoft Office Word 2003. 
Acesso a um servidor com o Exemplo de SQL Server do Northwind. 
• Permissões para ler e gravar no banco de dados do SQL Server. 
Criando o projeto 
Nesta etapa, você irá criar um projeto Documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Word Actions Pane. Verifique 
que Create a new document está selecionada. Para obter mais informações, consulte 
Como criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Word Actions Pane projeto 
para Solution Explorer o Visual Studio. 
Adicionar controles ao painel de ações 
Para essa explicação passo a passo, é necessário um controle painel Ações que contém controles 
ligados a dados Windows Forms. Adicionar uma fonte de dados para o projeto, e arraste os 
controles a partir da Data Sources janela para o controle painel Ações. 
Para adicionar um controle painel Ações 
1. Selecione o My Word Actions Pane projeto no Solution Explorer. 
2. No menu Project, selecione Add New Item. 
3. Na caixa Add New Item de diálogo, selecione Actions Pane Control, nomeá-la 
ActionsControl, e clique em Add 
Para adicionar uma nova fonte de dados para o projeto 
1. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data 
menu. 
Observação 
Se Show Data Sources Clique dentro do documento do Word e marque novamente. não estiver 
disponível, 
2. Clique Add New Data Source Para iniciar o Data Source Configuration 
Wizard. 
3. Selecione Database e, em seguida clique em Next. 
Selecionar uma conexão de dados ao banco de dados de Exemplo Northwind do SQL Server ou 
adicionar uma nova conexão com o New Connection botão. 
4. Clique em Next. 
5. Desmarque a opção para salvar a conexão se ele estiver selecionado e clique em Next. 
6. Expanda o Tables nó na janela Database objects. 
7. Marque a caixa de seleção ao lado e Products tabelas. o Suppliers 
8. Clique em Finish. 
O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele 
também adiciona um DataSet digitado ao seu projeto que está visível no Solution Explorer. 
Para adicionar controles Windows Forms ligados a dados a um controle 
painel Ações 
Visual C# Consolidado 130
1. Na janela Data Sources, expanda a Suppliers tabela. 
2. Clique na seta suspensa no nó Company Name, e selecione ComboBox. 
3. Arraste CompanyName da janela Data Sources para o controle painel Ações. 
Um ComboBox controle é criado no controle painel Ações. Ao mesmo tempo, nomeado 
SuppliersBindingSource, um adaptador de tabela, e um DataSet são adicionados ao 
projeto no bandeja de componentes. um BindingSource 
Observação 
Um navegador de ligação também é adicionado para o bandeja de componentes e para o topo do 
controle painel Ações. Você removerá esse controle posteriormente no explicação passo a passo 
o. 
4. Mover a caixa de combinação para que ele seja sob o rótulo e alterar a Size propriedade 
171, 21. 
5. Expandir a Products tabela na janela Data Sources. 
6. Clique na seta suspensa no nó ProductName, e selecione ListBox. 
7. Arraste ProductName para o controle painel Ações. 
Um ListBox controle é criado no controle painel Ações. Ao mesmo tempo, chamado 
ProductBindingSource e um adaptador de tabela são adicionados para o projeto no 
bandeja de componentes. um BindingSource 
8. Do SuppliersBindingNavigator Selecione na bandeja e Component pressione 
DELETE. 
Observação 
Excluindo o SuppliersBindingNavigator faz não remover todos os o código que foi gerado para 
ele. Você pode remover este código. 
9. Mover a caixa de listagem para que ele seja sob o rótulo e alterar a Size propriedade 
171,95. 
10. Arraste controlar e colocá-lo a caixa de listagem abaixo. de para o painel Ações um Button 
o Toolbox 
11. Clique com o botão direito do mouse clique Properties no menu de atalho, e altere as 
seguintes propriedades: o Button, 
Propriedade Value (Valor) 
Name Inserir 
Text Inserir 
12. Redimensionar o controle de usuário para ajustar os controles. 
Configurando a fonte de dados 
Nesta seção, você adicionará código ao Load Evento do controle painel Ações para preencher o 
controle com dados da DataTable. Do DataSource você irá então definir e DataMember 
propriedades para cada controle. 
Para carregar o controle com dados 
• No manipulador Load de eventos da classe ActionsControl, adicione o seguinte código: 
C# 
Visual C# Consolidado 131
private void ActionsControl_Load(object sender, EventArgs e) { 
this.suppliersTableAdapter.Fill(this.northwindDataSet.Suppliers); 
this.productsTableAdapter.Fill(this.northwindDataSet.Products); } 
Para definir propriedades de vinculação de dados do controle 
1. Selecione o CompanyNameComboBox controle. 
2. Na janela Properties, clique no botão para a direita da propriedade DataSource, e 
selecione SuppliersBindingSource. 
3. Na janela Properties, clique no botão para a direita da propriedade DisplayMember, 
e selecione CompanyName. 
4. Selecione o ProductNameListBox controle. 
5. Na janela Properties, clique no botão para a direita da propriedade DataSource, 
expanda SuppliersBindingSource, e selecione FK_Products_Suppliers. 
6. Na janela Properties, clique no botão para a direita da propriedade DisplayMember, 
e selecione ProductName. 
Adicionando um método para inserir dados em uma tabela 
Nesta etapa, será ler os dados dos controles acoplados e preencher uma tabela em seu 
documento do Word. Primeiro, você irá criar um procedimento para formatar os títulos na tabela, e 
seguida, você adicionará o AddData método para criar e formatar uma tabela do Word. 
Para formatar os títulos de tabela 
Na classe ActionsControl, crie um método para formatar os títulos da tabela. Adicione código 
conforme mostrado no Exemplo a seguir: 
C# 
static void SetHeadings(Microsoft.Office.Interop.Word.Cell tblCell, string text) { 
tblCell.Range.Text = text; tblCell.Range.Font.Bold = 1; 
tblCell.Range.ParagraphFormat.Alignment = 
Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphCenter; } 
Para criar a tabela 
Na classe ActionsControl, escreva não um método que criará uma tabela se um não existir, e 
adicionar dados a partir do painel Ações à tabela. Adicione código conforme mostrado no Exemplo 
a seguir. 
C# 
private void AddData(DataRow row, string companyName) { object missing = 
System.Type.Missing; // Create a table if it doesn't already exist. if 
(Globals.ThisDocument.Tables.Count == 0) { try { // Create a table. 
Microsoft.Office.Interop.Word.Table tbl = Globals.ThisDocument.Tables.Add 
(Globals.ThisDocument.Application.Selection.Range, 1, 4, ref missing, ref missing); // Insert 
headings. SetHeadings(tbl.Cell(1, 1), "Company Name"); SetHeadings(tbl.Cell(1, 2), "Product 
Name"); SetHeadings(tbl.Cell(1, 3), "Quantity"); SetHeadings(tbl.Cell(1, 4), "UnitPrice"); } 
catch (Exception ex) { MessageBox.Show("Problem creating Products table: " + ex.Message, 
"Actions Pane", MessageBoxButtons.OK, MessageBoxIcon.Error); } } // Add data from data row 
to the table. Microsoft.Office.Interop.Word.Selection selection = 
Globals.ThisDocument.Application.Selection; if (selection.Tables.Count > 0) { 
Microsoft.Office.Interop.Word.Row newRow = Globals.ThisDocument.Tables[1].Rows.Add(ref 
missing); newRow.Range.Font.Bold = 0; newRow.Range.ParagraphFormat.Alignment = 
Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphLeft; 
newRow.Cells[4].Range.ParagraphFormat.Alignment = 
Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphRight; 
newRow.Cells[1].Range.Text = companyName; newRow.Cells[2].Range.Text = 
Visual C# Consolidado 132
row["ProductName"].ToString(); newRow.Cells[3].Range.Text = 
row["QuantityPerUnit"].ToString(); newRow.Cells[4].Range.Text = 
Math.Round(Convert.ToDouble(row["UnitPrice"])).ToString("#,##0.00"); } else { 
MessageBox.Show("Cursor must be within a table.", "Actions Pane", MessageBoxButtons.OK, 
MessageBoxIcon.Error); } } 
Para inserir texto em uma tabela do Word 
No manipulador Click de eventos do botão Insert, adicione código conforme mostrado no 
Exemplo o seguir: 
Observação 
Para obter informações sobre como criar manipuladores de eventos, consulte Como criar 
manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
private void Insert_Click(object sender, System.EventArgs e) { DataTable tbl = 
northwindDataSet.Products; DataRow[] rows; // Check if a product is selected. if 
(this.productNameListBox.SelectedIndex >= 0) { DataRowView productRow 
=(System.Data.DataRowView)this.productNameListBox.SelectedItem; string product = 
productRow.Row["ProductName"].ToString(); string company = 
this.companyNameComboBox.Text; // Return the data row from the selected product. rows = 
tbl.Select("ProductName = '" + product.Replace("'", "''") + "'"); this.AddData(rows[0], company); } 
else { MessageBox.Show("Please select a product.", "Actions Pane", MessageBoxButtons.OK); } } 
1. Em C#, você deve criar um manipulador de eventos para o Click Evento do botão. Você 
pode colocar este código no manipulador Load de eventos da classe ActionsControl. 
Para obter mais informações sobre como criar manipuladores de eventos, consulte Como 
criar manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
this.Insert.Click += new EventHandler(Insert_Click); 
Mostrando o Painel de Ações 
Você nesta seção, vai escrever código para mostrar o painel Ações. O painel Actions ficará visível 
depois controles são adicionados a ele. 
Para mostrar o painel Ações 
1. Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou 
ThisDocument.cs,. e, em seguida clique View Code no menu de atalho 
Criar uma nova instância do controle na parte superior da classe ThisDocument de forma que ele 
tenha como no Exemplo a seguir: 
C# 
private ActionsControl actions = new ActionsControl(); 
Adicione código ao manipulador Startup de eventos de ThisDocument forma que ele tenha como no 
Exemplo a seguir: 
Observação 
Para obter informações sobre como criar manipuladores de eventos, consulte Como criar 
manipuladores de eventos em Ferramentas do Visual Studio do Office:. 
C# 
this.ActionsPane.Controls.Add(actions); 
Testar o aplicativo 
Visual C# Consolidado 133
Agora você pode testar seu documento para certificar-se que o painel Ações é aberto quando o 
documento for aberto. Teste para a relação mestre / detalhes nos controles no painel Ações, e 
certifique-se que dados são preenchidos em uma tabela do Word quando o Insert botão é 
clicado. 
Para testar seu documento 
1. Pressione F5 para executar o projeto. 
2. Confirme se o painel Actions está visível. 
3. Selecione uma empresa na caixa de combinação e verifique que os itens na caixa 
Products Lista alterar. 
4. Selecione um produto, clique Insert no painel de ações, e verifique se os detalhes do 
produto foram adicionados à tabela no Word. 
5. Inserir outros produtos de várias empresas. 
Próximas etapas 
Essa explicação passo a passo mostra as noções básicas de vinculação de dados a controles em 
um painel Ações no Word. Aqui estão algumas tarefas que podem vie em seguida: 
• Implantando o projeto. Para obter mais informações, consulte Como implantar soluções do 
Office:. 
• Ligação de dados a controles no Excel. Para obter mais informações, Vinculação de Dados 
para controles em um painel Ações do Excel Walkthrough:. 
• Mostrar e ocultar controles no painel de ações. Para obter mais informações, consulte 
Alterando o painel de ações de acordo com contexto do usuário Walkthrough: 
Walkthrough: criar uma marca inteligente que converte 
Temperatures de Fahrenheit para Celsius 
Essa explicação passo a passo demonstra criar uma marca inteligente que reconhece Fahrenheit 
seqüências de temperatura. A marca inteligente inclui uma ação que converte o valor de 
temperatura em Celsius, e substitui o texto reconhecido por um Celsius formatado Seqüência de 
temperatura. 
Durante este explicação passo a passo, você aprenderá como: 
• Criar uma marca inteligente que reconhece uma expressão regular. 
• Criar uma ação que recupera dados da marca inteligente e modifica o texto de reconhecido 
marca inteligente. 
Pré-requisitos 
Para concluir esta explicação passo a passo, será necessário: 
• Microsoft Visual Studio 2005 Tools for the Microsoft Office System 
• O Microsoft Office Word 2003. 
Criando um novo projeto 
Nesta etapa, você irá criar um projeto Documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome My Smart Tag, usando o Visual 
Basic ou C#. Verifique que Create a new document está selecionada. Para obter mais 
informações, consulte Como criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o My Smart Tag projeto para 
Solution Explorer o Visual Studio. 
Visual C# Consolidado 134
Configurando o projeto 
Para esta etapa, você irá configurar o projeto para executar o código fornecido nessa explicação 
passo a passo. 
Para configurar seu projeto 
1. No menu Project, clique em Add Reference. 
2. Na guia COM, selecione biblioteca tipo 2.0 marcas inteligentes Microsoft e clique em OK. 
3. No Solution Explorer, clique com o botão direito do mouse ThisDocument.vb (em 
Visual Basic) ou ThisDocument.cs (em C#) e clique em View Code. 
4. Adicione a seguinte linha de código para o topo do arquivo: 
C# 
using System.Text.RegularExpressions; 
Criando a marca inteligente 
Nesta etapa, você será criar uma Visual Studio Tools for Office marca inteligente e adicioná-lo 
para o documento. Também irá adicionar uma expressão regular para a lista de termos que 
reconhece a marca inteligente, e criar uma ação que estará disponível quando o usuário clica a 
marca inteligente. 
Para criar a marca inteligente 
1. Substituir manipulador ThisDocument_Startup de eventos na classe ThisDocument 
pelo código a seguir. Este código cria uma SmartTag que representa a Visual Studio Tools 
for Office marca inteligente, e adiciona uma expressão regular para a lista de termos que 
reconhece a marca inteligente. 
C# 
private Microsoft.Office.Tools.Word.Action action1; private void ThisDocument_Startup(object 
sender, System.EventArgs e) { Microsoft.Office.Tools.Word.SmartTag smartTag1 = new 
Microsoft.Office.Tools.Word.SmartTag( "www.microsoft.com/Demo#DemoSmartTag", 
"Demonstration Smart Tag"); smartTag1.Expressions.Add(new Regex( @"(?'number'[+-]?\b[0-
9]+)?\s?(F|f)\b")); 
2. Criar uma nova Action e adicioná-lo para a Actions propriedade da marca inteligente. A 
Action representa um item que o usuário pode clicar no menu de marcas inteligentes. 
C# 
action1 = new Microsoft.Office.Tools.Word.Action( "Convert to Celsius"); smartTag1.Actions = 
new Microsoft.Office.Tools.Word.Action[] {action1}; 
3. Do SmartTaganexar a marca inteligente para o documento, adicionando à propriedade 
VSTOSmartTags. Na C#, anexar um manipulador de eventos para o Click evento da ação. 
C# 
this.VstoSmartTags.Add(smartTag1); action1.Click += new 
Microsoft.Office.Tools.Word.ActionClickEventHandler( action1_Click); } 
Criar um manipulador de eventos para a ação 
Nesta etapa, você irá adicionar um manipulador de eventos para o Click evento da ação. O 
manipulador de eventos recupera o Fahrenheit valor de temperatura da chave number, que está 
no conjunto de propriedades da marca inteligente. O manipulador de eventos converte o 
Fahrenheit valor de temperatura para Celsius,. e substitui a seqüência reconhecido Neste 
exemplo, a chave number identifica um grupo capturado da expressão regular atribuído a marca 
inteligente. Para obter mais informações sobre propriedade Sacos e expressões regulares em 
Visual Studio Tools for Office marcas inteligentes, consulte Arquitetura marcas inteligentes. 
Visual C# Consolidado 135
Para criar o manipulador de eventos 
• Copie o código a seguir para a ThisDocument classe: 
C# 
void action1_Click(object sender, Microsoft.Office.Tools.Word.ActionEventArgs e) { string value 
= e.Properties.get_Read("number"); double fahrenheit = Convert.ToDouble(value); int celsius = 
(int)(fahrenheit - 32) * 5 / 9; e.Range.Text = celsius.ToString() + "C"; } 
Testar o aplicativo 
Agora você pode testar seu documento para certificar-se que a marca inteligente converte 
Fahrenheit temperaturas para Celsius. 
Para testar sua pasta de trabalho 
1. Pressione F5 para executar o projeto. 
2. Digitar uma seqüência que esteja de acordo com a expressão regular é adicionado à 
marca inteligente, como 60F, 60° F,. ou 60 F 
Observação 
Para digitar um símbolo de grau (°), pressione ALT e digite 248. 
3. Clique no ícone de marca inteligente que aparece sobre a seqüência reconhecida e clique 
em Convert to Celsius. 
4. Confirme que a seqüência original é substituída por uma nova seqüência contendo a 
temperatura em Celsius. 
Implantando um Word ou Solution do Excel usando um 
manifesto Deployment Walkthrough: 
Essa explicação passo a passo demonstra como implantar uma solução o Microsoft Office Excel 
ou Microsoft Office Word em um compartilhamento de rede em um servidor. Será posicionado no 
final do explicação passo a passo, o possível para executar a solução no servidor do seu 
computador de desenvolvimento. 
Em um ambiente de produção, uma Microsoft Visual Studio 2005 Tools for the Microsoft Office 
System solução geralmente é publicada primeiro a um servidor de teste, e depois ele é 
reimplantado em um servidor de produção depois que o departamento de TI aprovar-. Você nessa 
explicação passo a passo, será emular esse processo, publicando uma solução em um local 
temporário no seu computador de desenvolvimento, e então redeploying a solução do local de 
publicação para um servidor. Para obter mais informações sobre as opções para implantar a 
solução, consulte Modelos de implantação. 
Durante este explicação passo a passo, você aprenderá como: 
• Do Publish Wizard uso para publicar sua solução em um local no seu computador de 
desenvolvimento. 
• Manualmente relançamento a solução do seu computador local para um compartilhamento 
de rede em um servidor. 
• Modificar o manifesto do aplicativo que está incorporado no documento para apontar para 
o novo local manifesto de implantação programaticamente. 
• Editar a manifesto de implantação para apontar para a nova localização do manifesto do 
aplicativo externos. 
• Editar o manifesto do aplicativo externo para apontar para o novo local do conjunto e a 
manifesto de implantação. 
Pré-requisitos 
Visual C# Consolidado 136
Para concluir esta explicação passo a passo, será necessário: 
• Visual Studio Tools for Office 
• O Word Microsoft Office 2003 ou Microsoft Office Excel 2003. 
Observação 
Essa explicação passo a passo pressupõe que você estiver implantando uma solução Word. Se 
você quiser executar explicação passo a passo com uma solução Excel, o substitua o nome do 
projeto do Word com o nome do seu projeto do Excel em todos os códigos e exemplos XML. 
• Acesso a um servidor de rede para implantação. Essa explicação passo a passo 
pressupõe que você são redeploying sua solução para o \\DeployServer\ShareFolder 
compartilhamento de rede. 
• Privilégios de administrador no computador de desenvolvimento, para que você possa 
definir a diretiva de segurança para um local de rede. 
Criando o projeto 
Nesta etapa, você irá criar um projeto Documento do Word. 
Para criar um novo projeto 
• Criar um projeto Documento do Word com o nome WordDeployment. Verifique que 
Create a new document está selecionada. Para obter mais informações, consulte Como 
criar Ferramentas do Visual Studio para projetos do Office:. 
Abre o novo documento do Word no designer e adiciona o WordDeployment projeto para 
Solution Explorer o Visual Studio. 
Adicionar código para trás o documento 
Nesta etapa, você adicionará uma caixa de mensagem ao manipulador Startup de eventos do 
documento. Isso permitirá que você para verificar se a solução está funcionando quando você 
abre o documento rapidamente. 
Para adicionar uma caixa de mensagem a um evento de inicialização 
1. Clique com o botão direito do mouse ThisDocument.vb no Solution Explorer, ou 
ThisDocument.cs,. e, em seguida clique View Code no menu de atalho 
2. Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisDocument 
classe para mostrar uma caixa de mensagem durante a inicialização. 
C# 
private void ThisDocument_Startup(object sender, System.EventArgs e) { 
MessageBox.Show("The document is deployed correctly."); } 
3. Pressione F5 para executar o projeto. 
Inicia o Word e a caixa de mensagem aparece. 
4. Fechar a caixa de mensagem. 
5. Sair do Word. 
Em seguida, você publicará nesta solução. 
Publicando a solução 
Nesta etapa, você publicará a solução em um local temporário no computador local. 
Para publicar a solução 
1. Clique com o botão direito do mouse o nó de projeto no Solution Explorer. 
2. Clique Publish no menu de atalho. 
Visual C# Consolidado 137
O Publish Wizard aparece. 
3. Na caixa Specify the location to publish this application, digite 
C:\TestDeploy. 
4. Clique em Finish. 
O documento de Solução e manifesto de implantação são copiados para C:\TestDeploy. 
O conjunto de solução, atualizado manifesto do aplicativo, e cópias do documento de 
Solução e manifesto de implantação são copiadas para 
C:\TestDeploy\WordDeployment_1.0.0.0. Para obter mais informações, consulte 
Implantando o Word e Excel Solutions. 
5. Feche o WordDeployment projeto no Visual Studio. 
Observação 
O conjunto não tem permissão para executar ainda, para que ele se você tentar executar a 
solução será lançar um erro. Você irá atualizar sua diretiva de segurança para conceder 
permissão de confiança total ao conjunto em uma etapa posterior. 
Quando você publicar uma solução, o manifesto do aplicativo incorporado no aponta de 
documento de solução para o caminho completo da manifesto de implantação. Se você 
relançamento os arquivos de solução para outro local, deverá atualizar o manifesto do aplicativo 
incorporado para apontar para a nova localização da manifesto de implantação. Você também 
deve atualizar a manifesto de implantação e o manifesto do aplicativo externo para apontar para 
os novos locais de arquivo. 
Atualizando o manifesto Application incorporados 
Para editar o manifesto do aplicativo incorporado, use a ServerDocument classe que Visual Studio 
Tools for Office fornece. Quando você usa a ServerDocument classe, você deve executar o 
código em um novo projeto (não a Visual Studio Tools for Office Solução), como um projeto de 
console, e o Visual Studio Tools for Office documento de solução deve ser fechado. 
Observação 
Inclui Visual Studio Tools for Office um Exemplo que demonstre como criar uma ferramenta que 
pode ser usada para editaro manifesto do aplicativo incorporado. Para obter mais informações, 
consulte Aplicativo Manifest Exemplo Editor. 
Para atualizar o manifesto do aplicativo incorporado 
1. Criar um novo projeto Console Application. 
2. Do Microsoft.VisualStudio.Tools.Applications.Runtime Adicionar referências para e 
System.Windows.Forms montagens para este projeto. 
3. Abra o arquivo Program.cs ou Module1.vb, e adicione a seguinte Imports ou using 
instrução para o topo do arquivo. 
C# 
using Microsoft.VisualStudio.Tools.Applications.Runtime; 
4. Copie o código a seguir para a Main função. Este código cria uma ServerDocument 
que fornece acesso ao manifesto do aplicativo incorporado de seu documento de solução. 
O código atribui o novo caminho manifesto de implantação para a DeployManifestPath 
propriedade, e salva e fecha o ServerDocument.. o ServerDocument 
C# 
ServerDocument sd = null; try { sd = new 
ServerDocument(@"C:\TestDeploy\WordDeployment.doc"); 
sd.AppManifest.DeployManifestPath = 
Visual C# Consolidado 138
@"\\DeployServer\ShareFolder\WordDeployment.application"; sd.Save(); } finally { if (sd != 
null) { sd.Close(); } } 
5. Pressione F5 para executar o projeto. 
Uma janela do console aparece rapidamente enquanto o manifesto do aplicativo 
incorporado está sendo atualizado, e fecha a janela do console. 
Atualizando o manifesto de implantação 
Agora que você atualizou o manifesto do aplicativo incorporado no documento Visual Studio Tools 
for Office de solução, você deve atualizar a manifesto de implantação para apontar para a nova 
localização do manifesto do aplicativo externos. 
Para atualizar a manifesto de implantação 
1. Abra a manifesto de implantação em um editor de texto, como o Bloco de notas. A 
manifesto de implantação é denominado WordDeployment.application, e está 
localizado na pasta C:\TestDeploy de publicação. 
2. Defina o codebase atributo do elemento <dependentAssembly> como o caminho 
completo da localização implantação final do manifesto do aplicativo externos. Para obter 
mais informações, consulte &lt;dependentAssembly&gt; Element (Visual Studio Tools for 
Office Reference).O atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly codebase="\\DeployServer\ShareFolder\ 
WordDeployment_1.0.0.0\WordDeployment.dll.manifest" 
3. Salve e feche o arquivo manifesto de implantação. 
Atualizando o manifesto de aplicativos externos 
Além disso, para atualizar a manifesto de implantação, você também deve editar o manifesto do 
aplicativo externo para apontar para os locais implantação final do conjunto de solução e a 
manifesto de implantação. Sempre que você publicar uma Visual Studio Tools for Office solução, 
um novo manifesto do aplicativo externo é gerado que aponta para a versão atual do conjunto de 
solução. 
Para atualizar o manifesto do aplicativo externo 
1. Abra o manifesto do aplicativo em um editor de texto, como o Bloco de notas. O manifesto 
do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na 
pasta C:\TestDeploy\WordDeployment_1.0.0.0 de publicação. 
2. Localize o <installFrom> elemento que está o filho do elemento <dependency>, e 
defina o codebase atributo como o caminho completo da montagem de solução atual. Para 
obter mais informações, consulte <installFrom> Element (Visual Studio Tools for Office 
Reference).O atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly codebase="\\DeployServer\ShareFolder\ 
WordDeployment_1.0.0.0\WordDeployment.dll" 
3. Localize o <installFrom> elemento que está o filho do elemento <assembly>, e defina o 
codebase atributo para o caminho completo do manifesto de implantação. Para obter mais 
informações, consulte <installFrom> Element (Visual Studio Tools for Office Reference).O 
atributo para essa explicação passo a passo deve aspecto como este: 
<dependentAssembly 
codebase="\\DeployServer\ShareFolder\WordDeployment.application" 
4. Salve e feche o arquivo manifesto do aplicativo. 
Copiando os arquivos da solução para o servidor 
Agora que você tiver editado os manifestos, você está pronto para copiar os arquivos de solução 
para o servidor. 
Visual C# Consolidado 139
Para copiar os arquivos de solução para o servidor 
1. Crie uma WordDeployment_1.0.0.0 pasta sob a 
\\DeployServer\ShareFolder compartilhamento de arquivos de rede. 
2. Copiar o documento de Solução e a manifesto de implantação para 
\\DeployServer\ShareFolder. 
3. Copiar o conjunto de solução e o manifesto do aplicativo para 
\\DeployServer\ShareFolder\WordDeployment_1.0.0.0. 
Conceder confiança total para a pasta de rede 
Para execute sua Visual Studio Tools for Office solução a partir da pasta de rede, você deve 
conceder confiança total para a pasta de rede na sua diretiva de segurança no computador de 
desenvolvimento. Você pode modificar a diretiva de segurança de um prompt de comando usando 
a ferramenta Diretiva de Segurança para Acesso ao Código (Caspol.exe). Para conceder 
confiança para um local de rede, você deve ter privilégios de administrador e você deverá alterar a 
diretiva de segurança no nível do computador. 
Observação 
Este procedimento é destinado a fim de executar essa explicação passo a passo. Não use este 
procedimento para conceder confiança a conjuntos ou diretórios se não tiver certeza que sejam 
segura e protegida. Para obter mais informações sobre concessão e remover permissões, 
consulte HOW TO: conceder permissões para pastas e montagens e Como remover permissões 
de pastas e montagens:. 
Para conceder confiança total para a pasta de rede 
• Digite o seguinte comando no prompt de comando Studio visual: 
caspol -m -ag LocalIntranet_Zone -url \\DeployServer\ShareFolder\* FullTrust -n "Remote 
Deployment" -d "Deployment Walkthrough" 
Testando a solução 
Agora você pode testar sua solução para certificar-se que seu código seja executado quando você 
abre o documento a partir do computador de desenvolvimento. 
Para testar a implantação 
1. No computador de desenvolvimento, abra o WordDeployment.doc arquivo no 
\\DeployServer\ShareFolder\. 
2. Confirme se a caixa de mensagem aparece. 
Próximas etapas 
Você também pode implantar a solução usando um arquivo do Microsoft Windows Installer (.msi). 
Para obter mais informações, consulte Implantando um Word ou Solution do Excel usando um 
arquivo do Windows Installer Walkthrough:. 
 
Implantando um Word ou Solution do Excel usando um arquivo 
do Windows Installer Walkthrough: 
Essa explicação passo a passo demonstra como criar um arquivo do Microsoft Windows Installer 
(.msi) que pode ser usado para implantar uma solução Microsoft Office Excel 2003 ou Microsoft 
Office Word 2003. 
Durante este explicação passo a passo, você aprenderá como: 
Visual C# Consolidado 140
• Criar um projeto de instalação que você pode usar para criar um arquivo do Windows 
Installer. 
• Modifique o projeto de instalação para que o arquivo Windows Installer instala sua 
Microsoft Visual Studio 2005 Tools for the Microsoft Office System solução. 
• Adicionar uma etapa para o projeto de instalação para que Arquivo do Windows Installer 
edita o manifesto do aplicativo incorporados no Visual Studio Tools for Office documento de 
solução. 
Essa explicação passo a passo pressupõe que o computador de destino já tiver os pré-requisitos 
instalados para executar Visual Studio Tools for Office soluções. Você cria o arquivo Windows 
Installer não o verificar ou instalar esses pré-requisitos. Para obter mais informações sobre os pré-
requisitos para executar Visual Studio Tools for Office soluções, consulte Como se preparar 
computadores de usuário final para executar soluções do Office:. 
Observação 
Conjuntos em Visual Studio Tools for Office Soluções devem ser concede confiança total na 
diretiva de segurança do usuário final antes da solução seja executado. O arquivo Windows 
Installer você criar nessa explicação passo a passo não Não implantar a diretiva de segurança 
necessário