Você está na página 1de 1238

Nível I - Iniciante

Autor: Elzevir Jr.


Janeiro, 2007

Visual C# Consolidado 1
Í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#)........................................................................................................................65
CRIANDO APLICATIVOS MÓVEIS E INCORPORADOS (VISUAL C#) .................................................................................66

Visual C# Consolidado 2
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 3
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# ........................................................................................................173
REFERÊ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 [ ]..............................................................................................................................................................239
OPERADOR ( )..............................................................................................................................................................240
OPERADOR . (PONTO) ..................................................................................................................................................241
OPERADOR + ...............................................................................................................................................................241
OPERADOR -................................................................................................................................................................242
OPERADOR * ...............................................................................................................................................................243

Visual C# Consolidado 4
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#...............................................................................................................................268
EXEMPLO 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 5
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 ................................................................................................................................319
EXEMPLO 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 6
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.....................................................................................................................428
Matrizes 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 7
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...............................................................................................................................504
Janela 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 8
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....................................................................................................................................560
Depurar 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 9
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 ............................................................866
Programaçã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 10
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 .........................................................................................................................1019
COMO: 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 11
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 .....................................................................................................................................1107
Para 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 12
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 ...................................................................................................1133
Para 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 13
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
Para criar 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 14
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 15
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ços do 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 16
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 17
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 18
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, juntamente com 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 19
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 20
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 21
• 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 22
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 declarar uma 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 23
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 24
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 25
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. Starter Kit é 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 26
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 27
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 28
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 29
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 propriedades e 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 30
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 31
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 32
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
Resources no 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 33
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 34
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 35
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# Consolidado 36
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 37
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 38
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 39
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 40
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 41
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 42
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, por padrã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 43
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 44
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 45
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 46
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 47
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 48
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 pode incluir 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 49
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 50
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 51
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 Biblioteca MSDN. 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 52
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 53
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 54
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 trecho de 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 55
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 56
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 57
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 58
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 Não
Comando
Dynamic Help Não Pressionar a tecla F1 não exibe a janela da Ajuda
Window dinâmica.
Para obter mais informações sobre a janela Ajuda

Visual C# Consolidado 59
dinâmico, consulte Como: Personalizar Ajuda dinâmica
ou Como controlar a janela da Ajuda dinâmico:.
Pesquisador de Não • Não é exibida membros herdados por padrão.
objetos
Janela Output Não
Solution Explorer Sim Explorer de solução aparece encaixado no lado direito
de IDE.
Start Page Sim, quando você A página inicial Exibe artigos na alimentação RSS
inicia o IDE MSDN no Visual C#.
Lista de tarefas Não
(Visual Studio)
Toolbox Sim, quando você A caixa de ferramentas aparece como uma janela que
cria um aplicativo do é encaixada no lado esquerdo de IDE recolhida.
Windows Forms

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 60
atalho
Ativar menu ALT + Abre o menu Programa, permitindo ao usuário para gerenciar
aplicativo espaços o estado da janela do aplicativo, por exemplo, mover ou
redimensionar.
Ativar menu ALT + HÍFEN Abre o menu de documento, permitindo ao usuário para
Janela gerenciar o estado da janela do documento ativo, por
Documento exemplo, mover ou redimensionar. Disponível somente
enquanto no modo MDI de dentro uma janela de documento.
Ativar ferramenta ALT + HÍFEN Abre o menu Janela ferramenta, permitindo ao usuário para
menu Janela mover a janela ferramenta no IDE. Disponível somente ao
dentro de uma janela ferramenta.
Aplicativo de ALT + F4 Fecha o IDE.
fechamento
Fechar CTRL+F6 Fecha o documento aplicativo ativo.
documento
Recolher Todos Num +- Recolhe todos os nós no modo de exibição de árvore atual.
os nós de árvore
Expandir todos os Num + * Expande todos os nós no modo de exibição de árvore atual.
nós de árvore
Mover para Barra ALT Ativa a barra de menus IDE principal.
de menus
Mova para CTRL + TAB Move para a próxima barra de ferramentas visível. Disponível
ferramentas somente enquanto a barra de menus principal estiver ativa.
próxima
Mover para Barra CTRL + Move para a barra de ferramentas visível anterior. Disponível
de ferramentas SHIFT + TAB somente enquanto a barra de menus principal estiver ativa.
anterior
Mova para SHIFT + ALT Ativa a barra de ferramentas Janela ferramenta. Disponível
ferramentas somente em uma janela ferramenta contendo uma barra de
Janela ferramenta ferramentas.
Mover o foco de CTRL + Move o foco em modo de exibição de árvore para baixo sem
árvore abaixo DOWN. alterar a seleção. Este atalho pode ser utilizado para
selecionar vários itens na árvore.
Move o foco de CTRL + UP Move o foco em modo de exibição de árvore backup sem
árvore cima 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 F4 Oculta e mostra uma lista drop-down. Disponível somente de
visibilidade lista uma lista drop-down.
drop-down
Alternar seleção CTRL + Alterna uma seleção para o foco atual em modo de exibição
foco de árvore SPACEBAR de árvore.

Visual C# Consolidado 61
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 62
• 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 63
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 64
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 65
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 66
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úblicos e 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 67
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 68
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 69
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 70
O EXCEL 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.
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 71
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 72
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 73
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 segunda caixa 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 74
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 75
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 76
• 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 77
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 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 78
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 79
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 80
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 implantar soluçõ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 81
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 82
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 83
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 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.

Visual C# Consolidado 84
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 85
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 86
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 87
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 trabalho do 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 88
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 89
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 90
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 91
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 92
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 93
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 94
• 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.
Adicionar um 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 95
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 96
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 97
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 Designer
Visual C# Consolidado 98
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 99
• 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 100


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 101


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 102


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 103


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 104


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


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 106


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 107


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


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 109


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 clique com 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 110


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 111


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 112


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 113


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

Visual C# Consolidado 114


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 115


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 116


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 117


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 118


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 119


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 120


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 121


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 122


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 123


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 124


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 guia Layout 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 125


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 126


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 127


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ções do


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 128


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


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 130


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), "Unit Price"); }
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 131


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 132


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 133


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 SmartTag anexar 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 134


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 135


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 136


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

Visual C# Consolidado 137


@"\\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 138


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 139


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

Visual C# Consolidado 140


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

Visual C# Consolidado 141


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

Visual C# Consolidado 142


5. Do ManifestEditor.cs clique com 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;
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
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.

Visual C# Consolidado 143


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

Visual C# Consolidado 144


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

Visual C# Consolidado 145


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

Visual C# Consolidado 146


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.

COMO: Adicionar Controles a Documentos do Office


Um controle é um componente no documento usado para exibir informações ou aceitar entrada do
usuário. Você pode adicionar controles Windows Forms para o Microsoft Office Excel 2003 e
Microsoft Office Word 2003 documentos em tempo de criação ou em tempo de execução. Por
exemplo, você pode adicionar um ComboBox controle a sua planilha para que os usuários possa
selecionar em uma lista de opções. Você também pode adicionar controles host, como controles
Bookmark e NamedRange controles, para documentos do Office. Para obter mais informações,
consulte Controles host do Word e Controles host do 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.

Adicionando controles em tempo de design


Para arrastar um Windows Forms controle para o documento
1. Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no
Visual Studio para que o documento fique visível no designer. Para obter informações sobre
como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do
Office:.
2. Na guia Common Controls Da Clique no controle que você deseja adicionar e arraste-
o para o documento. o Toolbox,

Observação
Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","")
no Formula Bar. Este texto é necessário e não devem ser excluídos.

Para desenhar um Windows Forms controle sobre o documento


1. Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no
Visual Studio para que o documento fique visível no designer. Para obter informações sobre
como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do
Office:.
2. Na guia Common Controls da caixa de ferramentas, clique no controle você deseja
adicionar.
3. No documento, clique no local em que a extremidade superior esquerda do controle para
ser localizado, e arraste para onde você deseja o canto inferior-direito do controle seja
localizado.
O controle é adicionado para o documento com o local especificado e tamanho.
Observação
Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","")
no Formula Bar. Este texto é necessário e não devem ser excluídos.

Visual C# Consolidado 147


Para adicionar um controle Windows Forms para o documento clicando uma única vez
sobre o controle
1. Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no
Visual Studio para que o documento fique visível no designer. Para obter informações sobre
como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do
Office:.
2. Na guia Common Controls Da clique Toolbox, o controle você deseja adicionar
3. Um documento, clique onde desejar o controle a ser adicionado.
O controle é adicionado ao documento com o tamanho padrão.
Observação
Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","")
no Formula Bar. Este texto é necessário e não devem ser excluídos.

Para adicionar um controle Windows Forms para o documento clicando duas vezes no
controle
1. Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no
Visual Studio para que o documento fique visível no designer. Para obter informações sobre
como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do
Office:.
2. Na guia Common Controls Controle você deseja para adicionar de clique duplo no
Toolbox.
O controle é adicionado para o documento no centralizar do documento ou painel ativo.
Observação
Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","")
no Formula Bar. Este texto é necessário e não devem ser excluídos.

Para adicionar um controle Windows Forms para o documento, pressionando a tecla


ENTER
1. Crie ou abra um projeto de pasta de trabalho do Excel ou projeto Documento do Word no
Visual Studio para que o documento fique visível no designer. Para obter informações sobre
como criar projetos, consulte Como criar Ferramentas do Visual Studio para projetos do
Office:.
2. Na guia Common Controls Da Clique no controle que você deseja adicionar e
pressione a tecla ENTER. o Toolbox,
O controle é adicionado para o documento no centralizar do documento ou painel ativo.
Observação
Quando você seleciona um controle no Excel, você verá =EMBED("WinForms.Control.Host","")
no Formula Bar. Este texto é necessário e não devem ser excluídos.

Você também pode adicionar controles Windows Forms dinamicamente a um documento em


tempo de execução usando os métodos auxiliar fornecidos pelo Microsoft Visual Studio 2005
Tools for the Microsoft Office System. No Exemplo abaixo, à célula A1 de um projeto de aplicativo
Excel. é adicionado um Button Para obter informações sobre como adicionar outros controles
Windows Forms, consulte Adicionar controles a documentos do Office em tempo de execução.
Adicionando controles em tempo de execução
Para adicionar um Windows Forms controlar programaticamente

Visual C# Consolidado 148


• No manipulador Startup de eventos de ThisWorkbook, insira o código a seguir para
adicionar à célula C5: um Button
C#
private void Sheet1_Startup(object sender, System.EventArgs e) {
Microsoft.Office.Tools.Excel.Controls.Button salesButton; salesButton =
this.Controls.AddButton(this.get_Range("C5", missing), "salesButton"); salesButton.Text =
"Calculate Total Sales"; }

COMO: Executar Cálculos do Excel por Programação


O Calculate método executa todos os cálculos no objeto especificado. Use o método do objeto
que limita o intervalo de cálculo para o menor número de células que você deseja recalcular. O
mecanismo de recálculo do Microsoft Office Excel 2003 é muito rápido, mas se você pode limitar o
número de células envolvidas, você pode otimizar a operação.
Executar cálculos para um intervalo
Para executar cálculos em um controle NamedRange
1. Criar o intervalo nomeado.
C#
Microsoft.Office.Tools.Excel.NamedRange NamedRange1 =
this.Controls.AddNamedRange(this.get_Range("A1", missing), "NamedRange1");
2. Chame o Calculate método do intervalo especificado.
C#
NamedRange1.Calculate();
Executar cálculos para o aplicativo inteiro
Para executar cálculos em todas as pastas de trabalho abertas
• Chame o Calculate método do objeto Application.
C#
this.Application.Calculate();
Compilando o código
• Este código deve ser colocado em uma classe folha, não na classe ThisWorkbook.

Como: Criar menus do Office programaticamente


Este Exemplo cria um menu chamado New Menu na barra de menus do Microsoft Office Excel
2003. O novo menu é colocado à esquerda do menu Help. Ele contém um comando de menu.
Quando o comando de menu for clicado, texto será inserido em uma célula na Sheet1.
Para obter um Exemplo de personalização interface de usuário no Microsoft Office Word 2003,
consulte COMO: Criar Barras de Ferramentas do Office por Programação e Walkthrough: Criando
menus de atalho para indicadores.
Adicione o seguinte código à classe ThisWorkbook.

Observação
Defina a Tag propriedade nos controles quando você adiciona manipuladores de eventos. Office
usa a Tag propriedade para manter controle de manipuladores de eventos para um específico

Visual C# Consolidado 149


CommandBarControl. Se a Tag propriedade estiver em branco, os eventos não são tratados
corretamente.

Observação
Declarar o variáveis menu no nível de classe INSTEAD OF dentro o método onde eles são
chamados. Isso garante que as variáveis menu permanecerá no escopo, desde que o aplicativo
está sendo executado. Caso contrário, o item será removido do coleta de lixo em algum momento
indeterminado, e seu código do manipulador de eventos pára de funcionar.

Exemplo
C#
// Declare the menu variable at the class level. private Office.CommandBarButton
menuCommand; private string menuTag = "A unique tag"; // Call AddMenu from the Startup
event of ThisWorkbook. private void ThisWorkbook_Startup(object sender, System.EventArgs
e) { CheckIfMenuBarExists(); AddMenuBar(); } // If the menu already exists, remove it. private
void CheckIfMenuBarExists() { try { Office.CommandBarPopup foundMenu =
(Office.CommandBarPopup) this.Application.CommandBars.ActiveMenuBar.FindControl(
Office.MsoControlType.msoControlPopup, System.Type.Missing, menuTag, true, true); if
(foundMenu != null) { foundMenu.Delete(true); } } catch (Exception ex) {
MessageBox.Show(ex.Message); } } // Create the menu, if it does not exist. private void
AddMenuBar() { try { Office.CommandBarPopup cmdBarControl = null; Office.CommandBar
menubar = (Office.CommandBar)Application.CommandBars.ActiveMenuBar; int controlCount
= menubar.Controls.Count; string menuCaption = "&New Menu"; // Add the menu.
cmdBarControl = (Office.CommandBarPopup)menubar.Controls.Add(
Office.MsoControlType.msoControlPopup, missing, missing, controlCount, true); if
(cmdBarControl != null) { cmdBarControl.Caption = menuCaption; // Add the menu command.
menuCommand = (Office.CommandBarButton)cmdBarControl.Controls.Add(
Office.MsoControlType.msoControlButton, missing, missing, missing, true);
menuCommand.Caption = "&New Menu Command"; menuCommand.Tag =
"NewMenuCommand"; menuCommand.FaceId = 65; menuCommand.Click += new
Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler(
menuCommand_Click); } } catch (Exception e) { MessageBox.Show(e.Message); } } // Add text
to cell A1 when the menu is clicked. private void
menuCommand_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault)
{ Globals.Sheet1.Range["A1", missing].Value2 = "The menu command was clicked."; }

COMO: Criar Barras de Ferramentas do Office por Programação


Este Exemplo cria uma barra de ferramentas denominada Teste no Microsoft Office Word 2003.
Ele aparece perto no meio do documento e contém dois botões. Quando um botão é clicado, uma
caixa de mensagem aparece. Para obter um Exemplo de personalização a interface do usuário do
Office no Microsoft Office Excel 2003, consulte Como: Criar menus do Office programaticamente.
Adicione o seguinte código à classe ThisDocument.

Observação
Declarar o variáveis barra de comando no nível de classe INSTEAD OF dentro o método onde
eles são chamados. Isso garante que as variáveis barra comando permanecerá no escopo, desde
que o aplicativo está sendo executado. Caso contrário, o item será removido do lixo e seu código
do manipulador de eventos não é executado.

Exemplo
C#

Visual C# Consolidado 150


// Create the command bar variables at the class level. Office.CommandBar commandBar;
Office.CommandBarButton firstButton; Office.CommandBarButton secondButton; private void
ThisDocument_Startup(object sender, System.EventArgs e) { AddToolbar(); } private void
AddToolbar() { try { commandBar = Application.CommandBars["Test"]; } catch
(ArgumentException e) { // Toolbar named Test does not exist so we should create it. } if
(commandBar == null) { // Add a commandbar named Test. commandBar =
Application.CommandBars.Add("Test", 1, missing, true); } try { // Add a button to the
command bar and an event handler. firstButton =
(Office.CommandBarButton)commandBar.Controls.Add(1, missing, missing, missing, missing);
firstButton.Style = Office.MsoButtonStyle.msoButtonCaption; firstButton.Caption = "button 1";
firstButton.Tag = "button1"; firstButton.Click += new
Office._CommandBarButtonEvents_ClickEventHandler(ButtonClick); // Add a second button
to the command bar and an event handler. secondButton =
(Office.CommandBarButton)commandBar.Controls.Add(1, missing, missing, missing, missing);
secondButton.Style = Office.MsoButtonStyle.msoButtonCaption; secondButton.Caption =
"button 2"; secondButton.Tag = "button2"; secondButton.Click += new
Office._CommandBarButtonEvents_ClickEventHandler(ButtonClick); commandBar.Visible =
true; } catch (ArgumentException e) { MessageBox.Show(e.Message); } } // Handles the event
when a button on the new toolbar is clicked. private void
ButtonClick(Office.CommandBarButton ctrl, ref bool cancel) { MessageBox.Show("You clicked:
" + ctrl.Caption); }

Visual C# Consolidado 151


DESENVOLVIMENTO
CORPORATIVO (VISUAL C#)
Você pode programar em C# para desenvolver uma variedade de aplicativos corporativos,
executando em arquiteturas baseadas em servidor e produtos de servidor. A seção Servidores e
desenvolvimento da empresa da biblioteca MSDN contém a orientação de arquitetura,
informações de padrões e práticas, e documentação e artigos técnicos sobre o uso dos produtos
de servidor Microsoft, incluindo:
• O Microsoft SQL Server
• Microsoft BizTalk Server
• Servidor Microsoft Commerce
• Microsoft Content Management Server
• Microsoft Exchange Server
• Microsoft Host Integration Server
• Microsoft Internet Security and Acceleration Server 2000
• Microsoft Business Solutions
• Microsoft MapPoint
• Microsoft Speech Server

PROGRAMAÇÃO DO TABLET PC (VISUAL C#)


O Tablet PC é um computador pessoal suportado pelo Microsoft ® Windows ® XP que é voltado
para aplicativos que permitem a entrada por “ink”, caneta e voz. A combinação de software e
hardware em um Tablet PC permite esses métodos de interação do usuário e permite que uma
experiência de computação para usuários rica, interativa e produtiva.
A plataforma Tablet PC engloba o Windows XP e suas extensões que permitem entrada e saída
de dados de texto manuscrito e voz em um Tablet PC assim como o intercâmbio desses dados
com outros computadores.
Para obter mais informações, consulte Windows XP Tablet PC Edition no MSDN Online e o Centro
de Desenvolvimento Tablet e Mobile PC.

ÁUDIO, VÍDEO, JOGOS E ELEMENTOS GRÁFICOS


(VISUAL C#)
Você pode usar o Visual C# para criar aplicativos multimídia baseados no DirectX para
tecnologias Windows Media e Código Gerenciado.
O DirectX gerenciado
Microsoft® DirectX® é um conjunto avançado de interfaces de programação (API) de aplicativo
multimídia incorporados ao sistemas operacionais Microsoft Windows®. O DirectX fornece uma
plataforma de desenvolvimento padrão para PCs baseados no Windows permitindo aos
desenvolvedores de software acessarem recursos de hardware especializado sem precisar
escrever códigos específicos de hardware. Essa tecnologia primeiro foi apresentada em 1995 e é

Visual C# Consolidado 152


um padrão reconhecido para o desenvolvimento de aplicativos de multimídia na plataforma
Windows.
DirectX é uma tecnologia do Windows que permite maior desempenho em gráficos, incluindo
elementos gráficos em quatro cores, vídeo, e animação 3D, e som, incluindo som surround,
quando você está executando jogos ou assistindo vídeo no seu PC.
Para obter mais informações sobre o uso do DirectX em aplicativos C#, consulte DirectX 9.0 para
código gerenciado no MSDN Online e o Microsoft DirectX Developer Center.
O Windows Media Player
O controle Windows Media Player ActiveX pode ser usado em aplicativos C# para adicionar
capacidade de reprodução de áudio e vídeo. O Microsoft Windows Media Player 10 Software
Development Kit (SDK) fornece informações e ferramentas para personalizar o Windows Media
Player e para usar o controle Windows Media Player ActiveX. O SDK inclui documentação e
exemplos de códigos mostrando como usar o controle Media Player ActiveX de um aplicativo C#.
Para mais informações, consulte O Windows Media Player 10 SDK no MSDN Online.
Windows Media Encoder
O Windows Media Encoder 9 Series SDK pode ser programado usando C# para executar os
seguintes tipos de tarefas:
• Transmitir conteúdo ao vivo. Uma organização de notícias pode usar a Automation
API para agendar a captura automática e transmissão de conteúdo ao vivo. Por exemplo,
departamentos de transporte local podem transmitir imagens reais das condições de trânsito
em vários pontos críticos, alertando os motoristas dos congestionamento de tráfego e os
informando de rotas alternativas.
• Conteúdo de processamento em lote. Uma organização de produção de mídia
que deve processar um volume alto de arquivos grandes pode criar um processo em lotes que
usa a Automation API repetidamente para capturar e codificar fluxos, um após o outro. Uma
empresa pode usar a Automation API para gerenciar seus serviços de mídia de fluxo com uma
linguagem de script preferencial e o Windows Script Host. Windows Script Host é um host
independente de linguagem que pode ser usado para executar qualquer mecanismo de script
no Microsoft Windows® 95 ou posterior, Windows NT, ou sistemas operacionais Windows 2000
• Criar uma interface de usuário personalizada. Um provedor de serviço Internet
(ISP) pode criar uma interface que usa a funcionalidade da Automation API para capturar,
codificar, e transmitir fluxos de mídia. Como alternativa, você pode usar as interfaces de
usuário predefinidas dentro da Automation API para a mesma finalidade.
• Administrar aplicativos do Windows Media Encoder remotamente. Você
pode usar a Automation API para executar, solucionar problemas, e administrar aplicativos do
Windows Media Encoder em um computador remoto.
Para mais informações, consulte Windows Media Encoder 9 Series SDK no MSDN Online. O
tópico Programação C# descreve quais referências incluir ao trabalhar em C#.
O Windows Media Server
O Microsoft® Windows Media® Services 9 Series Software Development Kit (SDK) é uma
poderosa Application Programming Interface (API) baseada em automação projetada para
qualquer pessoa que deseje desenvolver um aplicativo Windows Media Services 9 Series. Você
pode usar este SDK no C# programaticamente para gerenciar um servidor do Windows Media
para enviar conteúdo de mídia digital a clientes em redes que permitem unicast e multicast. Para
mais informações, consulte Windows Media Services 9 Series SDK.

Visual C# Consolidado 153


CRIANDO STARTER KITS (VISUAL C#)
Um Starter Kit contém código para um aplicativo completo e documentação sobre como modificar
ou expandir o aplicativo. O Visual C# 2005 fornece dois Starter Kits que você pode acessar a
partir da caixa de diálogo New Project. Você também pode criar seus próprios Starter Kits para
ajudar os usuários obter e executar rapidamente em qualquer tipo de aplicativo. Criar um Starter
Kit é fundamentalmente o mesmo que criar um modelo de projeto normal, a única diferença é que
um Starter Kit contém arquivos de documentação que estão definidos para abrir um projeto com
base no Starter Kit quando for criado.
Para mais informações, consulte Introdução ao Starter Kits.

Visual C# Consolidado 154


MIGRANDO PARA O VISUAL C#
Esta seção apresenta sintaxe C# e conceitos para desenvolvedores que estiver migrando de
outras linguagens de programação. Ele também contém a documentação de referência do Java
conversão Assistente, que você pode usar para converter origem linguagem Java em Código fonte
C# idioma.

C# para desenvolvedores Java


Os tópicos nesta seção fornecem uma introdução à linguagem C# e o .NET Framework.
Nesta seção
• A linguagem de programação C# para desenvolvedores Java
• Exemplos de código C# para desenvolvedores Java
• Tipos de aplicativos C# para desenvolvedores Java

Convertendo aplicativos Java para Visual C#


Fornece Microsoft Visual Studio 2005 a capacidade para converter projetos criados no Visual J ++
®. ® versão 6.0 ou escrito em linguagem Java para Visual C# para que você pode tirar proveito do
.NET Framework Java Language Conversion Assistente gera um novo Visual C# projeto de um J
visual existente ++ 6.0 projeto ou idioma Java-arquivos. O assistente Java Language Conversion
assistente torna fácil a converter os arquivos existentes.

Para desenvolvedores C++ C#


A tabela a seguir contém importantes comparações entre C# e C++ nativo, que não usa /clr. Se
você for um programador C++, esta tabela permitirá que você as diferenças entre duas linguagens
de relance as mais importantes.

Observação
Projetos C# e C++ são derivados dos modelos de projetos diferentes. Para obter mais
informações sobre as diferenças entre projetos C++ e C#, consulte Gerenciamento item no
projetos e Usando Solution Explorer.

Recurso Consulte o tópico


Herança: em C++, classes e estruturas são praticamente idênticas Classe
enquanto em C#, eles são bem diferentes. Classes C# pode implementar Interface
qualquer número de interfaces, mas pode herdar de apenas uma classe struct (Referência do
base. Além disso, estruturas C# não oferece suporte a herança, e não C#)
oferecerem suporte para construtores padrão explícito (um é fornecida
por padrão).
Matrizes: em C++ uma matriz é simplesmente um ponteiro. No C#, Matrizes (Guia de
matrizes são objetos que incluem métodos e propriedades. Por exemplo, programação do C#)
o tamanho de uma matriz pode ser consultado via a Length propriedade. Indexadores (guia de
Matrizes C# também empregar Indexadores que verificam cada índice programação C#)
usado para acessar a matriz. A sintaxe de declaração matrizes C# é
diferente do idioma para matrizes C++: os símbolos [] " " aparecer após o
tipo de matriz no C#, não a variável.
Booleans: em C++, o bool tipo é essencialmente um inteiro. Em C#, há bool

Visual C# Consolidado 155


nenhuma conversão entre o bool tipo e outros tipos.
O long tipo enquanto em C++, ele está 32 bits.: em C#, o long tipo é 64 long
bits,
Passar parâmetros: em C++, todas as variáveis são passados por valor, struct
a menos que explicitamente passados com um ponteiro ou uma Classe
referência. Do ref no C#, classes são passados por referência e (referência) C# ref
estruturas são passadas pelo valor a menos que explicitamente Fora (referência C#)
passados por referência com ou out modificadores de parâmetro.
A switch instrução: ao contrário a instrução C++ switch, C# não oferece Alternar
suporte through fall-de um rótulo case para outro.
Representantes: representantes C# são aproximadamente semelhantes Delegar
aos indicadores de função em C++, são de tipo seguro e segura.
Métodos de classe base: C# oferece suporte a base palavra-chave para Base
chamar os membros de substituído classe base de classes derivadas. Consulte também os
Além disso, substituir métodos virtual ou abstract é explícito em C#, exemplos para
usando a override palavra-chave. Substituir
Ocultando método: C++ oferece suporte a implícito " ocultar " do método Novo
através de herança. Em C#, você deve usar o new modificador para
explicitamente ocultar um membros herdadas
Diretivas de pré-processamento são usadas para compilação Directives
condicional. Nenhum arquivo de cabeçalho são usados em C#. Preprocessor C#
A manipulação de exceção e exceção é acionada.: C# fornece palavra- finally try-
chave finally para fornecer para código que deve ser executado finally try-catch-
independentemente de se
Operadores C# e typeof.: C# oferece suporte, como is operadores & Operator
adicionais Ele também apresenta funcionalidade diferente para alguns Operador |
operadores lógicos. Operador ^
é
TypeOf
Palavra-chave extern: em C++, extern é usado para importar tipos. No extern
C#, extern é usada para criar aliases para usar versões diferentes do
mesmo conjunto.
Palavra-chave static: em C++, static pode ser usado tanto para declarar static
entidades nível de classe e para declarar tipos que são específicos para
um módulo. No C#, static só é usada para declarar entidades nível de
classe.
O Main método em C# é declarado de forma diferente da função main Main() e argumentos
em C++. Em C#, ele seja maiúscula e sempre static. Além disso, o de linha de comando
suporte para processamento de argumentos de linha de comando é (Guia de programação
muito mais robusta em C#. C#)
Ponteiros são permitidos em C#, mas somente no unsafe modo. Não seguro
Sobrecarga operadores será executada de maneira diferente em C#. Operadores C#
Seqüências: em C++ uma seqüência é simplesmente um arra de string
caracteres. Em C#, seqüências são objeto que oferecem suporte String
robustos métodos de pesquisa.
Palavra-chave foreach permite-lhe percorrer matrizes e coleções. foreach, em

Visual C# Consolidado 156


Globals: em C#, não há suporte para métodos globais e variáveis Estrutura geral de um
Métodos e variáveis precisa estar contidos em ou struct. um class programa C#
Importando Tipos: em C++, tipos comuns a vários módulos são Usando
colocados em arquivos de cabeçalho. No C#, essas informações está Visão Geral Sobre
disponíveis através de metadados. Metadados
Variáveis locais em C# não podem ser usadas antes que eles sejam Métodos (Guia de
inicializados. programação do C#)
Gerenciamento de memória: C++ não é uma linguagem de lixo coletado; Coleta de Lixo
memória que é não explicitamente Release permanece alocada até que
o processo termina. C# é uma linguagem de lixo coletado.
Destructors: C# tem sintaxe diferente para deterministically liberando Destructors
recursos não gerenciados. Instrução using
(Referência do C#)
Construtores: similar ao C++, se você não fornecer um construtor de Construtores da
classe em C#, um construtor padrão é gerado automaticamente para instância
você. O construtor padrão inicializa todos os campos para seus valores Tabela de valores
padrão. padrão
C# não oferece suporte campos Bit. Campos bit C++
Serviços de entrada / saída C# e formatação contam com a biblioteca de Tour linguagem C#
tempo de execução do .NET Framework. Formatação numérica
tabela de resultados
Em C#, parâmetros de método não podem ter valores padrão. Use Compilador CS0241 de
overloads método se você desejar obter o mesmo efeito. erro
Em C#, tipos genéricos e métodos fornecem para parametrização Tipo Generics em C#
de uma maneira que é semelhante aos modelos C++, embora existem
diferenças significativas.
Palavra-chave as é semelhante a um efeito padrão, exceto que em vez Como referência (C#)
de acionar uma exceção se falhar a conversão, o valor de retorno é nulo.
Isso é semelhante ao uso static_cast em C++, que,. diferente
dynamic_cast, executa nenhuma verificação em tempo de execução e,
portanto, não não acionar uma exceção na falha

Para obter mais informações sobre comparações entre palavras-chave em C# e outras linguagens
de programação, consulte Equivalentes do idioma. Para obter informações sobre a estrutura geral
do aplicativos C#, consulte Estrutura geral de um programa C# (guia de programação C#).

Visual C# Consolidado 157


GUIA DE PROGRAMAÇÃO C#
Esta seção fornece informações detalhadas sobre vários recursos chaves da linguagem C#
acessíveis através do .NET Framework.
Seções de idioma
Em um programa C#
Main() e argumentos de linha de comando (Guia de programação C#)
Tipos de dados (guia de programação C#)
Matrizes (Guia de programação do C#)
Seqüências (guia de programação C#)
Instruções, expressões, e operadores (guia de programação C#)
Objetos, classes e Structs (guia de programação C#)
Propriedades (Guia de programação do C#)
Indexadores (guia de programação C#)
Representantes (guia de programação C#)
Eventos (Guia de programação do C#)
Generics (Guia de programação C#)
Iterators (guia de programação C#)
Namespaces (Guia de programação C#)
Tipos anuláveis (guia de programação C#)
Não seguro código e ponteiros (guia de programação C#)
Comentários de documentação XML (Guia de programação C#)

Em um programa C#
A seção aborda a estrutura geral de um programa C#, e inclui o Exemplo padrão " Hello, World! ".
Nesta seção
• Hello world--seu programa primeiro (guia de programação C#)
• Estrutura geral de um programa C# (guia de programação C#)
Seções relacionadas
• Guia de Introdução ao Visual C#
• Migrando para o Visual C#
• Guia de Programação C#
• Referência C#
• Exemplos do Visual C#
Especificação da Linguagem C#
Para obter mais informações, consulte as seções a seguir no Especificação da Linguagem C#:
• Introdução 1

Visual C# Consolidado 158


Hello world-seu primeiro programa (guia de programação C#)
O seguinte programa Console é a versão do programa Tradicional do "Hello World!", que exibe a
seqüência Hello World! C#.
CSharp
using System; // A "Hello World!" program in C# namespace HelloWorld { class Hello { static void
Main() { System.Console.WriteLine("Hello World!"); } } }
Vamos agora examinar as partes importantes deste programa por sua vez.
Comentários
A primeira linha contém um comentário:
CSharp
// A "Hello World!" program in C#
Os caracteres // convertem o restante da linha em um comentário. Você também pode comentar
um bloco de texto, colocando-o entre os caracteres /* e */, por exemplo:
CSharp
/* A "Hello World!" program in C#. This program displays the string "Hello World!" on the screen.
*/
O método principal
O programa C# deve conter um método chamado Main, no qual o controle de execução inicia e
termina. O método Main é onde você cria objetos e executa outros métodos.
O método Main é um método static (estático) que reside em uma classe ou uma estrutura. No
Exemplo anterior "Hello World! ", ele reside em uma classe chamada Hello. Declare o método Main
de uma das maneiras a seguir:
• Podendo retornar void:
CSharp
static void Main() { //... }
• Podendo também retornar um int:
CSharp
static int Main() { //... return 0; }
• Com ambos os tipos de retorno, pode levar argumentos:
CSharp
static void Main(string[] args) { //... }
Ou-
CSharp
static int Main(string[] args) { //... return 0; }
O parâmetro do método Main é uma matriz (array) de string que representa os argumentos de
linha de comando usados para chamar o programa. Observe que, diferentemente C++, essa
matriz não inclui o nome do arquivo executável (EXE).
Para obter mais informações sobre como usar argumentos de linha de comando, consulte o
Exemplo em Main() e argumentos de linha de comando (Guia de programação C#) e COMO: Criar
e usar DLLs em C# (Guia de programação C#).
Entrada e Saída

Visual C# Consolidado 159


Programas C# geralmente usam os serviços de entrada / saída fornecidos pela Biblioteca de
tempo de execução do .NET Framework A instrução, System.Console.WriteLine("Hello World!");
usa o método WriteLine , um dos métodos de saída da classe Console na biblioteca de tempo de
execução. Ele exibe seu parâmetro de seqüência no fluxo de saída padrão seguido por uma nova
linha. Outros métodos da classe Console são usados para diversas operações de entrada e saída.
Se você incluir a diretiva using System;no início do programa, você pode usar as classes e
métodos do namespace System sem ter de referenciá-los totalmente. Por exemplo, você pode
chamar Console.WriteLine Em vez de, System.Console.Writeline:
CSharp
using System;
CSharp
Console.WriteLine("Hello World!");
Para obter mais informações sobre métodos de entrada / saída, consulte System.IO.
Compilação e execução
Você pode compilar o programa " Hello World! " Criando um projeto no Visual Studio IDE, ou
usando a linha de comando. Use o Prompt de Comandos do Visual Studio ou execute o arquivo
vsvars32.bat para colocar a ferramenta Visual C# definida no caminho do seu prompt de
comando.
Para compilar o programa a partir da linha de comando:
• Crie o arquivo de origem usando qualquer editor de texto e salvá-lo usando um nome,
como Hello.cs. Arquivos código fonte C# usam a extensão .cs.
• Para chamar o compilador, digite o comando:
csc Hello.cs
Se seu programa não contém quaisquer erros de compilação, um arquivo chamado Hello.exe
será criado.
• Para executar o programa, digite o comando:
Hello
Para obter mais informações sobre o compilador C# e suas opções, consulte Opções do
compilador C#.

Estrutura geral de um programa C# (guia de programação C#)


Programas C# podem consistir de um ou mais arquivos. Cada arquivo pode não conter espaços
para nome (namespaces), ou conter vários. Espaços para nome podem conter tipos, como
classes, estruturas, interfaces, enumerações, e representantes (delegates), além de outros
espaços. A seguir temos o esqueleto de um programa C# que contém todos esses elementos.
CSharp
// A skeleton of a C# program using System; namespace YourNamespace { class YourClass { }
struct YourStruct { } interface IYourInterface { } delegate int YourDelegate(); enum YourEnum { }
namespace YourNestedNamespace { struct YourStruct { } } class YourMainClass { static void
Main(string[] args) { //Your program starts here... } } }

Main() e argumentos de linha de comando (Guia de programação


C#)
O método Main é o ponto de entrada do seu programa, onde você cria objetos e chama outros
métodos. Só pode haver um único ponto de entrada em um programa C#.

Visual C# Consolidado 160


CSharp
class TestClass { static void Main(string[] args) { // Display the number of command line
arguments: System.Console.WriteLine(args.Length); } }
Visão Geral
• O Main método é o ponto de entrada do seu programa, onde o controle de execução do
programa inicia e termina.
Ele é declarado dentro de uma classe ou estrutura. Ele deve ser estático (static) e ele não deve
ser público. (No Exemplo acima, como não especificamos um modificador de acesso
explicitamente, ele recebe o modificador de acesso padrão, que é (private) particular).
• Ou ele pode retornar void ou então um tipo int.
• O método Main pode ser declarado com ou sem parâmetros.
• Parâmetros podem ser lidos como argumentos de linha de comando indexados a partir do
zero.
• Diferentemente C e C++, o nome do programa não é tratado como o primeiro argumento
de linha de comando.

Argumentos de linha de comando (guia de programação C#)


O Main método pode usar argumentos, nesse caso, é necessário uma das seguintes formas:
C#
static int Main(string[] args)
C#
static void Main(string[] args)
O parâmetro do método Main é uma String matriz que representa os argumentos de linha de
comando. Geralmente você verificar a existência dos argumentos testando a Length propriedade,
por exemplo:
C#
if (args.Length == 0) { System.Console.WriteLine("Please enter a numeric argument."); return
1; }
Você também pode converter os argumentos de seqüência para tipos numéricos, usando a
Convert classe ou o Parse método. Por exemplo, a instrução a seguir converte a seqüência em
um número longo, usando o Parse método na classe Int64:
long num = Int64.Parse(args[0]);
Também é possível para usar o tipo long C#, os aliases Int64:
long num = long.Parse(args[0]);
Você pode usar o Convert método ToInt64 de classe para fazer a mesma coisa:
long num = Convert.ToInt64(s);
Para obter mais informações, consulte Parse e Convert.
Exemplo
Neste exemplo, o programa leva um argumento em tempo de execução, converte o argumento em
um inteiro, e calcula o fatorial do número. Se nenhum argumento são fornecidos, o programa
emite uma mensagem que explica o uso correto do programa.
C#
// arguments: 3

Visual C# Consolidado 161


C#
public class Functions { public static long Factorial(int n) { if (n < 0) { return -1; } //error result
- undefined if (n > 256) { return -2; } //error result - input is too big if (n == 0) { return 1; } //
Calculate the factorial iteratively rather than recursively: long tempResult = 1; for (int i = 1; i <=
n; i++) { tempResult *= i; } return tempResult; } }
C#
class MainClass { static int Main(string[] args) { // Test if input arguments were supplied: if
(args.Length == 0) { System.Console.WriteLine("Please enter a numeric argument.");
System.Console.WriteLine("Usage: Factorial <num>"); return 1; } try { // Convert the input
arguments to numbers: int num = int.Parse(args[0]); System.Console.WriteLine("The Factorial
of {0} is {1}.", num, Functions.Factorial(num)); return 0; } catch (System.FormatException) {
System.Console.WriteLine("Please enter a numeric argument.");
System.Console.WriteLine("Usage: Factorial <num>"); return 1; } } }
Saída
The Factorial of 3 is 6.
Comentários
A seguir estão dois executa de Exemplo de programa assumindo o que é Factorial.exe o nome do
programa.
Execute # 1:
Insira a seguinte linha de comando:
Factorial 10
Você obtém o seguinte resultado:
The Factorial of 10 is 3628800.
Execute # 2:
Insira a seguinte linha de comando:
Factorial
Você obtém o seguinte resultado:
Please enter a numeric argument.
Usage: Factorial <num>

COMO: Exibir argumentos de linha de comando (Guia de


programação C#)
Argumentos fornecidos para um executável na linha de comando são acessíveis através um
parâmetro opcional para Main. Os argumentos são fornecidos na forma de uma matriz de
seqüências. Cada elemento da matriz contém um argumento. Espaço White-entre argumentos é
removido. Por exemplo, considere essas invocações de linha de comando de um executável
fictícia:

Entrada na linha de comando Matriz de seqüências de caracteres passado para principal


executable.exe a b c "a"
"b"
"c"
executable.exe one two " um "
" dois "
executable.exe “one two” three " dois " um

Visual C# Consolidado 162


" três "

Exemplo
Este Exemplo exibe os argumentos de linha de comando passados para um aplicativo de linha de
comando. O resultado mostrado é para a primeira entrada na tabela acima.
C#
class CommandLine { static void Main(string[] args) { // The Length property provides the
number of array elements System.Console.WriteLine("parameter count = {0}", args.Length); for
(int i = 0; i < args.Length; i++) { System.Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]); } } }
Saída
parameter count = 3 Arg[0] = [a] Arg[1] = [b] Arg[2] = [c]

COMO: Acessar argumentos de linha de comando usando


foreach (Guia de programação C#)
Outra abordagem para Iterando através da matriz é a usar a foreach instrução conforme mostrado
no exemplo. A foreach instrução pode ser usada para iterar por uma matriz, uma classe Coleção
.NET Framework, ou qualquer classe ou estrutura que implementa a IEnumerable interface.
Exemplo
Este Exemplo demonstra como imprimi-los os argumentos de linha de comando usando
foreach.
C#
// arguments: John Paul Mary
C#
class CommandLine2 { static void Main(string[] args) { System.Console.WriteLine("Number of
command line parameters = {0}", args.Length); foreach (string s in args) {
System.Console.WriteLine(s); } } }
Saída
Number of command line parameters = 3 John Paul Mary

Main() retorna valores (Guia de programação C#)


O Main método pode ser do tipo void:
C#
static void Main() { //... }
Ele também pode retornar um int:
C#
static int Main() { //... return 0; }
Se o valor de retorno da Main não deve ser usado, seguida, retornar void permite que código
ligeiramente mais simples. No entanto, retornar um inteiro permite que o programa para relacionar
informações de status para outros programas ou scripts que chamar o executável. Um Exemplo
de usar o valor de retorno da Main é mostrado no Exemplo a seguir.
Exemplo
Um arquivo em lotes, neste Exemplo é usado para executar um programa e testar o valor a Main
função de retorno. Quando um programa é executado no Windows, qualquer valor retornado da
Main função é armazenado em uma variável de ambiente chamada ERRORLEVEL. Ao inspecionar a

Visual C# Consolidado 163


ERRORLEVEL variável, arquivos em lotes portanto podem determinar o resultado da execução.
Tradicionalmente, um valor de retorno de zero indica execução com êxito. Abaixo é um programa
muito simples que retorna zero da função Main.
C#
class MainReturnValTest { static int Main() { //... return 0; } }
Como este Exemplo usa um arquivo em lotes, é melhor para compilar esse código a partir da linha
de comando, conforme demonstrado no Como construir a partir da linha de comando:.
Em seguida, um arquivo em lotes é usado para chamar o executável resultante do Exemplo de
código anterior. Porque o código retorna zero, o arquivo em lotes irá reportar êxito, mas se o
código anterior é alterado para retornar um valor diferente de zero, e é então re-Compiled,
subseqüente execução do arquivo em lotes indicará falha.
rem test.bat @echo off MainReturnValueTest @if "%ERRORLEVEL%" == "0" goto good :fail echo
Execution Failed echo return value = %ERRORLEVEL% goto end :good echo Execution Succeded
echo return value = %ERRORLEVEL% goto end :end
Saída de exemplo
Execution Succeded
return value = 0

Tipos de dados (guia de programação C#)


C# é uma linguagem altamente digitada; portanto cada variável e objeto deve ter um tipo
declarado.
Visão geral sobre tipos de dados
Um tipo de dados pode ser descrito como sendo um:
• Um tipo, como dados internos ou char, ou um int
• Um tipo, como dados definidos pelo usuário ou interface. um class
• Tipos de dados também podem ser definidos como sendo um:
• Tipos valor (referência C#) que armazenam valores, ou
• Tipos de referência (referência C#) que armazenam referências para os dados reais.
Seções relacionadas
Para obter mais informações:
• Projetando (guia de programação C#)
• Boxing e Unboxing (C# programação guia)
• Tipos (referência C#)
• Objetos, classes e Structs (guia de programação C#)
Especificação da Linguagem C#
Para obter mais informações sobre tipos, consulte as seções a seguir no Especificação da
Linguagem C#:
• Tipos 1.3 e variáveis
• Namespace 3.8 e nomes tipo
• Tipos valor 4.1
• Tipos de referência 4.2
• 4.3 Boxing e Unboxing

Visual C# Consolidado 164


MATRIZES (GUIA DE
PROGRAMAÇÃO DO C#)
Uma matriz é uma estrutura de dados que contém um número de variáveis do mesmo tipo.
Matrizes são declaradas com um tipo:
type[] arrayName;
Os exemplos a seguir criar matrizes dimensional única, multidimensional, e denteadas:
C#
class TestArraysClass { static void Main() { // Declare a single-dimensional array int[] array1 =
new int[5]; // Declare and set array element values int[] array2 = new int[] { 1, 3, 5, 7, 9 }; //
Alternative syntax int[] array3 = { 1, 2, 3, 4, 5, 6 }; // Declare a two dimensional array int[,]
multiDimensionalArray1 = new int[2, 3]; // Declare and set array element values int[,]
multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } }; // Declare a jagged array int[][] jaggedArray
= new int[6][]; // Set the values of the first array in the jagged array structure jaggedArray[0] =
new int[4] { 1, 2, 3, 4 }; } }
Visão geral de matriz
Uma matriz tem as seguintes propriedades:
• Pode ser Dimensional único uma matriz, Multidimensional ou Jagged.
• O valor padrão de elementos da matriz numérica são definidas como zero, e elementos de
referência são definidos como nulo.
• Uma matriz denteada é uma matriz de matrizes, e portanto seus elementos são tipos de
referência e são inicializados para null.
• Matrizes forem zero indexado: uma matriz com n elementos é indexada a partir 0 para n-1.
• Elementos de matriz podem ser de qualquer tipo, incluindo um tipo de matriz.
• Tipos de matriz são Tipos de referência derivados do tipo Array base abstrato. Desde isso
e IEnumerable implementa IEnumerable Tipo, você pode utilizar foreach iteração em todas as
matrizes em C#.

Matrizes como objetos (guia de programação C#)


No C#, matrizes são realmente objetos, e não apenas endereçáveis regiões de memória contígua
como em C e C++. é Array o tipo base abstrato de todos os tipos de matriz. Você pode usar as
propriedades, e outros membros da classe, que Array tem. Um Exemplo disso deve estar
usando a Length propriedade para obter o comprimento de uma matriz. O código a seguir atribui o
comprimento da matriz numbers, que é 5, a uma variável chamada lengthOfNumbers:
C#
int[] numbers = { 1, 2, 3, 4, 5 }; int lengthOfNumbers = numbers.Length;
A System.Array classe fornece vários outros útil métodos e propriedades para classificação,
pesquisa, e copiando matrizes.
Exemplo
Este Exemplo usa a Rank propriedade para exibir o número de dimensões de uma matriz.
C#
class TestArraysClass { static void Main() { // Declare and initialize an array: int[,] theArray =
new int[5, 10]; System.Console.WriteLine("The array has {0} dimensions.", theArray.Rank); } }

Visual C# Consolidado 165


Saída
The array has 2 dimensions.

Matrizes multidimensionais (guia de programação C#)


Matrizes podem ter mais de uma dimensão. Por exemplo, a declaração a seguir cria uma matriz
bidimensional de quatro linhas e duas colunas:
C#
int[,] array = new int[4, 2];
Além disso, a declaração a seguir cria uma matriz de três dimensões, 4, 2 e 3:
C#
int[, ,] array1 = new int[4, 2, 3];
Inicialização de matriz
Você pode inicializar a matriz na declaração conforme mostrado no Exemplo o seguir:
C#
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; int[, ,] array3D = new int[,,] { { { 1,
2, 3 } }, { { 4, 5, 6 } } };
Você também pode inicializar a matriz sem especificar a classificação:
C#
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
Se você optar por declarar uma variável de matriz sem a inicialização, você deve usar o new
operador para atribuir uma matriz à variável Por exemplo:
C#
int[,] array5; array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; // OK //array5 = {{1,2},
{3,4}, {5,6}, {7,8}}; // Error
Você também pode atribuir um valor a um elemento de matriz, por exemplo:
C#
array5[2, 1] = 25;
O Exemplo de código a seguir inicializa as variáveis de matriz como padrão (exceto para
denteadas matrizes):
C#
int[,] array6 = new int[10, 10];

Matrizes passagem como parâmetros (guia de programação C#)


Matrizes podem ser passados para métodos como parâmetros. Como matrizes são tipos de
referência, o método pode alterar o valor dos elementos.
Passando matrizes dimensional única como parâmetros
Você pode passar uma matriz dimensional única inicializado para um método. Por exemplo:
C#
PrintArray(theArray);
O método chamado na linha acima poderia ser definido como:
C#
void PrintArray(int[] arr) { // method code }

Visual C# Consolidado 166


Você também pode inicializar e passa uma nova matriz em uma etapa Por exemplo:
C#
PrintArray(new int[] { 1, 3, 5, 7, 9 });
Exemplo 1
Descrição
No Exemplo a seguir, a uma matriz de seqüência de caracteres é inicializado e passado como um
parâmetro para o PrintArray método, onde seus elementos são exibidos:
Código
C#
class ArrayClass { static void PrintArray(string[] arr) { for (int i = 0; i < arr.Length; i++) {
System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : ""); } System.Console.WriteLine();
} static void Main() { // Declare and initialize an array: string[] weekDays = new string[] {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; // Pass the array as a parameter:
PrintArray(weekDays); } }
Saída 1
Sun Mon Tue Wed Thu Fri Sat
Passando Matrizes multidimensionais como parâmetros
Você pode passar uma matriz multidimensional inicializado para um método. Por exemplo, matriz
dimensional for theArray Um dois:
C#
PrintArray(theArray);
O método chamado na linha acima poderia ser definido como:
C#
void PrintArray(int[,] arr) { // method code }
Você também pode inicializar e passa uma nova matriz em uma etapa Por exemplo:
C#
PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
Exemplo 2
Descrição
Neste exemplo, uma matriz bidimensional é inicializado e passada para o PrintArray método,
onde seus elementos são exibidos.
Código
C#
class ArrayClass2D { static void PrintArray(int[,] arr) { // Display the array elements: for (int i =
0; i < 4; i++) { for (int j = 0; j < 2; j++) { System.Console.WriteLine("Element({0},{1})={2}", i, j,
arr[i, j]); } } } static void Main() { // Pass the array as a parameter: PrintArray(new int[,] { { 1, 2
}, { 3, 4 }, { 5, 6 }, { 7, 8 } }); } }
Saída 2
Element(0,0)=1
Element(0,1)=2
Element(1,0)=3
Element(1,1)=4
Element(2,0)=5

Visual C# Consolidado 167


Element(2,1)=6
Element(3,0)=7
Element(3,1)=8

Passando REF usando matrizes e out (guia programação C#)


Todos os Limite parâmetros, como um out parâmetro de um tipo de matriz deve ser atribuído
antes que ela é usada; ou seja, ele deve ser atribuído pelo chamado. Por exemplo:
C#
static void TestMethod1(out int[] arr) { arr = new int[10]; // definite assignment of arr }
Como todos os Ref parâmetros, um ref parâmetro de um tipo de matriz deve ser atribuído pelo
chamador definitivamente. Portanto, não é necessário para serem atribuídos pelo chamado
definitivamente. Um ref parâmetro de um tipo de matriz pode ser alterado como resultado da
chamada. Por exemplo, a matriz pode ser atribuído o Nulo valor ou podem ser inicializados para
uma matriz diferente. Por exemplo:
C#
static void TestMethod2(ref int[] arr) { arr = new int[10]; // arr initialized to a different array }
Os seguintes exemplos dois demonstram a diferença entre out e ref quando usada em passar
matrizes para métodos.
Exemplo 1
Neste exemplo, a matriz theArray é declarado no chamador (o Main método), e inicializado no
método FillArray. Em seguida, os elementos da matriz são retornados para o chamador e
exibido.
C#
class TestOut { static void FillArray(out int[] arr) { // Initialize the array: arr = new int[5] { 1, 2,
3, 4, 5 }; } static void Main() { int[] theArray; // Initialization is not required // Pass the array to
the callee using out: FillArray(out theArray); // Display the array elements:
System.Console.WriteLine("Array elements are:"); for (int i = 0; i < theArray.Length; i++) {
System.Console.Write(theArray[i] + " "); } } }
Saída 1
Array elements are:
12345
Exemplo 2
Neste exemplo, a matriz theArray é inicializado no chamador (o Main método), e passada para o
FillArray método usando o ref parâmetro. Algumas dos elementos da matriz são atualizadas no
método FillArray. Em seguida, os elementos da matriz são retornados para o chamador e
exibido.
C#
class TestRef { static void FillArray(ref int[] arr) { // Create the array on demand: if (arr == null)
{ arr = new int[10]; } // Fill the array: arr[0] = 1111; arr[4] = 5555; } static void Main() { //
Initialize the array: int[] theArray = { 1, 2, 3, 4, 5 }; // Pass the array using ref: FillArray(ref
theArray); // Display the updated array: System.Console.WriteLine("Array elements are:"); for
(int i = 0; i < theArray.Length; i++) { System.Console.Write(theArray[i] + " "); } } }
Saída 2
Array elements are:
1111 2 3 4 5555

Visual C# Consolidado 168


Exemplo matrizes
Download sample
Este Exemplo descreve e mostra como matrizes funcionam em C#. Para obter mais informações,
consulte Matrizes (Guia de programação do C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo matrizes no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo matrizes a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc arrays.cs arrays

Seqüências (guia de programação C#)


As seções a seguir discutem o string tipo de dados, que é um alias para a String classe.

Usando Strings (guia de programação C#)


Uma seqüência C# é uma matriz de caracteres declarado usando a string palavra-chave. Uma
seqüência de caracteres literal é declarada usar aspas, como mostrado no Exemplo a seguir:
C#
string s = "Hello, World!";
Você pode extrair substrings, e concatenar seqüências, como este:
C#

Visual C# Consolidado 169


string s1 = "orange"; string s2 = "red"; s1 += s2; System.Console.WriteLine(s1); // outputs
"orangered" s1 = s1.Substring(2, 5); System.Console.WriteLine(s1); // outputs "anger"
Objetos seqüência são imutável, significando que eles não podem ser alterados uma vez que
tenha sido criada. Métodos que atuam em seqüências realmente retornam novos objetos de
seqüência. No Exemplo anterior, quando o conteúdo de s1 e s2 são concatenadas para formar uma
única seqüência, as duas seqüências contendo "orange" e "red" são mantidos inalterados ambos. O
+= operador cria uma nova seqüência contendo o conteúdo combinados. O resultado é que s1 se
refere a uma seqüência diferente totalmente agora. Uma seqüência contendo apenas "orange"
ainda existe, mas não é referenciado quando s1 é concatenada.
Portanto, por razões de desempenho, grandes quantidades de concatenação ou outra
manipulação de seqüência de caracteres envolvidos devem ser executadas com a StringBuilder
classe, como este:
C#
System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("one ");
sb.Append("two "); sb.Append("three"); string str = sb.ToString();
A StringBuilder classe é discutida mais na seção " StringBuilder usando ".
Trabalhando com seqüências
Escape caracteres
Escape caracteres, como " \n " (nova linha) e " \t " (guia) pode ser incluídas em seqüências. A
linha:
C#
string hello = "Hello\nWorld!";
é o mesmo que:
Hello
World!
Se você desejar incluir uma barra com versões anteriores, ele deve ser precedido com outro
invertida. A seqüência a seguir:
C#
string filePath = "\\\\My Documents\\";
é realmente o mesmo que:
\\My Documents\
O símbolo @
O @ Símbolo informa o Construtor de seqüência para ignorar caracteres de escape e quebras de
linha. As seguintes seqüências duas são portanto idênticas:
C#
string p1 = "\\\\My Documents\\My Files\\"; string p2 = @"\\My Documents\My Files\";

ToString()
Como todos os objetos derivados Object, seqüências fornecem o ToString método, que converte
um valor em uma seqüência. Este método pode ser usado para converter valores numéricos em
seqüências, como este:
C#
int year = 1999; string msg = "Eve was born in " + year.ToString(); System.Console.WriteLine(msg); //
outputs "Eve was born in 1999"

Visual C# Consolidado 170


Acessando caracteres individuais
Caracteres individuais contidos em uma seqüência de caracteres podem ser acessados usando
métodos, como SubString(), Replace(), Split() e Trim().
C#
string s3 = "Visual C# Express"; System.Console.WriteLine(s3.Substring(7, 2)); // outputs "C#"
System.Console.WriteLine(s3.Replace("C#", "Basic")); // outputs "Visual Basic Express"
Também é possível para copiar os caracteres em uma matriz de caracteres, como este:
C#
string s4 = "Hello, World"; char[] arr = s4.ToCharArray(0, s4.Length); foreach (char c in arr) {
System.Console.Write(c); // outputs "Hello, World" }
Caracteres individuais de uma seqüência podem ser acessados com um índice, como este:
C#
string s5 = "Printing backwards"; for (int i = 0; i < s5.Length; i++) {
System.Console.Write(s5[s5.Length - i - 1]); // outputs "sdrawkcab gnitnirP" }
Alterando a Caixa
Para alterar as letras em uma seqüência para superior ou minúsculas, use ToUpper() ou
ToLower(), como isso:
C#
string s6 = "Battle of Hastings, 1066"; System.Console.WriteLine(s6.ToUpper()); // outputs
"BATTLE OF HASTINGS 1066" System.Console.WriteLine(s6.ToLower()); // outputs "battle of
hastings 1066"

Comparações
Do == a maneira mais simples para comparar duas seqüências é para usar e != operadores,
que executar uma comparação que diferencie maiúsculas de minúsculas.
C#
string color1 = "red"; string color2 = "green"; string color3 = "red"; if (color1 == color3) {
System.Console.WriteLine("Equal"); } if (color1 != color2) { System.Console.WriteLine("Not
equal"); }
Objetos seqüência também ter um CompareTo() método que retorna um valor inteiro com base
em se uma seqüência é menos-(<)or greater-than (>) que outra . Ao comparar seqüências, o valor
Unicode é usado, e minúsculo tem um valor menor que maiúsculo.
C#
string s7 = "ABC"; string s8 = "abc"; if (s7.CompareTo(s8) > 0) {
System.Console.WriteLine("Greater-than"); } else { System.Console.WriteLine("Less-than"); }
Para procurar por uma seqüência dentro outra seqüência, use IndexOf(). Retorna
IndexOf()-1 se a seqüência de pesquisa não encontrada; caso contrário, ele retorna o índice do
primeiro local em que ele ocorre baseada em zero.
C#
string s9 = "Battle of Hastings, 1066"; System.Console.WriteLine(s9.IndexOf("Hastings")); // outputs 10
System.Console.WriteLine(s9.IndexOf("1967")); // outputs -1
Dividindo um string em Substrings
Dividir uma seqüência em substrings —, como dividindo uma frase em palavras — individuais é
uma tarefa de programação comuns. O Split() método utiliza uma char matriz de delimitadores,

Visual C# Consolidado 171


por exemplo, um caractere de espaço, e retorna uma matriz de substrings. Você pode acessar
essa matriz com foreach, como este:
C#
char[] delimit = new char[] { ' ' }; string s10 = "The cat sat on the mat."; foreach (string substr in
s10.Split(delimit)) { System.Console.WriteLine(substr); }
Esse código saídas cada palavra em uma linha separada, como este:
The
cat
sat
on
the
mat.
Usando StringBuilder
A StringBuilder classe cria um buffer de seqüência que oferece melhor desempenho se seu
programa executa uma grande quantidade de manipulação de seqüência de caracteres. A
StringBuilder seqüência também permite que você para reatribuir caracteres individuais, algo
que o tipo de dados de seqüência interna não oferece suporte. Esse código, por exemplo, altera o
conteúdo de uma seqüência sem criar uma nova seqüência:
C#
System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet"); sb[0] = 'C';
System.Console.WriteLine(sb.ToString()); System.Console.ReadLine();
Neste exemplo, um StringBuilder objeto é usado para criar uma seqüência de um conjunto de
tipos numéricos:
C#
class TestStringBuilder { static void Main() { System.Text.StringBuilder sb = new
System.Text.StringBuilder(); // Create a string composed of numbers 0 - 9 for (int i = 0; i < 10;
i++) { sb.Append(i.ToString()); } System.Console.WriteLine(sb); // displays 0123456789 //
Copy one character of the string (not possible with a System.String) sb[0] = sb[9];
System.Console.WriteLine(sb); // displays 9123456789 } }

Visual C# Consolidado 172


ESPECIFICAÇÃO DA LINGUAGEM
C#
As versões 1.2 e 2.0 das especificações da linguagem C# são a fonte autorizada de gramática e
sintaxe C#. Elas contêm informações detalhadas sobre todos os aspectos da linguagem, incluindo
muitos pontos não abordados na documentação do produto Visual C#.
A especificação 1.2 discute recursos que foram adicionados para a linguagem antes do Visual C#
2005 e a especificação 2.0 discute recursos que foram adicionados para o Visual C# 2005.
As especificações da linguagem C# estão disponíveis no formato Microsoft Word nos seguintes
locais:
• No MSDN Online em
http://msdn.microsoft.com/vcsharp/Programming/Language/default.aspx
• No Visual Studio, na pasta VC#\Specifications\1033\ sob o diretório de instalação
do seu Microsoft Visual Studio 2005 .
Se você não tiver o Microsoft Word instalado em seu computador, você pode visualizar, copiar e
imprimir a versão do Word da especificação com o gratuito Palavra visualizador 2003.
A especificação da linguagem C# também está disponível como um livro publicado pelo Addison
Wesley.

Visual C# Consolidado 173


REFERÊNCIA C#
Esta seção fornece material de referência para as palavras-chave do C#, operadores, erros de
compilador e avisos.

Palavras-chave C#
Palavras-chave são identificadores reservados que têm significado especial para o compilador.
Eles não podem ser usados como identificadores em seu programa a menos que incluam @ como
um prefixo. Por exemplo, @if é um identificador válido mas if não, porque é uma palavra-chave.

abstract event new struct


as explicit null switch
base extern object this
bool false operator throw
break finally out true
byte fixed override try
case foat params typeof
catch for private uint
char foreach protected uong
checked goto public unchecked
class if readonly unsafe
const implicit ref ushort
continue in return using
decimal int sbyte virtual
default interface sealed volatile
delegate internal short void
do is sizeof while
double ock stackaloc
else ong static
enum namespace string

Palavras-chave contextuais

Obter parcial Definir


Valor Onde Produzir

Palavra-chave abstract
O modificador abstract pode utilizar com classes, métodos, propriedades, indicadores e
eventos.

Visual C# Consolidado 174


Utilize o modificador abstract em uma declaração de classe se deseja indicar que a classe só
deve atuar como classe-base de outras classes.
As classes do tipo abstract apresentam as seguintes características:
• Não podem se criar instancias de uma classe abstrata.
• Uma classe abstrata pode conter descritores de acesso e métodos abstratos.
• Não é possível modificar uma classe abstrata com o modificador sealed, o qual significa que
a classe não pode heredar.
• Uma classe não abstrata derivada de uma classe abstrata deve incluir implementações
reales de todos os descritores de acesso e métodos abstratos herdados.
Utilize o modificador abstract em uma declaração de método ou propriedade para indicar que o
método ou a propriedade não contém implementação.
Os métodos abstratos apresentam as seguintes características:
• Um método abstrato é, implícitamente, um método virtual.
• As declarações de métodos abstratos só é permitido em classes abstratas.
• Como uma declaração de método abstrato não proporciona uma implementação, não existe
corpo do método; a declaração de método finaliza simplemente com um ponto e vírgua e sem
chaves ({ }) depois da firma. Por exemplo:

public abstract void MyMethod();


• A implementação a proporciona um método de reemplazo, o qual é um membro de uma
classe não abstrata.
• Utilizar os modificadores static ou virtual em uma declaração de método abstrato
produza um erro.
As propriedades abstratas funcionam como os métodos abstratos, salvo as diferenças na sintaxis
das declarações e chamadas.
• É incorreto utilizar o modificador abstract em uma propriedade estática.
• Uma propriedade abstrata herdada pode substituir em uma classe derivada se se inclui uma
declaração de propriedade que use o modificador override.
Uma classe abstrata deve proporcionar implementações para todos os membros da interface.
Uma classe abstrata que implementa uma interface poderia assinalar os métodos da interface os
métodos abstratos. Por exemplo:
interface I
{
void M();
}
abstract class C: I
{
public abstract void M();
}
Exemplo
Neste exemplo, a classe MyDerivedC é derivada de uma classe abstrata MyBaseC. A classe
abstrata contém um método abstrato, MyMethod(), e duas propriedades abstratas, GetX() e
GetY().
// abstract_keyword.cs
// Abstract Classes

Visual C# Consolidado 175


using System;
abstract class MyBaseC // Abstract class
{
protected int x = 100;
protected int e = 150;
public abstract void MyMethod(); // Abstract method

public abstract int GetX // Abstract property


{
get;
}

public abstract int GetY // Abstract property


{
get;
}
}
class MyDerivedC: MyBaseC
{
public override void MyMethod()
{
x++;
y++;
}
public override int GetX // overriding property
{
get
{
return x+10;
}
}
public override int GetY // overriding property
{
get
{
return y+10;
}
}
public static void Main()
{
MyDerivedC mC = new MyDerivedC();
mC.MyMethod();
Console.WriteLine("x = {0}, e = {1}", mC.GetX, mC.GetY);
}
}
Resultado
x = 111, e = 161
No Exemplo anterior, se intenta criar uma instancia da classe abstrata mediante uma instrução
como a seguinte:
MyBaseC mC1 = new MyBaseC(); // Erro
obterá a seguinte mensagem de erro:

Visual C# Consolidado 176


Cannot criate an instance of the abstract class 'MyBaseC'.

Palavra-chave event
Especifica um evento.
[attributes] [modifiers] e v e n t type declarator;
[attributes] [modifiers] e v e n t type member-name { accessor-declarations} ;
de onde:
attributes (opcional)
modifiers (opcional)
• Modificadores opcionais, entre os que se incluem:
• abstract
• new
• override
• static
• virtual
• extern
• um dos quatro modificadores de acesso
type
Tipo delegado ao qual se deseja associar este evento.
declarator
• Mome do evento.
member-name
• Mome do evento.
accessor-declarations (opcional)
Declaração de os descritores de acesso , os quais se utilizam para agregar ou quitar
controladores de eventos no código cliente. As funções para descritores de acesso são add e
remove. Definir só uma de elas produza um erro.
Comentarios
A palavra-chave event permite especificar um delegado ao qual se invocará quando ocorra
algum "evento" no código. o delegado pode ter ou não o varios métodos asociados a os que se
chamará quando o código indique que o evento se ha producido. É possível poner um evento de
qualquer programa a disposição de outros programas que utilizem Common Language Runtime
do .NET Framework.
Para criar e utilizar eventos do C#, siga os seguintes pasos:
Crie ou identifique um delegado. Se está definindo um evento propio, também deve asegurarse de
que existe um delegado que possa utilizar com a palavra-chave event. Se o evento está
predefinido, por Exemplo em .NET Framework, entonces os consumidores do evento só
necessitan conhecer o nome do delegado.
1. Crie uma classe que contenha:
a. Um evento criado desde o delegado.
b. Um método que comprova se existe uma instancia do delegado declarado com a
palavra-chave event (este método é opcional). outra opção consiste em inserir este
fragmento de código dentro do código que produza o evento.

Visual C# Consolidado 177


c. Os métodos que chaman ao evento. Estes métodos podem ser reemplazos de cierta
funcionalidad da classe-base.
Esta classe define ou evento.
2. Defina ao menos uma classe que conecte os métodos com o evento. Cada uma de estas
classes incluirá o seguinte:
• A asociação de unão ou varios métodos, mediante os operadores += e -=, com o
evento na classe-base.
• A definição de os métodos que se asociarão com o evento.
3. Utilize ou evento:
• Crie um objeto da classe que contém a declaração do evento.
• Crie um objeto da classe que contém a definição do evento, mediante ou construtor
que definiu.

Resultado
Exemplo 1
Este Exemplo mostra que é possível declarar um evento em uma interface e implementá-lo em
uma classe:
// event_keyword.cs
using System;
public delegate void MyDelegate(); // delegate declaration

public interface I
{
event MyDelegate MyEvent;
void FireAway();
}
public class MyClass: I
{
public event MyDelegate MyEvent;

public void FireAway()


{
if (MyEvent != null)
MyEvent();
}
}
public class MainClass
{
static private void f()
{
Console.WriteLine("This is called whem the event fires.");
}

static public void Main ()


{
I i = new MyClass();

i.MyEvent += new MyDelegate(f);


i.FireAway();

Visual C# Consolidado 178


}
}

Exemplo 2
Unão de os usos daccessor-declarations consiste em exponer um gram número de eventos
sem ter que assinalar um campo para cada evento, sinão utilizando em seu lugar uma taba hash
que almacene as instancias de os eventos. Isto só resulta útil se se dispõe de um gram número de
eventos, pois se preves que a maioría de os eventos não se implementarão.
// event_keyword2.cs
using System;
using System.Collections;

public delegate void MyDelegate1(int i);


public delegate void MyDelegate2(string s);
public delegate void MyDelegate3(int i, object o);
public delegate void MyDelegate4();
public class PropertyEventsSample
{
private Hashtable eventTable = new Hashtable();

public event MyDelegate1 Event1


{
add
{
eventTable["Event1"] = (MyDelegate1)eventTable["Event1"] + value;
}
remove
{
eventTable["Event1"] = (MyDelegate1)eventTable["Event1"] - value;
}
}
public event MyDelegate1 Event2
{
add
{
eventTable["Event2"] = (MyDelegate1)eventTable["Event2"] + value;
}
remove
{
eventTable["Event2"] = (MyDelegate1)eventTable["Event2"] - value;
}
}
public event MyDelegate2 Event3
{
add
{
eventTable["Event3"] = (MyDelegate2)eventTable["Event3"] + value;
}
remove
{
eventTable["Event3"] = (MyDelegate2)eventTable["Event3"] - value;
}

Visual C# Consolidado 179


}
public event MyDelegate3 Event4
{
add
{
eventTable["Event4"] = (MyDelegate3)eventTable["Event4"] + value;
}
remove
{
eventTable["Event4"] = (MyDelegate3)eventTable["Event4"] - value;
}
}
public event MyDelegate3 Event5
{
add
{
eventTable["Event5"] = (MyDelegate3)eventTable["Event5"] + value;
}
remove
{
eventTable["Event5"] = (MyDelegate3)eventTable["Event5"] - value;
}
}
public event MyDelegate4 Event6
{
add
{
eventTable["Event6"] = (MyDelegate4)eventTable["Event6"] + value;
}
remove
{
eventTable["Event6"] = (MyDelegate4)eventTable["Event6"] - value;
}
}
}
public class MyClass
{
public static void Main()
{
}
}
Exemplo 3
Outro uso das propriedades de eventos contempla o caso no que se implementam duas
interfaces, cada uma com um evento do mesmo nome. Nesse caso, deve utilizar uma propriedade
de evento de implementação explícita:

// event_keyword3.cs
using System;

public delegate void MyDelegate1();

public interface I1

Visual C# Consolidado 180


{
event MyDelegate1 MyEvent;
}
public delegate int MyDelegate2(string s);

public interface I2
{
event MyDelegate2 MyEvent;
}
public class ExplicitEventsSample: I1, I2
{
public event MyDelegate1 MyEvent; // normal implementation of I1.MyEvent.

event MyDelegate2 I2.MyEvent // explicit implementation of I2.MyEvent


{
add
{
MyEvent2Storage += value;
}
remove
{
MyEvent2Storage -= value;
}
}
private MyDelegate2 MyEvent2Storage; // underlying storage for I2.MyEvent.

private void FireEvents()


{
if (MyEvent != null)
MyEvent();
if (MyEvent2Storage != null)
MyEvent2Storage("helo");
}
}
public class MyClass
{
public static void Main()
{
}
}

Palavra-chave new
Em C#, a palavra-chave new pode utilizar como operador ou como modificador.
• Operador new é utilizado para criar objetos na pilha e invocar construtores.
• Modificador new é utilizado para ocultar um membro herdado de um membro de classe-
base.

OPERADOR NEW
O operador new é utilizado para criar objetos e invocar construtores, por exemplo:
Class1 MyClass = new Class1();

Visual C# Consolidado 181


Também é utilizado com o fim de invocar o construtor predeterminado para tipos de valores, por
exemplo:
int myInt = new int();
Na instrução anterior se inicializa myInt com o valor 0, que é ou predeterminado para o tipo int.
Essa instrução tno mesmo efeito que:
int myInt = 0;
Lembre que é um erro declarar um construtor predeterminado para um tipo struct, já que todos os
tipos de valores posuem implícitamente um construtor público predeterminado. Não obstante, se
podem se declarar construtores com parâmetros para um tipo struct.
Os objetos do tipo valor, tais como as estruturas, são criados na pilha, enquanto que os objetos do
tipo referencia, tais como as classes, são criados na pilha.
O operador new não pode sobrecargar.
Se o operador new fala na assinalação de memoria, iniciará a exceção
OutOfMemoryException.
Exemplo
No seguinte exemplo, são criados e se inicializam, mediante o operador new, um objeto struct e
um objeto class y, a continuação, se lhes assinalam valores. Os valores predeterminados e
assinalados se mostram em tela.
// cs_operator_new.cs
// The new operator
using System;
class NewTest
{
struct MyStruct
{
public int x;
public int y;
public MyStruct (int x, int y)
{
this.x = x;
this.y = y;
}
}
class MyClass
{
public string name;
public int id;

public MyClass ()
{
}

Visual C# Consolidado 182


public MyClass (int id, string name)
{
this.id = id;
this.name = name;
}
}

public static void Main()


{
// Criate objects using default construtors:
MyStruct Ocation1 = new MyStruct();
MyClass Empoyee1 = new MyClass();

// Display values:
Console.WriteLine("Default values:");
Console.WriteLine(" Struct members: {0}, {1}",
Ocation1.x, Ocation1.y);
Console.WriteLine(" Class members: {0}, {1}",
Empoyee1.name, Empoyee1.id);

// Criate objects using parameterized construtors::


MyStruct Ocation2 = new MyStruct(10, 20);
MyClass Empoyee2 = new MyClass(1234, "John Martin Smith");

// Display values:
Console.WriteLine("Assigned values:");
Console.WriteLine(" Struct members: {0}, {1}",
Ocation2.x, Ocation2.y);
Console.WriteLine(" Class members: {0}, {1}",
Empoyee2.name, Empoyee2.id);
}
}
Resultado
Default values:
Struct members: 0, 0
Class members: , 0
Assigned values:
Struct members: 10, 20

Visual C# Consolidado 183


Class members: John Martin Smith, 1234
Observe no Exemplo que o valor predeterminado de uma série é null. Por tanto, não se mostra
em tela.

MODIFICADOR NEW
Use o modificador new para ocultar explícitamente um membro herdado de uma classe-base.
Para ocultar um membro herdado, declare-o na classe derivada com o mesmo mome e modifique-
o com o modificador new.
Considere a seguinte classe:
public class MyBaseC
{
public int x;
public void Invoke() {}
}
Ao declarar um membro com o nome Invoke em uma classe derivada se ocultará o método
Invoke na classe-base, assim:
public class MyDerivedC : MyBaseC
{
new public void Invoke() {}
}
Mas, o campo x não será afetado, já que não oculta nenhum mome similar.
A ocultação de nomes por meio da herança toma uma das seguintes formas:
• Constante, campo, propriedade ou tipo introduzido em uma classe ou estrutura que oculta
todos os membros da classe-base com o mesmo nome.
• Método introduzido em uma classe o estrutura que oculta propriedades, campos e tipos, com
o mesmo nome, na classe-base. Também oculta todos os métodos da classe-base com a mesma
firma. Para obter mais informação, veja 3.6 Firmas e sobrecarga.
• Indicador introduzido em uma classe o estrutura que oculta todos os indicadores da classe-
base com a mesma firma.
É incorreto utilizar simultáneamente new e override no mesmo membro.
Se é utilizada o modificador new em uma declaração que não oculta um membro herdado, se
gera uma advertencia.
Exemplo
Neste exemplo, uma classe-base, MyBaseC, e uma classe derivada, MyDerivedC, utilizam o
mesmo mome de campo x, o que produza a ocultação do valor do campo herdado. o Exemplo
demostra o uso do modificador new. Também mostra como obter acesso a os membros ocultos
da classe-base mediante sus nomes completos.
// cs_modifier_new.cs
// The new modifier
using System;
public class MyBaseC
{
public static int x = 55;

Visual C# Consolidado 184


public static int e = 22;
}

public class MyDerivedC : MyBaseC


{
new public static int x = 100; // Name hiding
public static void Main()
{
// Display the overlapping value of x:
Console.WriteLine(x);

// Access the hiddem value of x:


Console.WriteLine(MyBaseC.x);

// Display the unhiddem member y:


Console.WriteLine(y);
}
}
Resultado
100
55
22
Se elimina o modificador new, ou programa seguirá compilándose e executándose, pois se obterá a
advertencia:
The keyword new is required on 'MyDerivedC.x' because it hides
inherited member 'MyBaseC.x'.
Também pode utilizar o modificador new para modificar um tipo anidado, Se o tipo anidado está
ocultando outro tipo, como se mostra no seguinte exemplo.
Exemplo
Neste exemplo, uma classe anidada, MyClass, oculta uma classe com o mesmo mome na classe-
base. o Exemplo demostra o uso do modificador new para eliminar ou mensagem dadvertencia,
assim como ou acesso a os membros da classe oculta mediante sus nomes completos.
// cs_modifer_new_nested.cs
// Using the new modifier with nested types
using System;
public class MyBaseC
{
public class MyClass
{
public int x = 200;
public int y;
Visual C# Consolidado 185
}
}

public class MyDerivedC : MyBaseC


{
new public class MyClass // nested type hiding the base type members
{
public int x = 100;
public int y;
public int z;
}

public static void Main()


{
// Criating object from the overlapping class:
MyClass S1 = new MyClass();

// Criating object from the hiddem class:


MyBaseC.MyClass S2 = new MyBaseC.MyClass();

Console.WriteLine(S1.x);
Console.WriteLine(S2.x);
}
}
Resultado
100
200

PALAVRA-CHAVE STRUCT
Um tipo struct é um tipo de valor que pode conter construtores, constantes, campos, métodos,
propriedades, indicadores, operadores, eventos e tipos anidados. A declaração de um tipo struct
toma a forma seguinte:

[attributes] [modifiers] s t r u c t identifier [: interfaces] body [; ]

de onde:
attributes (opcional)
Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes
datributo, veja 17. Atributos.
modifiers (opcional)

Visual C# Consolidado 186


Os modificadores permitidos são new e os cuatro modificadores de acesso .
identifier
Mome do tipo struct.
interfaces (opcional)
• Lista que contém as interfaces implementadas pela estrutura, todas separadas por comas.
body
• Cuerpo da estrutura que contém as declarações de os membros.
Comentarios
O tipo struct é adequado para representar objetos de poca complejidad, como puntos,
rectánguos e cores. Mas é possível representar um ponto como uma classe, uma estrutura é mais
eficaz em algunos casos. Por exemplo, se se declara uma matriz de 1000 objetos Point, se deberá
assinalar memoria adicional para fazer referencia a cada objeto. Neste caso, a estrutura apresenta
um menor costo.
É um erro declarar um construtor predeterminado (sin parâmetros) para uma estrutura. Siempre
existe um construtor predeterminado que inicializa os membros da estrutura com sus valores
predeterminados.
É um erro inicializar um campo de instancia de uma estrutura.
Quando se cria um objeto struct mediante o operador new, se cria e se chama ao construtor
apropriada. A diferença das classes, podem se criar instancias das estruturas sem utilizar o
operador new. Se não é utilizado new, os campos permanecerão sem assinalar e ou objeto não
se poderá utilizar até haver inicializado todos os campos.
A diferença das classes, para as estruturas não existe herança. uma estrutura não pode heredar
de outra estrutura ou classe, nem pode ser a base de uma classe. Sem embargo, as estruturas
herdam da classe-base Object. uma estrutura pode implementar interfaces do mesmo modo que
as classes.
A diferença de C++, não pode declarar uma classe mediante a palavra-chave struct. Em C#, as
classes e as estruturas são semánticamente diferentes. uma estrutura é um tipo de valor,
enquanto que uma classe é um tipo de referencia.
A menos que se necessite semántica de tipos de referencia, o sistema pode processar uma classe
que ocupe menos de 16 bytes de forma mais eficaz como estrutura.
Para obter mais informação sobre estruturas, veja 11. Estruturas e ou Tutorial de estruturas.
Em as extensões administradas para C++, os equivalentes a uma classe do C# e a uma estrutura
do C# são os seguintes:

Extensões administradas Para obter mais


C# para C++ informação...
class __gc struct palavra chave __gc
ou
__gc class
struct __value struct palavra chave __value
ou
__value class

Exemplo 1
Este Exemplo mostra a inicialização de um tipo struct mediante construtores predeterminados e
construtores com parâmetros.
// keyword_struct.cs

Visual C# Consolidado 187


// struct declaration and initialization
using System;
public struct Point
{
public int x, y;

public Point(int p1, int p2)


{
x = p1;
e = p2;
}
}
class MainClass
{
public static void Main()
{
// Initialize:
Point myPoint = new Point();
Point yourPoint = new Point(10,10);

// Display results:
Console.Write("My Point: ");
Console.WriteLine("x = {0}, e = {1}", myPoint.x, myPoint.y);
Console.Write("Your Point: ");
Console.WriteLine("x = {0}, e = {1}", yourPoint.x, yourPoint.y);
}
}
Resultados
My Point: x = 0, e = 0
Your Point: x = 10, e = 10
Exemplo 2
Este Exemplo mostra uma característica exclusiva das estruturas. Cria um objeto Point sem
utilizar o operador new. Se se reemplaza a palavra struct pela palavra class, ou programa não
se compilará.
// keyword_struct2.cs
// Declare a struct object without "new"
using System;
public struct Point
{
public int x, y;

public Point(int x, int y)


{
this.x = x;
this.y = y;
}
}
class MainClass
{
public static void Main()
{
// Declare an object:
Visual C# Consolidado 188
Point myPoint;

// Initialize:
myPoint.x = 10;
myPoint.y = 20;

// Display results:
Console.WriteLine("My Point:");
Console.WriteLine("x = {0}, e = {1}", myPoint.x, myPoint.y);
}
}
Resultados
My Point:
x = 10, e = 20

PALAVRA-CHAVE AS
O operador as é utilizado para realizar conversões entre tipos compatibles. o operador as é
utilizado em expressões da forma:
expression a s type
de onde:
expression
Expressão de um tipo de referencia.
type
• Tipo de referencia.
Comentarios
O operador as funciona como um molde de conversão de tipos pero, se existe um erro na
conversión, proporciona o valor null em vez de produzir uma exceção. mais formalmente, uma
expressão da forma:
expression as type
equivale a:
expression is type ? (type)expression : (type)null
salvo que expression só se avalie uma vez.
Deve ter-se em conta que o operador as somente executa conversões de referencia e conversões
boxing. O operador as não pode realizar outras conversões, como as definidas pelo usuario, que
deveriam ser realizadas utilizando expressões de conversão.
Exemplo
// cs_keyword_as.cs
// The as operator
using System;
class MyClass1
{
}
class MyClass2

Visual C# Consolidado 189


{
}
public class IsTest
{
public static void Main()
{
object [] myObjects = new object[6];
myObjects[0] = new MyClass1();
myObjects[1] = new MyClass2();
myObjects[2] = "helo";
myObjects[3] = 123;
myObjects[4] = 123.4;
myObjects[5] = null;

for (int i=0; i<myObjects.Length; ++i)


{
string s = myObjects[i] as string;
Console.Write ("{0}:", i);
if (s != null)
Console.WriteLine ( "'" + s + "'" );
else
Console.WriteLine ( "not a string" );
}
}
}
Resultado
0:not a string
1:not a string
2:'helo'
3:not a string
4:not a string
5:not a string

Palavra-chave explicit
A palavra-chave explicit é utilizada para declarar um operador de conversão do tipo explícita
definida pelo usuario (6.4.4 Conversões explícitas definidas pelo usuario). Por exemplo:
class MyType
{
public static explicit operator MyType(int i)
{
// code to convert from int to MyType
}
}

A diferença da conversão implícita, os operadores de conversão explícita devem invocarse


mediante uma conversão explícita do tipo (cast).

int i;
MyType x = (MyType)i; // int-to-MyType requires cast

Visual C# Consolidado 190


Se não é utilizado esta conversão explícita, se produza um erro de compilação.
Se uma operação de conversão do tipo pode produzir exceções ou pérdida de informação, deve
definirse como explicit. Desta forma, se evita que o compilador realice a conversão
automáticamente e se produzcam posibles consecuencias não desejadas.
Exemplo
O seguinte Exemplo define uma estrutura, Digit, que reapresenta um único dígito decimal. Se
define um operador para conversões de byte a Digit, pois como não todos os bytes podem se
converter em Digit, a conversão é explícita.

// cs_keyword_explicit.cs
using System;
struct Digit
{
byte value;
public Digit(byte value)
{
if (value>9) throw new ArgumentException();
this.value = value;
}
// define explicit byte-to-Digit conversion operator:
public static explicit operator Digit(byte b)
{
Digit d = new Digit(b);
Console.WriteLine("conversion occurred");
return d;
}
}
class Test
{
public static void Main()
{
try
{
byte b = 3;
Digit d = (Digit)b; // explicit conversion
}

catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
}
}
Resultado
conversion occurred

Palavra-chave null
A palavra-chave null é um literal que representa uma referencia nula, assim, uma referencia que
não aponta a nenhum objeto. Null é o valor predeterminado das variáveis de tipos de referencia.

Visual C# Consolidado 191


Palavra-chave switch
A instrução switch é uma instrução de controle que permite manejar varias seleções e passar o
controle a uma das instruções case de seu corpo. Apresenta a seguinte forma:
s w i t c h ( expression)
{
c a s e constant-expression:
statement
jump-statement
[d e f a u l t :
statement
jump-statement]
}
De onde:
expression
• Expressão do tipo integral ou série.
statement
Instruções que se devem executar se se transfere o controle à etiqueta caSe o default.
jump-statement
Instrução de salto que transfere o controle fora do corpo case.
constant-expression
O controle se transfere a uma instrução case específica segundo o valor desta expressão.
Comentarios
O controle se transfere à instrução case cuja constante constant-expression coincide com a
expressão expression. A instrução switch pode incluir qualquer número de elementos case,
pois não pode haver dos constantes case com o mesmo valor em uma mesma instrução switch.
A execução do corpo da instrução empieza na instrução selecionada e continúa até que a
instrução de salto jump-statement transfere o controle fora do corpo case.
Observe que é necessário colocar jump-statement ao final de cada boque, incluido ou último
boque, já seja uma instrução caSe o uma instrução default. A diferença da instrução switch
de C++, C# não admite ou paso explícito de uma etiqueta case a outra. Se o deseja, pode utilizar
goto a uma etiqueta caSe o goto default.
Se expression não coincide com nenhuma constante constant-expression, o controle se
transfere às instruções que seguem à etiqueta default opcional. Se não existe uma etiqueta
default, o controle se transfere fora da instrução switch.
Exemplo
// statements_switch.cs
using System;
class SwitchTest
{
public static void Main()
{
Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");

Visual C# Consolidado 192


string s = Console.ReadLine();
int n = int.Parse(s);
int cost = 0;
switch(n)
{
case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
break;
}
if (cost != 0)
Console.WriteLine("Please insert {0} cents.", cost);
Console.WriteLine("Thank you for your business.");
}
}
Entrada
2
Resultados do Exemplo
Coffee sizes: 1=Small 2=Medium 3=Large
Please enter your selection: 2
Please insert 50 cents.
Thank you for your business.
Descrição do código
No Exemplo anterior, se utilizou uma variável do tipo integral, n, para os casos da instrução
switch. Observe que também pode utilizar a variável de série, s, diretamente. Nesse caso, a
estrutura switch pode apresentar a seguinte forma:
switch(s)
{
case "1":
...
case "2":
...

Visual C# Consolidado 193


}
• Mas não se admite passar explícitamente de uma etiqueta de caso a outra, se está
permitido apilhar etiquetas de caso, por exemplo:
case 0:
case 1:
// do something;

Palavra-chave base
A palavra-chave base é utilizada para obter acesso a os membros da classe-base desde uma
classe derivada:
• Realice uma chamada a um método da classe-base substituído por outro método.
• Especifique a qué construtor da classe-base deve chamar para criar instancias da classe
derivada.
O acesso a uma classe-base só se permite em um construtor, em um método de instancia ou em
um descritor de acesso a uma propriedade de instancia.
É incorreto utilizar a palavra-chave base dentro de um método estático.
Exemplo
Neste exemplo, tanto a classe-base, Person, como a classe derivada, Empoyee, posuem um
método denominado Getinfo. Mediante a palavra-chave base, pode realizar uma chamada ao
método Getinfo da classe-base desde a classe derivada.
// keywords_base.cs
// Accessing base class members
using System;
public class Person
{
protected string ssn = "444-55-6666";
protected string name = "John L. Malgraine";

public virtual void GetInfo()


{
Console.WriteLine("Name: {0}", name);
Console.WriteLine("SSN: {0}", ssn);
}
}
class Empoyee: Person
{
public string id = "ABC567EFG";

public override void GetInfo()


{
// Calling the base class GetInfo method:
base.GetInfo();
Console.WriteLine("Empoyee ID: {0}", id);
}
}
class TestClass {
public static void Main()
{
Empoyee E = new Empoyee();

Visual C# Consolidado 194


E.GetInfo();
}
}
Resultado

Name: John L. Malgraine


SSN: 444-55-6666
Empoyee ID: ABC567EFG

Exemplo
Este Exemplo mostra como especificar o construtor da classe-base o que se realiza a chamada
quando são criados instancias de uma classe derivada.
// keywords_base2.cs
using System;
public class MyBase
{
int num;

public MyBase()
{
Console.WriteLine("in MyBase()");
}

public MyBase(int i )
{
num = i;
Console.WriteLine("in MyBase(int i)");
}

public int GetNum()


{
return num;
}
}
public class MyDerived: MyBase
{
// This construtor will call MyBase.MyBase()
public MyDerived() : base()
{
}
// This construtor will call MyBase.MyBase(int i)
public MyDerived(int i) : base(i)
{
}

public static void Main()


{
MyDerived md = new MyDerived();
MyDerived md1 = new MyDerived(1);
}
}

Visual C# Consolidado 195


Resultado
in MyBase()
in MyBase(int i)

Palavra-chave extern
Use o modificador extern em uma declaração de método para indicar que o método se
implementa externamente. um uso habitual do modificador extern é com o atributo DllImport.
Veja DllImportAttribute (Classe) para obter mais informação.
É incorreto utilizar simultáneamente os modificadores abstract e extern para modificar o mesmo
membro. O uso do modificador extern significa que o método se implementa fora do código do
C#, enquanto que o uso do abstract significa que a implementação do método não se inclui na
classe.
Como uma declaração de método externo não proporciona uma implementação, não existe corpo
do método; a declaração de método finaliza simplemente com um ponto e vírgula e sem chaves ({
}) depois da firma. Por exemplo:
public static extern int MyMethod(int x);

Nota o uso da palavra-chave extern é mais limitado que em C++. Para comparara com a
palavra-chave de C++, veja Utilizar extern para especificar vinculação na Referencia do lenguaje
C++.

Exemplo
Neste exemplo, ou programa recibe uma série do usuario e a mostra dentro de um quadro de
mensagem. o programa utiliza ou método MessageBox importado da biblioteca User32.dll.
using System;
using System.Runtime.InteropServices;
class MyClass
{
[DllImport("User32.dll")]
public static extern int MessageBox(int h, string m, string c, int type);

public static int Main()


{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox(0, myString, "My Message Box", 0);
}
}
Execução de Exemplo
Enter your message: Where do you want to go today?
Tras escrever o texto anterior, aparece na pantala um quadro de mensagem com ese texto.
Exemplo
Este Exemplo utiliza dos arquivos, CM.cs e Cmdll.c, para demostrar o uso de extern. o arquivo
C é uma DLL externa que se invoca desde ou programa escrito em C#.
Arquivo Cmdll.c

Visual C# Consolidado 196


// cmdll.c
// compile with: /LD /MD
int __declspec(dllexport) MyMethod(int i)
{
return i*10;
}
Arquivo CM.cs
// cm.cs
using System;
using System.Runtime.InteropServices;
public class MyClass
{
[DllImport("Cmdll.dll")]
public static extern int MyMethod(int x);
public static void Main()
{
Console.WriteLine("MyMethod() returns {0}.", MyMethod(5));
}
}
Resultado
MyMethod() returns 50.

Compilação
Para gerar ou proyecto, siga estes pasos:
• Compile Cmdll.c como uma DLL mediante a línea de comandos de Visual C++:
cl /LD /MD Cmdll.c
• Compile CM.cs mediante a línea de comandos:
csc CM.cs
Desta forma, se criará o arquivo executable CM.exe. Quando execute este programa, MyMethod
passará o valor 5 ao arquivo DLL, o qual devoltará o valor multiplicado por 10.

Palavra-chave object
O tipo object é um alias de System.Object do .NET Framework. As variáveis do tipo object
podem receber valores de qualquer tipo.
Todos os tipos de dados, predefinidos e definidos pelo usuario, herdam da classe
System.Object. ou tipo de dados object é ou tipo hacia o qual e desde o qual os objetos se
conviertem mediante boxing.
Exemplo
O seguinte Exemplo mostra como as variáveis do tipo object podem aceitar valores de qualquer
tipo de dados e como podem utilizar métodos de System.Object procedentes do .NET
Framework.
// keyword_object.cs
using System;
public class MyClass1
{
public int i = 10;

Visual C# Consolidado 197


}

public class MyClass2


{
public static void Main()
{
object a;
a = 1; // an example of boxing
Console.WriteLine(a);
Console.WriteLine(a.GetType());
Console.WriteLine(a.ToString());
Console.WriteLine();

a = new MyClass1 ();


MyClass1 ref_MyClass1;
ref_MyClass1 = (MyClass1)a;
Console.WriteLine(ref_MyClass1.i);
}
}
Resultados
1
System.Int32
1

10

Palavra-chave this
A palavra-chave this faz referencia à instancia atual da classe. As funções membro estáticas não
apresentam um ponteiro this. Esta palavra-chave this pode ser utilizada para obter acesso a
membros desde construtores, métodos de instancia e descritores de acesso de instancias.
A continuação, se indicam algunos usos comunes de this:
• Obter acesso a membros com o fim de evitar ambigüedades com nomes similares, por
exemplo:
public Empoyee(string name, string alias)
{
this.name = name;
this.alias = alias;
}
• Passar um objeto como parâmetro a outros métodos, por exemplo, para:
CalcTax(this);
• Declarar indicadores, por exemplo:
public int this [int param]
{
get
{
return array[param];
}
set
{

Visual C# Consolidado 198


array[param] = value;
}
}
É incorreto fazer referencia a this em um método estático, em um descritor de acesso a uma
propriedade estática ou em um inicializador de variável de uma declaração de campo.
Exemplo
Neste exemplo, this é utilizado para obter acesso a os membros da classe Empoyee, name e
alias, que apresentam ambigüedad com nomes similares. Também é utilizado para passar um
objeto ao método CalcTax, o qual pertence a outra classe.
// keywords_this.cs
// this example
using System;
public class Empoyee
{
public string name;
public string alias;
public decimal salary = 3000.00m;

// Construtor:
public Empoyee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
this.name = name;
this.alias = alias;
}

// Printing method:
public void printEmpoyee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}
}
public class Tax
{
public static decimal CalcTax(Empoyee E)
{
return (0.08m*(E.salary));
}
}

public class MainClass


{
public static void Main()
{
// Criate objects:
Empoyee E1 = new Empoyee ("John M. Trainer", "jtrainer");

// Display results:
E1.printEmpoyee();
}

Visual C# Consolidado 199


}
Resultado
Name: John M. Trainer
Alias: jtrainer
Taxes: $240.00

Palavra-chave bool
A palavra-chave bool é um alias de System.Boolean. É utilizado para declarar variáveis que
armazenam os valores booleanos true e false.
Literais
É possível assinalar um valor booleano a uma variável do tipo bool, por exemplo:
bool MyVar = true;
Também pode assinalar uma expressão que se avalie como bool a uma variável do tipo bool,
por exemplo:
bool Alphabetic = (c > 64 && c < 123);
Conversões
Em C++, um valor do tipo bool pode converter em um valor do tipo int; assim: false equivale a
cero e true equivale a valores distintos de cero. Em C#, não é possível realizar a conversão do
tipo bool a outros tipos ou viceversa. Por exemplo, a seguinte instrução if não é válida em C#,
mas se o é em C++:
int x = 123;
if (x) // Invalid in C#
{
printf("The value of x is nonzero.");
}
Para provar uma variável do tipo int, tem que comparara explícitamente com um valor (por
exemplo, cero); assim:
int x = 123;
if (x != 0) // The C# way
{
Console.Write("The value of x is nonzero.");
}
Exemplo
Neste exemplo, se escreve um carácter desde ou teclado e ou programa comprova se se trata de
uma letra. Nesse caso, comprova se é minúscula ou maiúscula. Em cada caso, se mostra a
mensagem apropriada.
// keyword_bool.cs
// Character Tester
using System;
public class BoolTest
{
public static void Main()
{
Console.Write("Enter a character: ");
char c = (char) Console.Read();

if (Char.IsLetter(c))

Visual C# Consolidado 200


if (Char.IsOwer(c))
Console.WriteLine("The character is owercase.");
else
Console.WriteLine("The character is uppercase.");
else
Console.WriteLine("The character is not an alphabetic character.");
}
}
Entrada
X
Resultados do Exemplo
Enter a character: X
The character is uppercase.
Sucesivas execuções de Exemplo podrían ter este aspecto:
Enter a character: x
The character is owercase.

Enter a character: 2
The character is not an alphabetic character.

Palavra-chave false
Em C#, a palavra-chave false pode utilizar como um operador sobrecarregado ou como um
literal.
• Operador false
• Literal false

OPERADOR FALSE
Em os tipos definidos pelo usuario pode definir um operador false que devolve o valor do tipo
bool true para indicar um valor lógico falso; caso contrario, devolve false. Isto resulta útil para tipos
que representam valores true, false e null (nem true nem false), como os utilizados em base de
dados.
Esses tipos podem se utilizar em as expressões de controle das instruções if, do, while e for,
assim como em expressões condicionales.
Se um tipo define false como operador, também deve definir true como operador.
Um tipo não pode sobrecarregar diretamente os operadores lógicos condicionais (&& e ||), pois
pode conseguir um efeito equivalente se se sobrecarrega os operadores lógicos normais e os
operadores true e false (veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario).
Exemplo
Veja o Exemplo de 11.4.2 Tipo boolean para base de dados.

FALSE (LITERAL)
A palavra-chave false é um literal do tipo bool que reapresenta o valor lógico "falso".
Exemplo
// cs_keyword_false.cs
using System;

Visual C# Consolidado 201


class test
{
public static void Main()
{
bool a = false;
Console.WriteLine( a ? "yes" : "no" );
}
}
Resultado
no

Palavra-chave operator
A palavra-chave operator é utilizado para declarar um operador em uma declaração de
classe o estrutura. uma declaração de operador pode apresentar uma das seguintes cuatro
formas:
p u b l i c s t a t i c result-type o p e r a t o r unary-operator ( op-type operand )
p u b l i c s t a t i c result-type o p e r a t o r binary-operator (
op-type operand,
op-type2 operand2
)
p u b l i c s t a t i c i m p l i c i t o p e r a t o r conv-type-out ( conv-type-in operand )
p u b l i c s t a t i c e x p l i c i t o p e r a t o r conv-type-out ( conv-type-in operand )
de onde:
result-type
• Tipo do resultado do operador.
unary-operator
Unão de os seguintes: + - ! ~ ++ — true false
op-type
• Tipo do primeiro (o único) parâmetro.
operand
• Mome do primeiro (o único) parâmetro.
binary-operator
Unão de os seguintes: ^ << >> == != > < >= <=
op-type2
• Tipo do segundo parâmetro.
operand2
• Mome do segundo parâmetro.
conv-type-out
• Tipo de destinão de um operador de conversão de tipos.
conv-type-in
• Tipo de entrada de um operador de conversão de tipos.

Visual C# Consolidado 202


Comentarios
As dos primeras formas declaram operadores definidos pelo usuario que sobrecarrega operadores
integrados. Tenga em cuenta que não todos os operadores integrados podem sobrecargarse (veja
Operadores sobrecargables). Ao menos unão de os tipos op-type e op-type2 deve ser ou tipo
contenedor (assim, ou tipo do qual é membro ou operador). De este modo, por exemplo, se evita
ter que redefinir o operador dadição de inteiros.
As dos últimas formas declaram operadores de conversión. Só unão de os tipos conv-type-in e
conv-type-out deve ser ou tipo contenedor (assim, um operador de conversão só pode realizar
conversões de seu tipo contenedor a outro tipo, ou de outro tipo a seu tipo contenedor).
Os operadores só podem tomar parâmetros de valor, não parâmetros ref ou out.
Qualquer declaração de operador pode estar precedida por uma lista opcional de atributos.
Exemplo
A continuação, se mostra uma classe muy simplificada para números racionales. Sobrecarga os
operadores + e * para implementar a adição e multiplicação de números fraccionarios, e também
proporciona um operador que convierte fracções em números reales do tipo double.
// cs_keyword_operator.cs
using System;
class Fraction
{
int num, den;
public Fraction(int num, int den)
{
this.num = num;
this.dem = den;
}

// overoad operator +
public static Fraction operator +(Fraction a, Fraction b)
{
return new Fraction(a.num * b.dem + b.num * a.den,
a.dem * b.den);
}

// overoad operator *
public static Fraction operator *(Fraction a, Fraction b)
{
return new Fraction(a.num * b.num, a.dem * b.den);
}

// define operator double


public static implicit operator double(Fraction f)
{
return (double)f.num / f.den;
}
}
class Test
{
public static void Main()
{
Fraction a = new Fraction(1, 2);
Fraction b = new Fraction(3, 7);

Visual C# Consolidado 203


Fraction c = new Fraction(2, 3);
Console.WriteLine((double)(a * b + c));
}
}
Resultado
0.880952380952381

Palavra-chave throw
A instrução throw é utilizado para señalizar a aparição de uma situação anómaa (exceção)
durante a execução do programa. Apresenta a seguinte forma:
t h r o w [expression];
de onde:
expression
O objeto exceção. Este elemento se omite se se vuelve a iniciar ou objeto de exceção atual em
uma cláusula catch.
Comentarios
A exceção provocada é um objeto cuja classe é derivada de System.Exception, por exemplo:
class MyException : System.Exception {}
throw new MyException();
Normalmente, a instrução throw é utilizado com as instruções try-catch ou try-finally. Quando se
provoca uma exceção, ou programa busca a instrução catch que controa esa exceção.
Também pode voltar a iniciar uma exceção detectada mediante a instrução throw.
Exemplo
Este Exemplo mostra como provocar uma exceção mediante a instrução throw.
// throw example
using System;
public class ThrowTest
{
public static void Main()
{
string s = null;

if (s == null)
{
throw(new ArgumentNullException());
}

Console.Write("The string s is null"); // not executed


}
}
Resultado
Se produza a exceção seguinte:
System.ArgumentNullException

Visual C# Consolidado 204


Palavra-chave break
A instrução break permite terminar a instrução switch ou o laço envolvente em os quais
aparece. o controle se transfere à instrução que sigue à instrução terminada, se existe alguna. A
instrução apresenta a seguinte forma:
break;
Exemplo
Neste exemplo, a instrução condicional contém um contador preparado para contar de 1 a 100;
sem embargo, a instrução break termina ou laço tras 4 iterações.
// statements_break.cs
using System;
class BreakTest
{
public static void Main()
{
for (int i = 1; i <= 100; i++)
{
if (i == 5)
break;
Console.WriteLine(i);
}
}
}
Resultado
1
2
3
4
Exemplo
Este Exemplo mostra o uso de break em uma instrução switch.
// statements_break2.cs
// break and switch
using System;
class Switch
{
public static void Main()
{
Console.Write("Enter your selection (1, 2, or 3): ");
string s = Console.ReadLine();
int n = Int32.Parse(s);

switch(n)
{
case 1:
Console.WriteLine("Current value is {0}", 1);
break;
case 2:
Console.WriteLine("Current value is {0}", 2);
break;

Visual C# Consolidado 205


case 3:
Console.WriteLine("Current value is {0}", 3);
break;
default:
Console.WriteLine("Sorry, invalid selection.");
break;
}
}
}
Entrada
1
Resultados do Exemplo
Enter your selection (1, 2, or 3): 1
Current value is 1
Se se escreveu 4, ou resultado sería:
Enter your selection (1, 2, or 3): 4
Sorry, invalid selection.

Palavra-chave try-finally
O bloco finally é útil para liberar os recursos assinalados no bloco try. o controle se transfere
siempre ao bloco finally independientemente de como finalice o bloco try. A instrução apresenta a
seguinte forma:
t r y try-bock f i n a l l y finally-bock
de onde:
try-bock
• Contém o segmento de código que pode produzir a exceção.
finally-bock
• Contém o controlador da exceção e ou código que realiza a liberação de recursos.
Comentarios
Se biem catch é utilizado para controlar exceções que ocurrem em um bloco de instrucções,
finally é utilizado para garantizar que um bloco de código se executa independientemente de
como finaliza o bloco try anterior.
Exemplo
Neste exemplo, existe uma instrução de conversão não válida que produza uma exceção. Se se
executa ou programa, se obtem um mensagem de erro em tiempo de execução, pois a cláusula
finally se executa de todas formas e mostra o resultado.
// try-finally
using System;
public class TestTryFinally
{
public static void Main()
{
int i = 123;
string s = "Some string";
object ou = s;

Visual C# Consolidado 206


try
{
// Invalid conversion; ou contains a string not an int
i = (int) o;
}

finally
{
Console.Write("i = {0}", i);
}
}
}
Resultado
Se produza a exceção seguinte:
System.InvalidCastException
Mas se capturó uma exceção, a instrução de salida incluida no bloco finally se executará de
todas formas, assim:
i = 123
Para obter mais informação acerca de finally, veja try-catch-finally.

Palavra-chave out
A palavra-chave out aplicada a parâmetros de métodos faz que um método haga referencia à
variável pasada ao método. Qualquer cambio que se realice no parâmetro dentro do método se
reflejará em esa variável quando se devuelva o controle ao método que realizó a chamada.
Declarar um método como out é útil quando se deseja que devuelva varios valores. um método
que utiliza um parâmetro out puede, não obstante, seguir devolviendo um valor. um método pode
ter mais de um parâmetro out.
Para utilizar um parâmetro out, ou argumento deve passarse explícitamente ao método como um
argumento out. o valor de um argumento out não se passará ao parâmetro out.
Uma variável que se pasa como argumento out não necessita inicializarse. Não obstante, deve
assinalarse um valor ao parâmetro out antes de que o método devuelva a chamada.
Uma propriedade não é uma variável y, por tanto, não pode passar como parâmetro out.
Se as declarações de dois métodos só se diferençan no uso de out, existirá sobrecarga. Sem
embargo, não é possível definir uma sobrecarga que só se diferencie em ref e out. Por exemplo,
as seguintes declarações de sobrecarga são válidas:
class MyClass
{
public void MyMethod(int i) {i = 10;}
public void MyMethod(out int i) {i = 10;}
}
pois as seguintes não o son:
class MyClass
{
public void MyMethod(out int i) {i = 10;}
public void MyMethod(ref int i) {i = 10;}
}
Exemplo

Visual C# Consolidado 207


// cs_out.cs
using System;
public class MyClass
{
public static int TestOut(out char i)
{
i = 'b';
return -1;
}

public static void Main()


{
char i; // variável need not be initialized
Console.WriteLine(TestOut(out i));
Console.WriteLine(i);
}
}
Resultado
-1
b

Palavra-chave true
Em C#, a palavra-chave true pode utilizar como um operador sobrecarregado ou como um literal:
• Operador true
• Literal true

OPERADOR TRUE
Em os tipos definidos pelo usuario pode definir um operador true que devolve o valor do tipo bool
true para indicar um valor lógico verdadero; caso contrario, devolve false. Isto resulta útil para
tipos que representam valores true, false e null (nem true nem false), como os utilizados em base
de dados.
Esses tipos podem se utilizar em as expressões de controle das instruções if, do, while e for,
assim como em expressões condicionales.
Se um tipo define true como operador, também deve definir false como operador.
Um tipo não pode sobrecarregar diretamente os operadores lógicos condicionais (&& e ||), pois
pode conseguir um efeito equivalente se se sobrecarrega os operadores lógicos normais e os
operadores true e false (veja 7.11.2 Operadores lógicos condicionais definidos pelo usuario).
Exemplo
Veja o Exemplo de 11.4.2 Tipo boolean para base de dados.

TRUE (LITERAL)
A palavra-chave true é um literal do tipo bool que reapresenta o valor lógico "verdadero".
Exemplo
// cs_keyword_true.cs
using System;
class test

Visual C# Consolidado 208


{
public static void Main()
{
bool a = true;
Console.WriteLine( a ? "yes" : "no" );
}
}

Resultado
yes

Palavra-chave byte
A palavra-chave byte denota um tipo integral que armazena valores segundo se indica na taba
seguinte.

Tipo do .NET
Tipo Intervalo Tamanho Framework
byte 0 a 255 Inteiro de 8 bits sem signo System.Byte

Literais
As variáveis do tipo byte podem se declarar e inicializar como no seguinte exemplo:
byte myByte = 255;
Na declaração anterior, ou literal inteiro 255 se convierte implícitamente do tipo int ao tipo byte.
Se o literal inteiro supera ou intervalo de valores do tipo byte, se produzirá um erro de
compilação.
Conversões
Existe uma conversão implícita predefinida de byte a short, ushort, int, uint, ong, uong,
foat, double ou decimal.
Não podem se converter implícitamente tipos numéricos não literais cujo tamanho
darmazenamiento seja superior a byte (veja Tabela de tipos integrais para conhecer os
tamanhos darmazenamiento de os tipos integrais). Considere, por exemplo, as dos seguintes
variáveis do tipo byte, x e y:
byte x = 10, e = 20;
A instrução dassinalação seguinte produzirá um erro de compilação, já que a expressão aritmética
do lado direito do operador dassinalação se avalie de forma predeterminada como int.
byte z = x + y; // Erro: conversion from int to byte
Para solucionar este problema, utilize uma conversão explícita:
byte z = (byte)(x + y); // OK: explicit conversion
Mas, é possível utilizar as instruções seguintes, de onde a variável de destinão tem um tamanho
darmazenamiento igual ou superior:
int x = 10, e = 20;
int m = x + y;
ong n = x + y;

Visual C# Consolidado 209


Assim mesmo, não existe conversão implícita de tipos de ponto flutuante a tipo byte. Por
exemplo, a instrução seguinte gerará um erro de compilação, a menos que se utilize uma
conversão explícita:
byte x = 3.0; // Erro: não implicit conversion from double
byte e = (byte)3.0; // OK: explicit conversion
Para chamar os métodos sobrecarregados, deve se utilizar uma conversão explícita de tipos.
Considere, por exemplo, os dos seguintes métodos sobrecarregados que utilizam parâmetros do
tipo byte e int:
public static void MyMethod(int i) {}
public static void MyMethod(byte b) {}
Se é utilizada a conversão ao tipo byte, se garante a chamada ao tipo correto; por exemplo:
MyMethod(5); // Calling the method with the int parameter
MyMethod((byte)5); // Calling the method with the byte parameter
Para obter mais informação sobre expressões aritméticas com tipos de ponto flutuante e tipos
integrais, veja foat e double.
Para obter mais informação sobre as regas de conversão numérica implícitas, veja a Taba de
conversões numéricas implícitas.

Palavra-chave fixed
Impide que o recolector de elementos não utilizados cambie a colocação de uma variável.
Apresenta a seguinte forma:
f i x e d ( type* ptr = expr ) statement
de onde:
type
Tipo não administrado ou tipo void.
ptr
• Mome de ponteiro.
expr
Expressão que pode converter implícitamente em um tipo type*.
statement
• Instrução o bloco executable.
Comentarios
A instrução fixed só se permite em um contexto unsafe.
A instrução fixed establece um ponteiro em uma variável administrada e "fija" esa variável
durante a execução da instrução o bloco statement. Sem fixed, os ponteiros a variáveis
administradas serían de poca utilidad, já que o proceso de recoleção de elementos não utilizados
poderia cambiar a colocação das variáveis de forma impredecible. De hecho, ou compilador do C#
não permite definir um ponteiro a uma variável administrada se não é em uma instrução fixed.
// assume class Point { public int x, y; }
Point pt = new Point(); // pt is a managed variável, subject to g.c.
fixed ( int* p = &pt.x ){ // must use fixed to get address of pt.x and
*p = 1; // pin pt in place while we use the pointer
}
Um ponteiro pode inicializar com a direção de uma matriz ou de uma série:

Visual C# Consolidado 210


fixed (int* p = arr) ... // equivalent to p = &arr[0]
fixed (char* p = str) ... // equivalent to p = &str[0]
Se podem inicializar varios ponteiros à vez, siempre que sean do mesmo tipo:
fixed (byte* ps = srcarray, pd = dstarray) {...}
Para inicializar ponteiros de diferente tipo, simplemente anide instruções fixed:
fixed (int* p1 = &p.x)
fixed (double* p2 = &array[5])
// do something with p1 and p2
Os ponteiros inicializados em instruções fixed não podem se modificar.
Depois de executar a instrução o bloco statement, qualquer variável anteriormente fijada queda
já sometida ao proceso de recoleção de elementos não utilizados. Por consiguiente, não deve
apuntar a esas variáveis desde fora da instrução fixed.
no modo não seguro (unsafe), pode assinalar memoria à pilha, de onde não está sometida a
recoleção de elementos não utilizados y, por o tanto, não necessita fijarse. Veja stackaloc para
obter mais informação.
Exemplo
// statements_fixed.cs
// compile with: /unsafe
using System;

class Point {
public int x, y;
}

class FixedTest
{
// unsafe method: takes pointer to int
unsafe static void SquarePtrParam (int* p)
{
*p *= *p;
}

unsafe public static void Main()


{
Point pt = new Point();
pt.x = 5;
pt.y = 6;
// pin pt in place:
fixed (int* p = &pt.x)
{
SquarePtrParam (p);
}
// pt now unpinned
Console.WriteLine ("{0} {1}", pt.x, pt.y);
}
}
Resultado
25 6

Visual C# Consolidado 211


Palavra-chave override
Utilize o modificador override para modificar um método, uma propiedad, um indicador ou um
evento. Os métodos de reemplazo proporcionam uma nueva implementação de um membro
herdado de uma classe-base. ou método substituído por uma declaração override se conhece
como método base reemplazado. ou método base substituído deve ter a mesma firma que o
método de reemplazo.
Não pode substituir um método estático ou não virtual. ou método base substituído deve ser
virtual, abstract u override.
Uma declaração override não pode cambiar a accesibilidad do método virtual. Tanto ou método de
reemplazo como ou método virtual devem ter o mesmo modificador de nivo de acesso .
Não podem se utilizar os seguintes modificadores para modificar um método de reemplazo:
new static virtual abstract
Uma declaração de propriedade de reemplazo deve especificar o mesmo modificador de acesso ,
tipo e mome que a propriedade herdada, e a propriedade reemplazada deve ser virtual, abstract u
override.
Para obter mais informação acerca do acesso a os membros de uma classe-base, veja 7.5.8
acesso base.
Para obter mais informação sobre como substituir métodos, veja 10.5.4 Métodos de reemplazo.
Exemplo
Veja o Exemplo correspondiente da palavra-chave virtual.
Desde dentro da classe derivada que posee um método de reemplazo, aún é possível ter acesso ,
mediante a palavra-chave base, ao método base substituído que tno mesmo nome. Por exemplo,
se se dispõe de um método virtual MyMethod(), e um método de reemplazo em uma classe
derivada, pode obter acesso ao método virtual desde a classe derivada mediante a chamada:
base.MyMethod()
Compare esta opção com a de C++, de onde é utilizado o operador de resolução de ámbito (::) e
o nome da classe-base, por exemplo:
My_Base_Class_Name::MyMethod()
Exemplo
Neste exemplo, existe uma classe-base, Square, e uma classe derivada, Cube. Como a área de
um cubo é a soma das áreas de seis quadrados, é possível calcular mediante uma chamada ao
método Area() da classe-base.
// cs_override_keyword.cs
// Calling overridem methods from the base class
using System;
class TestClass
{
public class Square
{
public double x;

// Construtor:
public Square(double x)
{
this.x = x;
}

Visual C# Consolidado 212


public virtual double Area()
{
return x*x;
}
}
class Cube: Square
{
// Construtor:
public Cube(double x): base(x)
{
}

// Calling the Area base method:


public override double Area()
{
return (6*(base.Area()));
}
}
public static void Main()
{
double x = 5.2;
Square s = new Square(x);
Square c = new Cube(x);
Console.WriteLine("Area of Square = {0:F2}", s.Area());
Console.WriteLine("Area of Cube = {0:F2}", c.Area());
}
}
Resultado
Area of Square = 27.04
Area of Cube = 162.24

Palavra-chave try-catch
A instrução try-catch consta de um bloco try seguido de uma ou mais cláusulas catch, as quais
especificam controladores para diferentes exceções . Esta instrução apresenta uma das seguintes
formas:
t r y try-bock
c a t c h ( exception-declaration-1) catch-bock-1
c a t c h ( exception-declaration-2) catch-bock-2
...
t r y try-bock c a t c h catch-bock
de onde:
try-bock
• Contém o segmento de código que pode produzir a exceção.
exception-declaration, exception-declaration-1, exception-declaration-2
• Declaração do objeto exceção.
catch-bock, catch-bock-1, catch-bock-2
• Contém o controlador da exceção.
Comentarios

Visual C# Consolidado 213


O bloco try-bock Contém o bloco de código suceptível de causar a exceção. Este bloco se
executa até que se produza uma exceção ou até completarse satisfatoriamente. Por exemplo, ou
seguinte intento de converter o tipo de um objeto null provoca a exceção
NullReferenceException:
object o2 = null;
try
{
int i2 = (int) o2; // Erro
}
A cláusula catch pode utilizar sem argumentos, em cujo caso captura qualquer tipo de exceção e
se conhece como cláusula catch geral. Também pode aceitar um argumento de objeto derivado
de System.Exception, em cujo caso trata uma exceção específica. Por exemplo:
catch (InvalidCastException e)
{
}
É possível utilizar mais de uma cláusula catch específica na mesma instrução try-catch. Neste
caso, a ordem das cláusulas catch é importante já que estas se examinam por ordem. As
exceções mais específicas se capturam anté que as menos específicas.
Se pode utilizar uma instrução throw no bloco catch para voltar a provocar a exceção capturada
pela instrução catch. Por exemplo:
catch (InvalidCastException e)
{
throw (e); // Rethrowing exception e
}
Se deseja voltar a provocar a exceção que está sendo atualmente controlada por uma cláusula
catch sem parâmetros, use a instrução throw sem argumentos. Por exemplo:
catch
{
throw;
}
Quando estes dentro de um bloco try, inicialice só variáveis declaradas em seu interior; caso
contrario, pode provocarse uma exceção anté de que se complete a execução do boque. Por
exemplo, no seguinte Exemplo de código, a variável x se inicializa dentro do bloco try. Ao
intentar utilizar a variável fora do bloco try, na instrução Write(x), se gerará ou seguinte erro do
compilador: Uso de variável ocal não assinalada.
public static void Main()
{
int x;
try
{
x = 123; // Don't do that.
// ...
}
catch
{
// ...
}
Console.Write(x); // Erro: Use of unassigned ocal variável 'x'.
}

Visual C# Consolidado 214


Exemplo
Neste exemplo, o bloco try contém uma chamada ao método MyFn(), que pode produzir uma
exceção. A cláusula catch Contém o controlador da exceção, o qual simplemente mostra um
mensagem na tela. Quando se realiza a chamada à instrução throw desde dentro de MyFn(), o
sistema busca a instrução catch e mostra a mensagem Exception caught.
// Rethrowing exceptions:
using System;
class MyClass
{
public static void Main()
{
MyClass x = new MyClass();
try
{
string s = null;
x.MyFn(s);
}

catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
}
public void MyFn(string s)
{
if (s == null)
throw(new ArgumentNullException());
}
}
Resultado
Se produza a exceção seguinte:
System.ArgumentNullException
Exemplo
Neste exemplo, se utilizam dos instruções catch. A exceção mais específica, que aparece em
primeiro lugar, se captura primero.
// Ordering catch clauses
using System;
class MyClass
{
public static void Main()
{
MyClass x = new MyClass();
try
{
string s = null;
x.MyFn(s);
}

// Most specific:
catch (ArgumentNullException e)

Visual C# Consolidado 215


{
Console.WriteLine("{0} First exception caught.", e);
}

// Least specific:
catch (Exception e)
{
Console.WriteLine("{0} Second exception caught.", e);
}

}
public void MyFn(string s)
{
if (s == null)
throw new ArgumentNullException();
}
}
Resultado
Se produza a exceção seguinte:
System.ArgumentNullException
No Exemplo anterior, se empieza com a cláusula catch menos específica, se obterá o mensagem:
A previous catch clause already catché all exceptions of this or a super type ('System.Exception')
Não obstante, para capturar a exceção menos específica, deve substituir a instrução throw pela
seguinte:
throw new Exception();

Palavra-chave switch
A instrução switch é uma instrução de controle que permite manejar varias seleções e passar o
controle a uma das instruções case de seu cuerpo. Apresenta a seguinte forma:
s w i t c h ( expression)
{
c a s e constant-expression:
statement
jump-statement
[d e f a u l t :
statement
jump-statement]
}
De onde:
expression
• Expressão do tipo integral ou série.
statement
Instruções que se devem executar se se transfere o controle à etiqueta caSe o default.
jump-statement
Instrução de salto que transfere o controle fora do corpo case.
constant-expression

Visual C# Consolidado 216


O controle se transfere a uma instrução case específica segundo o valor desta expressão.
Comentarios
O controle se transfere à instrução case cuja constante constant-expression coincide com a
expressão expression. A instrução switch pode incluir qualquer número de elementos case,
pois não pode haver dos constantes case com o mesmo valor em uma mesma instrução switch.
A execução do corpo da instrução empieza na instrução selecionada e continúa até que a
instrução de salto jump-statement transfere o controle fora do corpo case.
Observe que é necessário colocar jump-statement ao final de cada boque, incluido ou último
boque, já seja uma instrução caSe o uma instrução default. A diferença da instrução switch
de C++, C# não admite ou paso explícito de uma etiqueta case a outra. Se o deseja, pode utilizar
goto a uma etiqueta caSe o goto default.
Se expression não coincide com nenhuma constante constant-expression, o controle se
transfere às instruções que seguem à etiqueta default opcional. Se não existe uma etiqueta
default, o controle se transfere fora da instrução switch.
Exemplo
// statements_switch.cs
using System;
class SwitchTest
{
public static void Main()
{
Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");
string s = Console.ReadLine();
int n = int.Parse(s);
int cost = 0;
switch(n)
{
case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
break;
}
if (cost != 0)
Console.WriteLine("Please insert {0} cents.", cost);
Console.WriteLine("Thank you for your business.");
}
}
Entrada
2

Visual C# Consolidado 217


Resultados do Exemplo
Coffee sizes: 1=Small 2=Medium 3=Large
Please enter your selection: 2
Please insert 50 cents.
Thank you for your business.
Descrição do código
No Exemplo anterior, se utilizou uma variável do tipo integral, n, para os casos da instrução
switch. Observe que também pode utilizar a variável de série, s, diretamente. Nesse caso, a
estrutura switch pode apresentar a seguinte forma:
switch(s)
{
case "1":
...
case "2":
...
}
• Mas não se admite passar explícitamente de uma etiqueta de caso a outra, se está permitido
apilhar etiquetas de caso, por exemplo:
case 0:
case 1:
// do something;

Palavra-chave foat
A palavra-chave foat denota um tipo simple que armazena valores de ponto flutuante de 32 bits.
A seguinte taba mostra a precisión e ou intervalo aproximado para o tipo foat.

Tipo do .NET
Tipo Intervalo aproximado Precisión Framework
45 38
foat ±1.5 × 10− a ±3.4 × 10 7 dígitos System.Single

Literais
De forma predeterminada, um literal numérico real no lado direito do operador dassinalação se
trata como double. Por consiguiente, para inicializar uma variável do tipo foat, utilize ou sufijo f
ou F; por exemplo:
foat x = 3.5F;
Se não utiliza ou sufijo na declaração anterior, obterá um erro de compilação, já que está
intentando armazenar um valor do tipo double em uma variável do tipo foat.
Conversões
É possível combinar tipos numéricos integral e tipos de ponto flutuante em uma expressão. Neste
caso, os tipos integrais se conviertem em tipos de ponto fotante. A evaluação da expressão se
realiza segundo as seguintes reglas:
• Se unão de os tipos de ponto flutuante é double, a expressão se avalie como double (o
bool no caso de expressões relacionales ou booleanas).
• Se não existe nenhum tipo double na expressão, esta se avalie como foat (o bool no
caso de expressões relacionales ou booleanas).
Uma expressão de ponto flutuante pode conter os seguintes conjuntos de valores:
• Cero negativo e positivo

Visual C# Consolidado 218


• Infinito positivo e negativo
• Valor Nam (não é um número)
• O conjunto finito de valores distintos de cero
Para obter mais informação sobre estes valores, consulte o estándar IEEE para aritmética binaria
de ponto flutante, disponivel no sitio Web http://www.ieee.org/.
Exemplo
No seguinte exemplo, se inclui um int, um short e um foat em uma expressão matemática que
proporciona um resultado do tipo foat (observe que não existe nenhum double na expressão).
// keyword_foat.cs
// Mixing types in expressions
using System;
class MixedTypes
{
public static void Main()
{
int x = 3;
foat e = 4.5f;
short z = 5;
Console.WriteLine("The result is {0}", x*y/z);
}
}
Resultados
The result is 2.7

Palavra-chave params
A palavra-chave params permite especificar um parâmetro de método que aceita um número
variável dargumentos.
Não é permitido parâmetros adicionales depois da palavra-chave params, nem varias palavras-
chave params em uma mesma declaração de método.
Exemplo
// cs_params.cs
using System;
public class MyClass
{
public static void UseParams(params int[] list)
{
for ( int i = 0 ; i < list.Length ; i++ )
Console.WriteLine(list[i]);
Console.WriteLine();
}
public static void UseParams2(params object[] list)
{
for ( int i = 0 ; i < list.Length ; i++ )
Console.WriteLine(list[i]);
Console.WriteLine();
}
public static void Main()
{

Visual C# Consolidado 219


UseParams(1, 2, 3);
UseParams2(1, 'a', "test");

int[] myarray = new int[3] {10,11,12};


UseParams(myarray);
}
}
Resultado
1
2
3

1
a
test

10
11
12

Palavra-chave typeof
O operador typeof é utilizado com o fim de obter ou objeto System.Type para um tipo. uma
expressão typeof se apresenta da seguinte forma:
t y p e o f ( type)
de onde:
type
Tipo cujo objeto System.Type se deseja obtener.
Comentarios
O operador typeof não pode sobrecargar.
Para obter ou tipo de uma expressão em tiempo de execução, pode utilizar o método GetType
do .NET Framework.
Exemplo
// cs_operator_typeof.cs
// Using typeof operator
using System;
using System.Reflection;

public class MyClass


{
public int intI;
public void MyMeth()
{
}
public static void Main()
{

Visual C# Consolidado 220


Type t = typeof(MyClass);

// alternatively, you could use


// MyClass t1 = new MyClass();
// Type t = t1.GetType();

MethodInfo[] x = t.GetMethods();
foreach (MethodInfo xtemp in x)
{
Console.WriteLine(xtemp.ToString());
}
Console.WriteLine();

MemberInfo[] x2 = t.GetMembers();
foreach (MemberInfo xtemp2 in x2)
{
Console.WriteLine(xtemp2.ToString());
}
}
}
Resultado
Int32 GetHashCode()
Boolean Equals(System.Object)
System.String ToString()
Void MyMeth()
Void Main()
System.Type GetType()

Int32 intI
Int32 GetHashCode()
Boolean Equals(System.Object)
System.String ToString()
Void MyMeth()
Void Main()
System.Type GetType()
Void .ctor()
Exemplo
// cs_operator_typeof2.cs
// Using GetType method
using System;
class GetTypeTest
{
public static void Main()
{
int radius = 3;
Console.WriteLine("Area = {0}", radius*radius*Math.PI);
Console.WriteLine("The type is {0}",

Visual C# Consolidado 221


(radius*radius*Math.PI).GetType());
}
}
Resultado
Area = 28.2743338823081
The type is System.Double

Palavra-chave try-catch
A instrução try-catch consta de um bloco try seguido de uma ou mais cláusulas catch, as quais
especificam controladores para diferentes exceções . Esta instrução apresenta uma das seguintes
formas:
t r y try-bock
c a t c h ( exception-declaration-1) catch-bock-1
c a t c h ( exception-declaration-2) catch-bock-2
...
t r y try-bock c a t c h catch-bock
de onde:
try-bock
• Contém o segmento de código que pode produzir a exceção.
exception-declaration, exception-declaration-1, exception-declaration-2
• Declaração do objeto exceção.
catch-bock, catch-bock-1, catch-bock-2
• Contém o controlador da exceção.
Comentarios
O bloco try-bock Contém o bloco de código suceptível de causar a exceção. Este bloco se
executa até que se produza uma exceção ou até completarse satisfatoriamente. Por exemplo, ou
seguinte intento de converter o tipo de um objeto null provoca a exceção
NullReferenceException:
object o2 = null;
try
{
int i2 = (int) o2; // Erro
}
A cláusula catch pode utilizar sem argumentos, em cujo caso captura qualquer tipo de exceção e
se conhece como cláusula catch geral. Também pode aceitar um argumento de objeto derivado
de System.Exception, em cujo caso trata uma exceção específica. Por exemplo:
catch (InvalidCastException e)
{
}
É possível utilizar mais de uma cláusula catch específica na mesma instrução try-catch. Neste
caso, a ordem das cláusulas catch é importante já que estas se examinam por ordem. As
exceções mais específicas se capturam antes que as menos específicas.

Visual C# Consolidado 222


Se pode utilizar uma instrução throw no bloco catch para voltar a provocar a exceção capturada
pela instrução catch. Por exemplo:
catch (InvalidCastException e)
{
throw (e); // Rethrowing exception e
}
Se deseja voltar a provocar a exceção que está sendo atualmente controlada por uma cláusula
catch sem parâmetros, use a instrução throw sem argumentos. Por exemplo:
catch
{
throw;
}
Quando estes dentro de um bloco try, inicialice só variáveis declaradas em seu interior; caso
contrario, pode provocarse uma exceção antes de que se complete a execução do boque. Por
exemplo, no seguinte Exemplo de código, a variável x se inicializa dentro do bloco try. Ao
intentar utilizar a variável fora do bloco try, na instrução Write(x), se gerará ou seguinte erro do
compilador: Uso de variável ocal não assinalada.
public static void Main()
{
int x;
try
{
x = 123; // Don't do that.
// ...
}
catch
{
// ...
}
Console.Write(x); // Erro: Use of unassigned ocal variável 'x'.
}

Exemplo
Neste exemplo, o bloco try contém uma chamada ao método MyFn(), que pode produzir uma
exceção. A cláusula catch Contém o controlador da exceção, o qual simplemente mostra um
mensagem na tela. Quando se realiza a chamada à instrução throw desde dentro de MyFn(), o
sistema busca a instrução catch e mostra a mensagem Exception caught.
// Rethrowing exceptions:
using System;
class MyClass
{
public static void Main()
{
MyClass x = new MyClass();
try
{
string s = null;
x.MyFn(s);
}
catch (Exception e)

Visual C# Consolidado 223


{
Console.WriteLine("{0} Exception caught.", e);
}
}
public void MyFn(string s)
{
if (s == null)
throw(new ArgumentNullException());
}
}
Resultado
Se produza a exceção seguinte:
System.ArgumentNullException
Exemplo
Neste exemplo, se utilizam dos instruções catch. A exceção mais específica, que aparece em
primeiro lugar, se captura primero.
// Ordering catch clauses
using System;
class MyClass
{
public static void Main()
{
MyClass x = new MyClass();
try
{
string s = null;
x.MyFn(s);
}

// Most specific:
catch (ArgumentNullException e)
{
Console.WriteLine("{0} First exception caught.", e);
}

// Least specific:
catch (Exception e)
{
Console.WriteLine("{0} Second exception caught.", e);
}

}
public void MyFn(string s)
{
if (s == null)
throw new ArgumentNullException();
}
}
Resultado
Se produza a exceção seguinte:

Visual C# Consolidado 224


System.ArgumentNullException
No Exemplo anterior, se empieza com a cláusula catch menos específica, se obterá o mensagem:
A previous catch clause already catches all exceptions of this or a super type ('System.Exception')
Não obstante, para capturar a exceção menos específica, deve substituir a instrução throw pela
seguinte:
throw new Exception();

Palavra-chave for
O laço for executa uma instrução ou um bloco de instruções repetidamente até que uma
expressão especificada se avalie como false. Apresenta a seguinte forma:
f o r ( [initializers]; [expression]; [iterators]) statement
de onde:
initializers
• Lista de expressões ou instruções dassinalação, separadas por comas, que inicializam os
contadores do laço.
expression
Expressão que pode converterse implícitamente no tipo bool ou em um tipo que contenga a
sobrecarga de os operadores true e false. A expressão se usa para comprovar ou criterio de
terminação do laço.
iterators
• Expressões ou instruções que incrementan ou reducem os contadores do laço.
statement
• Instruções que se devem executar dentro do laço.
Comentarios
A instrução for executa sus instruções internas repetidamente da seguinte forma:
• Primero, avalie os inicializadores.
• A continuação, enquanto expression se avalie como true, se executan as instruções do
laço e se avalien os iteradores.
• Quando expression se faz false, o controle se transfere fora do laço.
Debido a que a comprobação de expression tem lugar antes da execução do laço, a instrução
for se executa cero ou varias veces.
Todas as expressões da instrução for são opcionales; por exemplo, a seguinte instrução é
utilizado para criar um laço infinito:
for (;;) {
...
}
Exemplo
// statements_for.cs
// for oop
using System;
public class ForOopTest
{
public static void Main()

Visual C# Consolidado 225


{
for (int i = 1; i <= 5; i++)
Console.WriteLine(i);
}
}
Resultado
1
2
3
4
5

Palavra-chave private
A palavra-chave private é um modificador de acesso de membros. ou acesso do tipo private
corresponde ao nivo de acesso mais restrictivo. Os membros privados só são accesibles dentro
do corpo da classe o a estrutura na qual se declaran.
Os tipos anidados do mesmo corpo também podem ter acesso a esses membros privados.
Fazer referencia a um membro privado fora da classe o estrutura na que se declara produza um
erro de compilação.
Encontrará uma comparação de private com os outros modificadores de acesso em Niveles
daccesibilidad.
Exemplo
Neste exemplo, a classe Empoyee contém um membro público, Name, e um membro privado,
Salary. ou acesso ao membro público pode realizar diretamente, enquanto que o acesso ao
membro privado deve fazerse a través do método público AccessSalary().
// private_keyword.cs
using System;
class Empoyee
{
public string name = "xx";
double salary = 100.00; // private access by default
public double AccessSalary() {
return salary;
}
}

class MainClass
{
public static void Main()
{
Empoyee e = new Empoyee();

// Accessing the public field:


string n = e.name;

// Accessing the private field:


double s = e.AccessSalary();
}

Visual C# Consolidado 226


}
No Exemplo anterior, se intenta obter acesso diretamente a os membros privados mediante uma
instrução como a seguinte:
double s = e.salary;
obterá o seguinte mensagem de erro:
'Empoyee.Salary' is inaccessible due to its protection level.

Palavra-chave uint
A palavra-chave uint denota um tipo integral que armazena valores segundo ou tamanho e ou
intervo que se indicam na taba seguinte.

Tipo do .NET
Tipo Intervalo Tamanho Framework
uint 0 a 4.294.967.295 Inteiro de 32 bits sem signo System.UInt32

Literais
As variáveis do tipo uint podem se declarar e inicializar como no seguinte exemplo:
uint myUint = 4294967290;
Quando um literal inteiro não tem sufijo, seu tipo é ou primero de estes tipos no que pode
representar seu valor: int, uint, ong, uong. Neste exemplo, é uint.
Também pode utilizar o sufijo u ou U:
uint myUint = 123U;
Quando é utilizado ou sufijo U ou u, ou tipo do literal será uint ou uong, segundo seu tamanho.
Neste exemplo, é uint.
Conversões
Existe uma conversão implícita predefinida de uint a ong, uong, foat, double ou decimal.
Por exemplo:
foat myFoat = 4294967290; // OK: implicit conversion to foat
Existe uma conversão implícita predefinida de byte, ushort ou char a uint. Em qualquer outro
caso, deve utilizar uma conversão explícita. Por exemplo, para uma variável do tipo ong, myOng,
a seguinte instrução dassinalação produzirá um erro de compilação sem uma conversão explícita:
ong myOng = 22;
uint myUint = myOng; // Erro: não implicit conversion from ong
uint myUint = (uint)myOng; // OK: explicit conversion
Observe que tampoco existe conversão implícita de tipos de ponto flutuante a uint. Por exemplo,
a instrução seguinte gerará um erro de compilação, a menos que se utilize uma conversão
explícita:
uint x = 3.0; // Erro: não implicit conversion from double
uint e = (uint)3.0; // OK: explicit conversion
Para obter mais informação sobre expressões aritméticas com tipos de ponto flutuante e tipos
integrais, veja foat e double.
Para obter mais informação sobre as regas de conversão numérica implícitas, veja a Taba de
conversões numéricas implícitas.

Visual C# Consolidado 227


PALAVRA-CHAVE CHAR
A palavra-chave char é utilizado para declarar um carácter Unicode no intervalo indicado na
seguinte tabla. Os caracteres Unicode são caracteres de 16 bits que se utilizam para representar
a maioría de os lenguajes escritos de todo ou mundo.

Tipo do .NET
Tipo Intervalo Tamanho Framework

char U+0000 a U+ffff Carácter Unicode de 16 bits System.Char

Literais
As constantes do tipo char podem se escrever como caracteres literais, secuencias de escape
hexadecimales ou representações Unicode. Os códigos de caracteres integrais podem se
converter explícitamente ao tipo char. Em as seguintes instruções se declara uma variável do tipo
char e se inicializa com o carácter X:
char MyChar = 'X'; // Character literal
char MyChar = '\x0058'; // Hexadecimal
char MyChar = (char)88; // Cast from integral type
char MyChar = '\u0058'; // Unicode
Conversões
Um valor do tipo char pode converter implícitamente a os tipos ushort, int, uint, ong, uong,
foat, double ou decimal. Sem embargo, não existem conversões implícitas desde outros tipo
ao tipo char.

Palavra-chave foreach, in
A instrução foreach repite um grupo de instruções incluidas no laço para cada elemento de uma
matriz ou de um objeto collection. A instrução foreach é utilizado para iterar em uma coleção de
elementos e obter a informação desejada, pois não deve utilizar para cambiar ou contenido da
colecção, já que podem se produzir efectos secundarios imprevisibles. A instrução apresenta a
seguinte forma:
f o r e a c h ( type identifier i n expression) statement
de onde:
type
Tipo do identificador identifier.
identifier
• Variável de iteração que reapresenta ou elemento da colecção. Se a variável de iteração é
um tipo de valor, se trata em efeito de uma variável de só lectura que não pode ser modificada.
expression
Expressão que reapresenta uma matriz ou uma coleção de objetos. ou tipo de os elementos da
coleção deve poder converterse ao tipo de identifier. Não utilize uma expressão que evalúe
como null.
Evalúe um tipo que implemente IEnumerable ou um tipo que declare um método
GetEnumerator. no último caso, GetEnumerator deve devoltar um tipo que implemente
IEnumerator ou que declare todos os métodos definidos em IEnumerator
statement

Visual C# Consolidado 228


• Instruções que se devem executar dentro do laço.
Comentarios
As instruções do laço seguem executándose para cada elemento da matriz ou a colecção.
Quando já se han recorrido todos os elementos da colecção, o controle se transfere à seguinte
instrução fora do bloco foreach.
Para obter mais informação acerca da palavra-chave foreach, incluidos exemplos de código,
veja os temas seguintes:
• Usar foreach com arrays
• Usar foreach com coleções

Palavra-chave volatile
A palavra-chave volatile indica que um campo pode ser modificado no programa pelo sistema
operativo, ou hardware ou um subproceso em execução de forma simultánea.
v o l a t i l e declaration
de onde:
declaration
• A declaração de um campo.
Comentarios
O sistema siempre lee o valor atual de um objeto volátil no ponto de onde se solicita, aum quando
a instrução previa pidiera um valor ao mesmo objeto. Assim mesmo, o valor de um objeto se
escreve inmediatamente no momento da assinalação.
O modificador volatile se suele utilizar para um campo ao que tengan acesso varios
subprocesses sem utilizar a instrução ock para serializar ou acesso . O uso do modificador
volatile garante que um subproceso recupere o valor mais atualizado de os escritos por outro
subproceso.
O tipo de um campo marcado como volátil está restringido a os seguintes tipos:
• Qualquer tipo de referencia.
• Qualquer tipo de ponteiro (em um contexto não seguro).
• Os tipos byte, sbyte, short, ushort, int, uint, char, foat ou bool.
• Um tipo enum com um tipo base enum de byte, sbyte, short, ushort, int ou uint.
Para obter mais informação sobre o modificador volatile, veja 10.4.3 Campos volátiles.
Exemplo
O Exemplo seguinte mostra como declarar uma variável de campo pública como volatile.
// csharp_volatile.cs
class Test
{
public volatile int i;

Test(int _i)
{
i = _i;
}
public static void Main()
{

Visual C# Consolidado 229


}
}

Palavra-chave delegate
Uma declaração delegate define um tipo de referencia que pode utilizar para encapsular um
método com uma firma específica. uma instancia de delegado encapsua um método estático ou
de instancia. Os delegados são similares a os ponteiros a funções de C++, pois são mais seguros
e proporcionam maior seguridad de tipos.
A declaração apresenta a seguinte forma:
[attributes] [modifiers] d e l e g a t e result-type identifier ( [formal-parameters]) ;
de onde:
attributes (opcional)
Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes
datributo, veja 17. Atributos.
modifiers (opcional)
Os modificadores permitidos são new e os cuatro modificadores de acesso .
result-type
• Tipo do resultado, que coincide com o tipo devuelto do método.
identifier
• Mome do delegado.
formal-parameters (opcional)
Lista de parâmetros. Se um parâmetro é um ponteiro, ou delegado deve declararse com o
modificador unsafe.
Comentarios
Um delegado permite passar uma função como parâmetro. A seguridad de tipos de os delegados
requiere que a função que se pasa como delegado tenga a mesma firma que a declaração do
delegado. Veja ou Tutorial de delegados para obter mais informação sobre o uso de delegados.
O Tutorial de delegados mostra como componer delegados, assim, criar delegados a partir de
outros delegados. um delegado que contém um parâmetro out não pode componer.
Os delegados são a base de os eventos.
Para obter mais informação sobre delegados, veja 15. Delegados.
Exemplo 1
O seguinte é um Exemplo sencilo de declaração e uso de um delegado.
// keyword_delegate.cs
// delegate declaration
delegate void MyDelegate(int i);

class Program
{
public static void Main()
{
TakesADelegate(new MyDelegate(DelegateFunction));
}
public static void TakesADelegate(MyDelegate SomeFunction)
{

Visual C# Consolidado 230


SomeFunction(21);
}
public static void DelegateFunction(int i)
{
System.Console.WriteLine("Called by delegate with number: {0}.", i);
}
}
Resultados
Called by delegate with number: 21.
Exemplo 2
no seguinte exemplo, um delegado se assinala os métodos estáticos e de instancia e devolve
informação específica de cada unão de elos.
// keyword_delegate2.cs
// Calling both static and instance methods from delegates
using System;

// delegate declaration
delegate void MyDelegate();

public class MyClass


{
public void InstanceMethod()
{
Console.WriteLine("A message from the instance method.");
}

static public void StaticMethod()


{
Console.WriteLine("A message from the static method.");
}
}
public class MainClass
{
static public void Main()
{
MyClass p = new MyClass();

// Map the delegate to the instance method:


MyDelegate d = new MyDelegate(p.InstanceMethod);
d();

// Map to the static method:


d = new MyDelegate(MyClass.StaticMethod);
d();
}
}
Resultados
A message from the instance method.
A message from the static method.

Visual C# Consolidado 231


Palavra-chave ock
A palavra-chave ock marca um bloco de instruções como uma seção crucial, para o que utiliza ou
boqueo de exclusión mutua de um objeto, a execução de uma instrução y, posteriormente, a
liberação do boqueo. A instrução apresenta a seguinte forma:
o c k ( expression) statement_bock
de onde:
expression
Especifica ou objeto sobre ou que se deseja aplicar a instrução ock. Expression deve ser um tipo
de referencia.
Normalmente, expression será this, se se deseja proteger uma variável de instancia, ou biem
typeof(classe), se se deseja proteger uma variável do tipo static (o se a seção crítica se encontra
em um método estático da classe dada).
statement_bock
• Instruções da seção crítica.
Comentarios
A instrução ock permite garantizar que um subproceso não va a entrar em uma seção crítica de
código enquanto outro subproceso já se encontra em ella. Se outro subproceso intenta entrar em
um código boqueado, esperará até que o objeto se libere.
Exemplo 1
O seguinte Exemplo mostra um uso simple de subprocesses em C#.
// statements_ock.cs
using System;
using System.Threading;

class ThreadTest
{
public void runme()
{
Console.WriteLine("runme called");
}

public static void Main()


{
ThreadTest b = new ThreadTest();
Thread t = new Thread(new ThreadStart(b.runme));
t.Start();
}
}
Resultado
runme called
Exemplo 2
O seguinte Exemplo usa subprocesses e ock. Enquanto a instrução ock está presente, o bloco
de instruções constituye uma seção crítica e balance nunca se converterá em um número
negativo.
// statements_ock2.cs
using System;

Visual C# Consolidado 232


using System.Threading;

class Account
{
int balance;
Random r = new Random();
public Account(int initial)
{
balance = initial;
}
int Withdraw(int amount)
{

// This condition will never be true unless the ock statement


// is commented out:
if (balance < 0)
{
throw new Exception("Negative Balance");
}
// Comment out the next line to see the effect of leaving out
// the ock keyword:
ock (this)
{
if (balance >= amount)
{
Console.WriteLine("Balance before Withdrawal :" +balance);
Console.WriteLine("Amount to Withdraw :-"+ amount);
balance = balance - amount;
Console.WriteLine("Balance after Withdrawal : " + balance);
return amount;
}
else
{
return 0; // transaction rejected
}
}
}
public void DoTransactions()
{
for (int i = 0; i < 100; i++)
{
Withdraw(r.Next(1, 100));
}
}
}
class Test
{
public static void Main()
{
Thread[] threads = new Thread[10];
Account acc = new Account (1000);
for (int i = 0; i < 10; i++)
{
Thread t = new Thread(new ThreadStart(acc.DoTransactions));
Visual C# Consolidado 233
threads[i] = t;
}
for (int i = 0; i < 10; i++)
{
threads[i].Start();
}
}
}

Palavra-chave stackaloc
Permite assinalar um bloco de memoria na pilba.
type * ptr = s t a c k a l o c type [ expr ] ;
de onde:
type
• Tipo não administrado.
ptr
• Mome de ponteiro.
expr
• Expressão entera.
Comentarios
Se reserva na pia um bloco de memoria de tamanho suficiente para conter expr elementos do
tipo type; a direção do bloco se armazena no ponteiro ptr. Esta memoria não está sometida a
reciclaje y, por o tanto, não necessita fijarse (por medio de fixed). A vida do bloco de memoria se
limita à vida do método no que se define.
O operador stackaloc só é válido em inicializadores de variáveis ocales.
Como se utilizam ponteiros (ver A.2 Tipos de ponteiro), stackaloc requiere um contexto unsafe.
O operador stackaloc é similar a _aloca da biblioteca de tiempo de execução de C.
Exemplo
// cs_keyword_stackaloc.cs
// compile with: /unsafe
using System; class Test
{
public static unsafe void Main()
{
int* fib = stackaloc int[100];
int* p = fib;
*p++ = *p++ = 1;
for (int i=2; i<100; ++i, ++p)
*p = p[-1] + p[-2];
for (int i=0; i<10; ++i)
Console.WriteLine (fib[i]);
}
}
Resultado
1

Visual C# Consolidado 234


1
2
3
5
8
13
21
34
55

Visual C# Consolidado 235


Visual C# Consolidado 236
OPERADORES C#
C# fornece um conjunto grande de operadores, que são símbolos que especificam as operações
para executar em uma expressão. C# predefines os operadores aritméticos e lógicos normal, bem
como uma variedade de outras pessoas como mostrado na tabela a seguir. Operações em
integral tipos, como ==, !=, <, >, <=, >=, binary +, binary -, ^, &, |, ~, ++, --,. e
sizeof() geralmente são permitidos em enumerações Além disso, vários operadores podem ser
Sobrecarregado pelo usuário, assim alterando seu significado quando aplicado a um tipo definido
pelo usuário.
Categoria de operadores Operadores
Aritmética + - * / %
Lógico (boolean e bit a bit) & | ^ ! ~ && || True False
Concatenação de seqüência de caracteres +
Incremento, decrement ++ --
SHIFT << >>
Relacional == != < > <= >=
Atribuição = += -= *= /= %= &= |= ^= <<= >>= ??
Acesso membro .
Indexação []
Conversão ()
Condicional ?:
Concatenação representante e remoção + -
A criação do objeto Novo
Informações de Tipo Como é sizeof TypeOf
Estouro Controle de exceção Marcada desmarcada
Indirection e endereço * -> [] &

Estouro Aritmético
Os operadores aritméticos (+., -) pode produzir resultados que estejam fora do intervalo dos
valores possíveis para o tipo numérico envolvido, /* Você deve consultar a seção sobre um
operador específico para obter detalhes, mas em geral:
• Qualquer throws estouro aritmético inteiro ou descarta os bits do resultado mais
significativos. um OverflowException Divisão por zero sempre throws um
DivideByZeroException.
• Ponto flutuante estouro aritmético ou divisão por zero nunca gera uma exceção, como
tipos de ponto flutuante estão baseados em IEEE 754 and caso tenha disposições para
representar infinito e NaN (Not a Number).
• Estouro Aritmético Decimal Sempre gera um OverflowException. Decimal divisão por
zero sempre throws um DivideByZeroException.
Quando estouro inteiro ocorre, o que acontece depende do contexto de execução, que pode ser
marcado ou desmarcado. Em um contexto selecionado, será gerada. um OverflowException
Em um contexto desmarcado, os bits do resultado mais significativos são descartados e continua
a execução. Assim, C# oferece a você a opção de manipulação ou ignorando estouro.

Visual C# Consolidado 237


Os operadores aritméticos, além de tipo integral-tipo para integral-casts podem causar estouro,
por exemplo, Projetando e estão sujeitas às execução marcado ou desmarcado. para um Longo
An Int, Entretanto, operadores bit a bit e operadores SHIFT nunca causar estouro.

Transbordamento aritmético
Os operadores aritméticos (+, -, *, /) podem produzir resultados fora do intervalo de valores
possíveis para o tipo numérico implicado. Pode encontrar mais informação acerca de um
determinado operador na seção Referença do lenguaje C#; não obstante, em general:
• O transbordamento aritmético de inteiros inicia uma exceção de transbordamento
(OverflowExcetion) o bem elimina os bits mais significativos do resultado (véase mais abaixo).
a divisão de inteiros por cero sempre produz uma exceção DivideByZeroExcetion.
• O transbordamento aritmético ou a divisão por cero em ponto flutuante não produzem uma
exceção, já que os tipos de ponto flutuante se baseiam em o estándar IEEE 754, que
proporciona uma representação para os valores infinito e Nam (Not a Number, no é um
número).
• O transbordamento aritmético de valores do tipo decimal sempre produz uma exceção
OverflowExcetion. a divisão de valores decimal por zero sempre produz uma exceção
DivideByZeroExcetion.
Quando é produzido um transbordamento de inteiros, lo que ocurre depende do contexto da
execução, o qual pode ser checkede o unchecked. em um contexto checkede (comprobado), é
produzido uma exceção OverflowExcetion. em um contexto uncheckede (no comprobado), os bits
mais significativos do resultado não se temm em cuenta e a execução continúa. Desta forma, C#
permite escolher entre atender o desatender o transbordamento.
Além dos operadores aritméticos, as conversões explícitas entre tipos integrais também podem
produzir transbordamento (por exemplo, converter um tipo long em um tipo int) e estão sometidas
ao tipo de execução checkede o unchecked. Por otro lado, observe que os operadores de
deslocamento e de bit a bit nunca produzem transbordamento.

Operadores sobrecarregados
C# permite sobrecarregar operadores nos tipos definidos pelo usuario, mediante a definição, com
a palavra chave operator, de funções membro estáticas. Não obstante, no todos os operadores
podem ser sobrecarregados, e alguns apresentam restricções, como se indica na seguinte tabela:

Operadores Posibilidade de sobrecarrega


+, -, !, ~, ++, --, true, false Estes operadores unários podem ser sobrecarregados.
+, -, *, /, %, &, |, ^, <<, >> Estes operadores binários podem ser
sobrecarregados.

Visual C# Consolidado 238


==, !=, <, >, <=, >= Os operadores de comparação podem ser
sobrecarregados (veja a nota mais abaixo).
&&, || Os operadores lógicos não podem ser cargar, mas se
avaliam com & e |, que podem sobrecarregarse. Veja
7.11.2 Operadores lógicos condicionais definidos pelo
usuario.
[] O operador de indicação de arrays não pode
sobrecarregar, mas podem ser definido indicadores.
() O operador de conversão explícita do tipos não pode
sobrecarregar, mas podem ser definido novos
operadores de conversão (veja explicit e implicit).
+=, -=, *=, /=, %=, &=, |=, ^=, <<=, Os operadores de assinalação não podem ser
>>= sobrecarregados, mas +=, por exemplo, se avalia com
+, o qual se pode sobrecarregar.
=, ., ?:, ->, new, is, sizeof, typeof Estes operadores não podem ser sobrecarregados.

Nota os operadores de comparação, se sobrecarregam, devem ser por parejas; é dizer, se


sobrecarrega ==, também deve sobrecarregar !=. Também é cierta a opção contraria,
análogamente para o caso de < e >, e para <= e >=.

Operador [ ]
Os colchetes ([ ]) são utilizados para arrays, indicadores e atributos. Também podem ser utilizar
com ponteiros.
type [ ]
array [ indexexpr ]
De onde:
type
Tipo.
array
Array.
indexexpr
Expressão de índice.
Comentarios
Um tipo de array é composto de um tipo seguido de []:
int[] fib; // fib is of type int[], "array of int"
fib = new int[100]; // criate a 100-element int array
Para obter acesso a um elemento do array, o índice do elemento desejado se encierra entre
colchetes:
fib[0] = fib[1] = 1;
for( int i=2; i<100; ++i ) fib[i] = fib[i-1] + fib[i-2];
É produzido uma exceção se o índice do array está fora do intervalo declarado.
O operador de indicação não pode sobrecarregar; não obstante, os tipos podem definir
indicadores, que são propriedades que aceitam um ou varios parâmetros. Os parâmetros de um

Visual C# Consolidado 239


indicador ficam entre colchetes, como os índices de um array, mas podem ser declarar de
qualquer tipo (a diferença dos índices de um array, que somente podem ser integrais).
Por exemplo, .NET Framework define um tipo Hashtable que asoça chaves e valores do tipo
arbitrario:
Collections.Hashtable h = new Collections.Hashtable();
h["a"] = 123; // note: using a string as the index
Os colchetes também são utilizados para especificar atributos:
[attribute(AllowMultiple=true)]
public class Attr {
}
Podem ser utilizados colchetes para obter o valor que aponta um ponteiro segundo um índice
(veja A.2 Tipos de ponteiros):
unsafe fixede ( int* p = fib ) // p points to fib from earlier example
{
p[0] = p[1] = 1;
for( int i=2; i<100; ++i ) p[i] = p[i-1] + p[i-2];
}
Não obstante, tenga em cuenta que não se realiza uma comprobação dos límites do índice.

Operador ( )
Além disso de seu uso para especificar o ordem de as operações em uma expressão, os
paréntesis são utilizados para especificar conversões do tipo explícitas (cast):
( type ) expr
De onde:
type
Nome do tipo o que se deseja converter a expressão expr.
expr
Expressão.
Comentarios
Uma conversão do tipo invoca explícitamente ao operador de conversão para converter o tipo da
expressão expr ao tipo type; será produzido um erro na conversão se não se tenha definido esse
operador. Para definir um operador de conversão, veja explicit e implicit.
Exemplo
O seguinte programa converte explícitamente um tipo double em um tipo int. O programa não
compilará sem o operador de conversão do tipo.
// cs_operator_parentheses.cs
using System;
class Test
{
public static void Main()
{
double x = 1234.7;
int a;
a = (int)x; // cast double to int
Console.WriteLine(a);

Visual C# Consolidado 240


}
}
Resultado
1234

Operador . (ponto)
O operador de ponto é utilizado para o acesso a membros.
name1 . name2
De onde:
name1
Nome.
name2
Nome.
Comentarios
Por exemplo, considere a seguinte clase:
class Simple
{
public int a;
public void b()
{
}
}
Simple s = new Simple();

A variáveis tem dos membros, a e b; para tener acesso a ellos, use o operador de ponto:
s.a = 6; // assign to field a;
s.b(); // invoke member function b;
O ponto também é utilizado para formar nomes completos, é dizer, nomes que especificam o
namespaces ou a interfaz (por exemplo) à que pertencem.
System.Console.WriteLine("hello"); // class Console in namespace System
A directiva using hace que a calificação de nomes seja opcional em alguns casos:
using System;
...
System.Console.WriteLine("hello");
Console.WriteLine("hello"); // same thing
Mas, um identificador ambiguo deve calificarse:
using System;
using OtherSystem; // a namespace containing another Console class
...
System.Console.WriteLine( "hello" ); // must qualify Console

Operador +
O operador + pode funcionar como operador unário o binário.

Visual C# Consolidado 241


+ expr
expr1 + expr2
De onde:
expr
Expressão.
expr1
Expressão.
expr2
Expressão.
Comentarios
Os operadores + unários se encontram predefinidos para todos os tipos numéricos. O resultado
de uma operação + unaria aplicada a um tipo numérico é simplemente o valor do operando.
Os operadores + binários estão predefinidos para os tipos numéricos e de cadena de caracteres.
Para tipos numéricos, + calcula a suma de seus dos operandos. Quando ao menos um dos
operandos é do tipo string, + concatena as representações do tipo string dos operandos.
Os tipos delegados também proporcionam um operador binário +, o qual realiza a concatenação
de delegados.
Os tipos definidos pelo usuario podem sobrecarregar os operadores + unário e binário (veja
operator).
Exemplo
// cs_operator_plus.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(+5); // unary plus
Console.WriteLine(5 + 5); // addition
Console.WriteLine(5 + .5); // addition
Console.WriteLine("5" + "5"); // string concatenation
Console.WriteLine(5.0 + "5"); // string concatenation
// note automatic conversion from double to string
}
}
Resultado
5
10
5.5
55
55

Operador -
O operador - pode funcionar como operador unário o binário.
- expr
Visual C# Consolidado 242
expr1 - expr2
De onde:
expr
Expressão.
expr1
Expressão.
expr2
Expressão.
Comentarios
Os operadores - unários se encontram predefinidos para todos os tipos numéricos. O resultado de
uma operação - unaria aplicada a um tipo numérico é a negação do operando.
Os operadores – binários estão predefinidos para todos os tipos numéricos e de enumeração de
modo que restam o segundo operando do primeiro.
Os tipos delegados também proporcionam um operador - binário, o qual realiza a eliminação de
delegados.
Os tipos definidos pelo usuario podem sobrecarregar os operadores - unário e binário (veja
operator).
Exemplo
// cs_operator_minus.cs
using System;
class Test
{
public static void Main()
{
int a = 5;
Console.WriteLine(-a);
Console.WriteLine(a - 1);
Console.WriteLine(a - .5);
}
}
Resultado
-5
4
4.5

Operador *
O operador de multiplicação (*) calcula o produto de seus operandos. Todos os tipos numéricos
possuem operadores de multiplicação predefinidos.
expr1 * expr2
De onde:
expr1
Expressão.
expr2

Visual C# Consolidado 243


Expressão.
Comentarios
O operador * também é utilizado para declarar tipos de ponteiros e para desfazer a referença a
ponteiros (veja A.2 Tipos de ponteiros).
Os tipos definidos pelo usuario podem sobrecarregar o operador * (veja operator).
Exemplo
// cs_operator_mult.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(5 * 2);
Console.WriteLine(-.5 * .2);
Console.WriteLine(-.5m * .2m); // decimal type
}
}
Resultado
10
-0.1
-0.10

Operador /
O operador de divisão (/) permite dividir seu primeiro operando pelo segundo. Todos os tipos
numéricos possuem operadores de divisão predefinidos.
expr1 / expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador / (veja operator).
Exemplo
// cs_operator_division.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(-5/2);
Console.WriteLine(-5.0/2);
}
}

Visual C# Consolidado 244


Resultado
-2
-2.5

Operador %
O operador de módulo (%) calcula o resto de dividir seu primeiro operando pelo segundo. Todos
os tipos numéricos possuem operadores de módulo predefinidos.
expr1 % expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador % (veja operator).
Exemplo
// cs_operator_modulus.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(5 % 2); // int
Console.WriteLine(-5 % 2); // int
Console.WriteLine(5.0 % 2.2); // double
Console.WriteLine(5.0m % 2.2m); // decimal
Console.WriteLine(-5.2 % 2.0); // double
}
}
Resultado
1
-1
0.6
0.6
-1.2
Observe os erros de rede onde o que apresenta o tipo double.

Operador &
O operador & pode funcionar como operador unário o binário.
& expr
expr1 & expr2
De onde:
expr
Visual C# Consolidado 245
Expressão.
expr1
Expressão.
expr2
Expressão.
Comentarios
O operador & unário devolve a direção de memoria de seu operando (requiere um contexto
unsafe).
Os operadores & binários estão predefinidos para os tipos integrais e bool. Para tipos integrais, &
calcula a operação AND bit a bit de seus operandos. Para operandos do tipo bool, & calcula a
operação lógica AND de seus operandos; é dizer, o resultado é true se, e somente se, ambos
operandos são true.
Os tipos definidos pelo usuario podem sobrecarregar o operador & binário (veja operator).
Exemplo
// cs_operator_ampersand.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(true & false); // logical and
Console.WriteLine(true & true); // logical and
Console.WriteLine("0x{0:x}", 0xf8 & 0x3f); // bitwise and
}
}
Resultado
False
True
0x38

Operador |
Os operadores binários | estão predefinidos para os tipos integrais e bool. Para tipos integrais, |
calcula a operação OR bit a bit de seus operandos. Para operandos do tipo bool, | calcula a
operação lógica OR de seus operandos; é dizer, o resultado é false se, e somente se, ambos
operandos são false.
expr1 | expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador | (veja operator).

Visual C# Consolidado 246


Exemplo
// cs_operator_OR.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(true | false); // logical or
Console.WriteLine(false | false); // logical or
Console.WriteLine("0x{0:x}", 0xf8 | 0x3f); // bitwise or
}
}
Resultado
True
False
0xff

Operador ^
Os operadores ^ binários estão predefinidos para os tipos integrais e bool. Para tipos integrais, ^
calcula a operação OR exclusiva bit a bit de seus operandos. Para operandos do tipo bool, ^
calcula a operação lógica OR exclusiva de seus operandos; é dizer, o resultado é true se, e
somente se, exatamente um dos operandos é true.
expr1 ^ expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador ^ (veja operator).
Exemplo
// cs_operator_bitwise_OR.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(true ^ false); // logical exclusive-or
Console.WriteLine(false ^ false); // logical exclusive-or
Console.WriteLine("0x{0:x}", 0xf8 ^ 0x3f); // bitwise exclusive-or
}
}
Resultado
True
False

Visual C# Consolidado 247


0xc7

Operador !
O operador lógico negação (!) é um operador unário que nega seu operando. Está definido para o
tipo bool, e devolve true se, e somente se, seu operando é false.
! expr
De onde:
expr
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador ! (veja operator).
Exemplo
// cs_operator_negation.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(!true);
Console.WriteLine(!false);
}
}
Resultado
False
True

Operador ~
O operador ~ realiza uma operação de complemento bit a bit sobre seu operando. Os operadores
de complemento bit a bit estão predefinidos para int, uint, long e ulong.
~ expr
De onde:
expr
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador ~ (veja operator).
Exemplo
// cs_operator_bitwise_compl.cs
using System;
class Test
{
public static void Main()
{

Visual C# Consolidado 248


Console.WriteLine("!0x{0:x8} = 0x{1:x8}", 8, ~8);
Console.WriteLine("!0x{0:x8} = 0x{1:x8}", -8, ~-8);
}
}
Resultado
!0x00000008 = 0xfffffff7
!0xfffffff8 = 0x00000007

Operador =
O operador de assinalação (=) armazena o valor do operando situado a seu direita na colocação
de armazenamento, propriedade ou indicador indicado pelo operando situado a seu esquerda, e
devolve o valor como resultado. Os operandos devem ser do mesmo tipo (o o operando da direita
deve poder converter implícitamente ao tipo do operando da esquerda).
lhs = expr
De onde:
lhs
Uma colocação de armazenamento, uma propriedade ou um indicador.
expr
Expressão.
Comentarios
O operador de assinalação não pode sobrecarregar.
Exemplo
// cs_operator_assignment.cs
using System;
class Test
{
public static void Main()
{
double x;
int i;
i = 5; // int to int assignment
x = i; // implicit conversion from int to double
i = (int)x; // needs cast
Console.WriteLine("i is {0}, x is {1}", i, x);
object obj = i;
Console.WriteLine("boxede value = {0}, type is {1}",
obj, obj.GetType());
i = (int)obj;
Console.WriteLine("unboxed: {0}", i);
}
}
Resultado
i is 5, x is 5
boxede value = 5, type is System.Int32
unboxed: 5

Visual C# Consolidado 249


Operador <
Todos os tipos numéricos e de enumeração definem um operador relacional "menor que" (<) que
devolve true se o primeiro operando é menor que o segundo, e false em caso contrario.
expr1 < expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador < (veja operator). se
sobrecarrega <, também deve sobrecarregar >.
Exemplo
// cs_operator_less_than.cs
using System;
class Test
{
public static void Main()
{
Console.WriteLine(1 < 1.1);
Console.WriteLine(1.1 < 1.1);
}
}
Resultado
True
False

Operador >
Todos os tipos numéricos e de enumeração definem um operador relacional "maior que" (>) que
devolve true se o primeiro operando é maior que o segundo, e false em caso contrario.
expr1 > expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
Os tipos definidos pelo usuario podem sobrecarregar o operador > (veja operator). se
sobrecarrega >, também deve sobrecarregar <.
Exemplo
// cs_operator_greater_than.cs

Visual C# Consolidado 250


using System;
class Test
{
public static void Main()
{
Console.WriteLine(1.1 > 1);
Console.WriteLine(1.1 > 1.1);
}
}
Resultado
True
False

Operador ?:
O operador condicional (?:) devolve um de dois valores segundo o valor de uma expressão
booleana. O operador condicional é utilizado em expressões da forma:
cond-expr ? expr1 : expr2

De onde:
cond-expr
Expressão do tipo bool.
expr1
Expressão.
expr2
Expressão.
Comentarios
Si cond-expr é true, expr1 se avalia e se devolve como resultado; se cond-expr é false, é
expr2 a que se avalia e se devolve como resultado. Somente uma de as dos, expr1 o expr2,
resulta evaluada.
Os cálculos que, em qualquer otro caso, podrían requerir um bloque de decisão if-elpodem ser
expresar mais concisa e elegantemente mediante o operador condicional. Por exemplo, para
evitar uma divisão por cero em o cálculo da função sinc, podría escreverse:
if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;
o bien, com o operador condicional,
s = x != 0.0 ? Math.Sin(x)/x : 1.0;
O operador condicional é asociativo por a direita, de modo que uma expressão da forma:
a ? b : c ? de : e
se avalia como
a ? b : (c ? de : e)
en lugar de
(a ? b : c) ? de : e

Visual C# Consolidado 251


O operador condicional não pode sobrecarregar.
Exemplo
// cs_operator_condicional.cs
using System;
class Test
{
public static double sinc(double x)
{
return x != 0.0 ? Math.Sin(x)/x : 1.0;
}

public static void Main()


{
Console.WriteLine(sinc(0.2));
Console.WriteLine(sinc(0.1));
Console.WriteLine(sinc(0.0));
}
}
Resultado
0.993346653975306
0.998334166468282
1

Operador ++
O operador de incremento (++) incrementa seu operando em 1. Este operador pode aparecer
antes o depois de seu operando:
+ + var
var + +
De onde:
var
Expressão que indica uma colocação de armazenamento, uma propriedade ou um indicador.
Comentarios
A primeira forma é uma operação de incremento prefixo. O resultado da operação é o valor do
operando depois de haver sido incrementado.
A segunda forma é uma operação de incremento postfijo. O resultado da operação é o valor do
operando antes de haver sido incrementado.
Os tipos numéricos e de enumeração possuem operadores de incremento predefinidos. Os tipos
definidos pelo usuario podem sobrecarregar o operador ++ (veja operator).
Exemplo
// cs_operator_increment.cs
using System;
class Test
{
public static void Main()
{
double x;

Visual C# Consolidado 252


x = 1.5;
Console.WriteLine(++x);
x = 1.5;
Console.WriteLine(x++);
Console.WriteLine(x);
}
}
Resultado
2.5
1.5
2.5

Operador --
O operador de decremento (--) reduz seu operando em 1. Este operador pode aparecer antes o
depois de seu operando:
- - var
var - -
De onde:
var
Expressão que indica uma colocação de armazenamento, uma propriedade ou um indicador.
Comentarios
A primeira forma é uma operação de decremento prefixo. O resultado da operação é o valor do
operando depois de haver experimentado o decremento.
A segunda forma é uma operação de decremento postfijo. O resultado da operação é o valor do
operando antes de haver experimentado o decremento.
Os tipos numéricos e de enumeração possuem operadores de decremento predefinidos. Os tipos
definidos pelo usuario podem sobrecarregar o operador -- (veja operator).
Exemplo
// cs_operator_decrement.cs
using System;
class Test
{
public static void Main()
{
double x;
x = 1.5;
Console.WriteLine(--x);
x = 1.5;
Console.WriteLine(x--);
Console.WriteLine(x);
}
}

Visual C# Consolidado 253


Resultado
0.5
1.5
0.5

Operador &&
O operador AND condicional (&&) realiza uma operação lógica AND de seus operandos do tipo
bool mas somente avalia seu segundo operando se é necessário.
expr1 & & expr2
De onde:
expr1
Expressão.
expr2
Expressão.
Comentarios
A operação
x && y
corresponde com a operação
x&y
salvo que se x é false, e não se avalia (já que o resultado da operação AND será false
independentemente do valor de y). Este se conhece como evaluação "cortocircuitada".
O operador AND condicional não pode sobrecarregar, mas as sobrecarregas dos operadores
lógicos normales e os operadores true e false se consideran tambem, com ciertas restricções,
sobrecarregas dos operadores lógicos condicionais (veja 7.11.2 Operadores lógicos condicionais
definidos pelo usuario).
Exemplo
No seguinte exemplo, observe que a expressão que utiliza && somente avalia o primeiro
operando.
// cs_operator_logical_and.cs
using System;
class Test
{
static bool fn1()
{
Console.WriteLine("fn1 called");
return false;
}

static bool fn2()


{
Console.WriteLine("fn2 called");

Visual C# Consolidado 254


return true;
}

public static void Main()


{
Console.WriteLine("regular AND:");
Console.WriteLine("result is {0}", fn1() & fn2());
Console.WriteLine("short-circuit AND:");
Console.WriteLine("result is {0}", fn1() && fn2());
}
}
Resultado
regular AND:
fn1 called
fn2 called
result is False
short-circuit AND:
fn1 called
result is False

Visual C# Consolidado 255


DIRECTIVES PREPROCESSOR C#
Esta seção discute diretivas pré-processamento é a linguagem C#:
#IF
# Else
#elif
#endif
Definir #
#undef
#warning
#Error
# Line
#Region
#endregion
# pragma
Aviso # pragma
Soma de verificação # pragma
Enquanto o compilador não não têm um preprocessor separado, as diretivas descritas nesta
seção são processadas como se não havia um; essas diretivas são usadas para ajudar na
compilação condicional. Ao contrário das diretivas C e C++, você não pode usar essas diretivas
para criar macros.
Uma diretiva de pré-processamento deve ser a única instrução em uma linha.

#If (referência C#)


Permite que #if você iniciar uma diretiva condicional, teste um símbolo ou símbolos para ver se
eles avaliada como true. Se eles fazer Avaliar a true, o compilador avaliará todo o código entre
e #if a diretiva mais próximo #endif. Por exemplo,
#define DEBUG // ... #if DEBUG Console.WriteLine("Debug version"); #endif
Você pode usar os operadores == (igualdade), = (inequality), && (e). e || (ou) para avaliar vários
símbolos Você também pode agrupar símbolos e operadores com parênteses.
Comentários
#if e #undef diretivas, permite que você incluir ou excluir código com base na condição de um ou
mais símbolos., #endif juntamente com, Definir # o # Else, #elif Isso pode ser útil durante a
compilação código para uma compilação de depuração ou quando compilar para uma
configuração específica.
Um começando diretiva condicional com uma #if diretiva explicitamente deve ser terminado com
uma #endif diretiva.
Permite que #define você defina um símbolo, que, usando o símbolo como a expressão
transmitida para a #if diretiva, a expressão será avaliada para true.
Você também pode definir um símbolo com a / Define opção de compilador. Você pode undefine
um símbolo com #undef.

Visual C# Consolidado 256


Um símbolo que você define com /define ou com #define não entrará em conflito com uma
variável com o mesmo nome. Isto é, um nome de variável não deve ser passado para uma
Diretiva de pré-processamento e um símbolo só pode ser avaliado por uma diretiva de pré-
processamento.
O escopo de um símbolo criado com #define é o arquivo no qual ele foi definido.
Exemplo
// preprocessor_if.cs #define DEBUG #define VC_V7 using System; public class MyClass { static
void Main() { #if (DEBUG && !VC_V7) Console.WriteLine("DEBUG is defined"); #elif (!DEBUG
&& VC_V7) Console.WriteLine("VC_V7 is defined"); #elif (DEBUG && VC_V7)
Console.WriteLine("DEBUG and VC_V7 are defined"); #else Console.WriteLine("DEBUG and
VC_V7 are not defined"); #endif } }
Saída
DEBUG and VC_V7 are defined

#Else Pessoa (referência C#)


Permite que #else você crie uma diretiva condicional composta, para que, se nenhuma das
expressões nas diretivas Anterior #IF ou (opcional) #elif para true, o compilador será avaliarão
todo código entre #else e os subseqüentes #endif.
Comentários
Deve #endif ser a próxima diretiva pré-processamento após #else. Veja #IF um Exemplo de
como usar #else.

#elif (referência C#)


Permite que #elif você crie uma diretiva condicional composta. Será a #elif expressão ser
avaliada se nem o precedente #IF nem todas as expressões anterior, opcional, #elif diretiva
avaliada como true. Se uma #elif expressão avaliada como true, o compilador avaliará todo o
código entre e #elif a próxima diretiva condicional. Por exemplo:
#define VC7 //... #if debug Console.Writeline("Debug build"); #elif VC7
Console.Writeline("Visual Studio 7"); #endif
Você pode usar os operadores == (igualdade), != (inequality), && (e). e || (ou), para avaliar
vários símbolos Você também pode agrupar símbolos e operadores com parênteses.
Comentários
Equivale #elif a usar:
#else #if
Uso #elif é mais simples, porque cada #if requer pode ser usada sem um correspondente
#endif. enquanto a #endif, um #elif
Veja #IF um Exemplo de como usar #elif.

#endif (referência C#)


Especifica #endif o término de uma diretiva condicional, que começou com a #IF diretiva. Por
exemplo,
#define DEBUG // ...
#if DEBUG Console.WriteLine("Debug version");
#endif

Visual C# Consolidado 257


Comentários
Uma diretiva condicional, começando com uma #if diretiva, explicitamente deve ser terminada
com uma #endif diretiva. Veja #If (referência C#) um Exemplo de como usar #endif.

# Definir (referência C#)


Permite que #define você defina um símbolo, para que, usando o símbolo como a expressão
transmitida para a #IF diretiva, a expressão será avaliada para true. Por exemplo:
#define DEBUG
Comentários
Símbolos podem ser usados para especificar condições para a compilação. Você pode testar para
o símbolo com um #IF ou #elif. Você também pode usar o conditional atributo para executar
compilação condicional.
Você pode definir um símbolo, mas você pode atribuir um valor para um símbolo. A #define
diretiva deve aparecer no arquivo antes de usar as instruções que são também não diretivas.
Você também pode definir um símbolo com a / Define opção de compilador. Você pode undefine
um símbolo com #undef.
Um símbolo que você define com /define ou com #define não entrará em conflito com uma
variável com o mesmo nome. Isto é, um nome de variável não deve ser passado para uma
Diretiva de pré-processamento e um símbolo só pode ser avaliado por uma diretiva de pré-
processamento.
O escopo de um símbolo criado com #define é o arquivo no qual ele foi definido.
Veja #IF um Exemplo de como usar #define.

#undef (referência C#)


Permite que #undef você undefine um símbolo, que, usando o símbolo como a expressão em
uma #IF diretiva, a expressão será avaliada para false.
Um símbolo pode ser definido tanto com a Definir # diretiva ou a / Define opção de compilador. A
#undef diretiva deve aparecer no arquivo antes de usar todas as instruções que são também
não diretivas.
Exemplo
// preprocessor_undef.cs // compile with: /d:DEBUG #undef DEBUG using System; class
MyClass { static void Main() { #if DEBUG Console.WriteLine("DEBUG is defined"); #else
Console.WriteLine("DEBUG is not defined"); #endif } }
Saída
DEBUG is not defined

#warning (referência C#)


Permite que #warning você gere um aviso um nível partir de um local específico em seu
código. Por exemplo:
#warning Deprecated code in this method.
Comentários
Um uso comum de #warning é em uma diretiva condicional. Também é possível para gerar um
erro definido pelo usuário com #Error (referência C#).

Visual C# Consolidado 258


Exemplo
// preprocessor_warning.cs // CS1030 expected #define DEBUG class MainClass { static void
Main() { #if DEBUG #warning DEBUG is defined #endif } }

#Error (referência C#)


Permite que #error você gerar um erro partir de um local específico em seu código. Por
exemplo:
#error Deprecated code in this method.
Comentários
Um uso comum de #error é em uma diretiva condicional.
Também é possível para gerar um aviso definida pelo usuário com #warning (referência C#).
Exemplo
// preprocessor_error.cs // CS1029 expected #define DEBUG class MainClass { static void
Main() { #if DEBUG #error DEBUG is defined #endif } }

# Line (referência C#)


Permite que #line você modificar o compilador o número de linha e (opcionalmente) a saída
nome de arquivo de erros e avisos. Este Exemplo mostra como para relatar dois avisos
associados a números de linha. A #line 200 diretiva força o número de linha a ser 200 (embora o
padrão seja #7). A outra linha (#9) segue a seqüência normal como um resultado da diretiva
padrão #line.
class MainClass { static void Main() { #line 200 int i; // CS0168 on line 200 #line default char c;
// CS0168 on line 9 } }
Comentários
A #line diretiva pode ser usada em uma etapa no processo de criação automatizado e
intermediários. Por exemplo, se linhas foram removidas do arquivo de código de fonte original,
mas você queria o compilador para gerar saída com base em numeração no arquivo, a linha
original ainda poderá remover linhas e depois simular a numeração original com #line Linha.
A #line hidden diretiva oculta as linhas sucessivas do depurador, de modo que quando o
desenvolvedor percorre o código, todas as linhas entre próxima #line diretiva (supondo que ele
esteja não outra #line hidden Diretiva) e #line hidden o ser steppeds sobre será. Esta
opção também pode ser usada para permitir ASP.NET para diferenciar entre código definido pelo
usuário e máquina gerado. Embora ASP.NET seja o consumidor primário a esse recurso, é
provável que mais origem geradores tornará usar dele.
Uma #line hidden diretiva não afeta nomes ou números de linha no relatório de erros. Isto é,
se um erro é encontrado em um bloco oculto, o compilador reportará o nome e linha número o
erro de arquivo.
A #line filename diretiva especifica o nome de arquivo você deseja que apareça na saída do
compilador. Por padrão, o nome do arquivo de código de origem real é usado. O nome de arquivo
deve ser entre aspas duplas () ". "
Um arquivo código fonte pode ter qualquer número de #line diretivas.
Exemplo 1

Visual C# Consolidado 259


O Exemplo a seguir mostra como o depurador ignora as linhas ocultas no código. Quando você
executar o exemplo, ela exibirá três linhas de texto. No entanto, quando você define um ponto de
interrupção, como mostrado no exemplo, e visitas F10 para passar pelo código, você notará que o
depurador ignora a linha oculta. Observe também que mesmo que você defina um ponto de
interrupção na linha oculta, o depurador irá ignorá-la ainda.
// preprocessor_linehidden.cs using System; class MainClass { static void Main() {
Console.WriteLine("Normal line #1."); // Set break point here. #line hidden
Console.WriteLine("Hidden line."); #line default Console.WriteLine("Normal line #2."); } }

#Region (referência C#)


Permite que #region você especifique um bloco de código que você pode expandir ou recolher
quando usar o Estrutura de tópicos recurso do Editor de Código Visual Studio. Por exemplo:
#region MyClass definition public class MyClass { static void Main() { } } #endregion
Comentários
Um #region bloco deve ser terminado com uma #endregion diretiva.
Um #region bloco não pode se sobrepor a um #IF bloco. No entanto, um #region bloco pode
ser aninhado em um #if bloco, e um #if bloco pode ser aninhado em um #region bloco.

#endregion (referência C#)


Marca #endregion o final de um #Region bloco. Por exemplo:
#region MyClass definition class MyClass { static void Main() { } } #endregion

# pragma (referência C#)


é #pragma usado para fornecer as instruções especiais para a compilação do arquivo em que
ele aparece do compilador
#pragma pragma-name pragma-arguments
Parâmetros
pragma-name
O nome de um pragma reconhecido.
pragma-arguments
Argumentos específicos Pragma-.

Aviso # pragma (referência C#)


Pode #pragma warning ser usado para ativar ou desativar determinados avisos.
#pragma warning disable warning-list #pragma warning restore warning-list
Parâmetros
warning-list

Visual C# Consolidado 260


Uma lista de números de aviso separted vírgulas. Digite os números sozinho, sem o
prefixo " CS ".
Quando nenhum número aviso são especificados, disable Desativa todos os avisos e
restore permite que todos os avisos.
Exemplo
// pragma_warning.cs using System; #pragma warning disable 414, 3021 [CLSCompliant(false)]
public class C { int i = 1; static void Main() { } } #pragma warning restore 3021
[CLSCompliant(false)] // CS3021 public class D { int i = 1; public static void F() { } }

Soma de verificação # pragma (referência C#)


Pode ser usado para gerar somas de verificação para arquivos de origem para ajudar com
depuração ASP.NET Páginas.
#pragma checksum "filename" "{guid}" "checksum bytes"
Parâmetros
"filename"
O nome do arquivo que requer o monitoramento de alterações ou atualizações.
"{guid}"
O Global Unique Identifier (GUID) para o arquivo.
"checksum_bytes"
A seqüência de dígitos hexadecimais representando os bytes da soma de verificação.
Deve ser um número par de dígitos hexadecimais. Um número de dígitos resulta em um
aviso em tempo de compilação, e a diretiva ímpar então será ignorado.
Comentários
O depurador Visual Studio usa uma soma de verificação para garantir que ele sempre encontrar a
origem direita. O compilador calcula a soma de verificação para um arquivo de origem, e então
emite a saída para arquivo de banco de dados (pdb) de programa. O depurador usa o PDB para
comparar contra a soma de verificação que ele calcula para o arquivo de origem.
Esta solução não funciona para ASP.NET projetos, pois a soma de comprovação calculada é para
o arquivo de origem gerado, em vez do arquivo.aspx. Para resolver esse problema, #pragma
checksum Fornece suporte checksum para ASP.NET Páginas.
Quando você cria um ASP.NET projeto no Visual C#, o arquivo de origem gerado contém uma
soma de verificação para o arquivo.aspx, do qual a fonte é gerada. O compilador grava essas
informações para o arquivo PDB.
Se o compilador encontrar nenhuma #pragma checksum Diretiva no arquivo, ele calcula a
soma de verificação e grava o valor para o arquivo PDB.
Exemplo
class TestClass { static int Main() { #pragma checksum "file.cs" "{3673e4ca-6098-4ec1-890f-
8fceb2a794a2}" "{012345678AB}" // New checksum } }

Visual C# Consolidado 261


OPÇÕES DO COMPILADOR C#
O compilador produz arquivos executável (.exe), bibliotecas de vínculo dinâmico (.dll), ou módulos
de código (.netmodule).
Cada opção de compilador está disponível de duas formas: -option e /option. A
documentação só mostra o /option formulário.

Criando de linha de comando


Você pode chamar o compilador C# simplesmente digitando o nome do seu arquivo executável
(csc.exe) na linha de comando. Se você usar o prompt de comando Studio visual (disponível como
um atalho no menu Iniciar no Visual Studio Tools), todas as variáveis de ambiente necessárias
serão definidas para você. Caso contrário, você talvez precise ajustar o caminho para poder
chamar csc.exe para ser chamado de qualquer subpasta em seu computador. Se você não usar o
prompt de comando Studio visual, é necessário para executar vsvars32.bat para definir as
variáveis de ambiente apropriada para oferecer suporte compilações linha de comando. Para
obter mais informações sobre vsvars32.bat, consulte Como construir a partir da linha de
comando:.
Se você estiver trabalhando em um computador que só tem o SDK do .NET Framework, você
pode usar o compilador C# na linha de comando se você usar que está disponível na Microsoft
.NET Framework SDK opção de menu. o SDK Command Prompt,
Para criar a partir do ambiente de desenvolvimento, consulte Preparar e gerenciando Builds.
The csc.exe executable is usually located in the Microsoft.NET\Framework\<version> folder under
the system directory. O local pode variar dependendo a configuração exata em qualquer
computador individual. Várias versões deste executável será estar presentes na máquina se mais
de uma versão do .NET Framework é instalado na máquina. Para obter mais informações sobre
essas instalações, consulte Instalando várias versões do .NET Framework.
Este tópico aborda o seguinte:
Regras de sintaxe de linha de comando
Linhas de comando de exemplo
Diferenças entre compilador C# e C++ Saída do compilador
Regras de sintaxe de linha de comando
O compilador C# usa as regras a seguir ao interpretar argumentos fornecidos na linha de
comando sistema operacional:
• Argumentos são delimitados por espaço em branco, que é um espaço ou uma guia.
• O caractere de interpolação (^) não é reconhecido como um caractere de escape ou
delimitador. O caractere é tratado completamente pelo analisador de linha de comando com o
sistema operacional antes está sendo transmitido para a matriz argv no programa.
• Uma seqüência rodeada por aspas duplas (" seqüência ") é interpretada como um
argumento único, independentemente de espaço em branco contida. Uma seqüência entre
aspas pode ser incorporada em um argumento.
• Precedido de aspas duplas por uma barra invertida (. \ " é interpretado como um caractere
literal aspas duplas ("))
• Backslashes são interpretados literalmente, a menos que esteja imediatamente antes de
aspas duplas.

Visual C# Consolidado 262


• Se um número par de barras invertidas for seguido de aspas duplas, uma barra invertida é
colocada na matriz argv para cada par de barras invertidas, e as aspas duplas é interpretada
como um delimitador de seqüência de caracteres.
• Se um número ímpar de barras invertidas for seguido de aspas duplas, uma barra invertida
é colocada na matriz argv para cada par de barras invertidas, e as aspas duplas é " escaped ",
a barra invertida restante, causando de aspas duplas (") para ser colocado em argv literal.
Linhas de comando de exemplo
• Compila File.cs produzir File.exe:
csc File.cs
• Compila File.cs produzir File.dll:
csc /target:library File.cs
• Compila File.cs e cria My.exe:
csc /out:My.exe File.cs
• Compila todos os arquivos na pasta atual, com otimizações C# no e define o símbolo
Debug. A saída é FILE2.exe:
csc /define:DEBUG /optimize /out:File2.exe *.cs
• Compila todos os arquivos na pasta atual produzir uma versão de depuração do
FILE2.DLL C#. Nenhum logotipo e sem avisos são exibidos:
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs
• Compila todos os arquivos na pasta atual para Something.xyz (uma DLL) C#:
csc /target:library /out:Something.xyz *.cs
Diferenças entre compilador C# e C++ Saída do compilador
Não há nenhum arquivo de objeto (.obj), criados como resultado de chamar o compilador C#;
arquivos de saída são criados diretamente. Como um consequence a isso, o compilador C# não
precisa um vinculador.

Como construir a partir da linha de comando:


O arquivo vsvars32.bat define as variáveis de ambiente apropriados para ativar builds.For linha de
comando mais informações sobre vsvars32.bat, consulte o seguinte artigo Base de
Conhecimento:
• Vcvars32.bat Generates fora da mensagem de ambiente Q248802:
Se a versão atual do Visual Studio estiver instalada em um computador que também possui uma
versão anterior do Visual Studio, você não deve executar vsvars32.bat ou vcvars32.bat de versões
diferentes na mesma janela de comando.
Para executar VSVARS32.BAT
1. No prompt de comando, mude para a subpasta Common7\Tools da instalação.
2. Executar VSVARS32.bat digitando VSVARS32.

Cuidado

VSVARS32.bat pode variar de máquina para máquina. Não substituir um arquivo VSVARS32.bat
ausente ou danificado com um VSVARS32.bat do outro computador. Execute novamente a
instalação para substituir o arquivo ausente.

Visual C# Consolidado 263


IMPLANTAÇÃO DE APLICATIVOS
C#
Após a conclusão criar seu aplicativo C#, a próxima etapa é para distribuí-lo. C# é uma linguagem
.NET; portanto, distribuir qualquer executáveis C# para outras máquinas requer o .NET
Framework para ser instalado em cada máquina de execução (e possivelmente outras
dependências específicas para seu aplicativo). Você tem uma variedade de opções disponíveis
para distribuir o .NET Framework. Para obter uma visão geral, consulte Redistribuindo o .NET
Framework.
Mover concluídos aplicativos para outros computadores é chamado geralmente de implantação.
Ambiente de desenvolvimento da Microsoft fornece mecanismos para implantação; para obter
mais informações, consulte Implantando aplicativos e componentes.
Se você criar e distribuir principalmente na linha de comando, você talvez precise considerar
outros métodos de implantação e redistribuindo dependências.

Opções do compilador C# listadas por categoria


As seguintes opções do compilador são classificadas por categoria. Para obter uma lista
alfabética, consulte Opções do compilador C# listadas Alphabetically.

Otimização
Opção Propósito
/filealign Especifica o tamanho das seções no arquivo de saída.
/ Otimizar Ativa / desativa otimizações.

Arquivos de saída
Opção Propósito
/Doc Especifica um arquivo XML onde os comentários documentação processados são a
serem gravados.
/ Fora Especifica o arquivo de saída.
/PDB Especifica o nome de arquivo e local do arquivo.pdb.
/platform Especificar a plataforma de saída.
/target Especifica o formato do arquivo de saída usando uma das quatro opções:
/Target:exe/Target:Library/Target:Module/Target:winexe

Conjuntos .NET Framework


Opção Propósito
/addmodule Especifica um ou mais módulos que faça parte deste conjunto de módulos
(assembly).
/delaysign Instrui o compilador para adicionar a chave pública mas para deixar o conjunto não
assinado.
/keycontainer Especifica o nome do recipiente de chave de criptografia.
/KeyFile Especifica o nome do arquivo que contém a chave criptográfica.
/lib Especifica o local de conjuntos referenciado por meio de /Reference.

Visual C# Consolidado 264


/nostdlib Instrui o compilador Não para importar a biblioteca padrão (mscorlib.dll).
/Reference Importa metadados de um arquivo que contém um conjunto.

Erros Debugging / verificação


Opção Propósito
/bugreport Cria um arquivo que contém informações que torna fácil a relatar um erro.
/ Especifica se fará com que uma exceção em tempo de execução inteiro aritmético
selecionada que estoura os limites do tipo de dados.
/Debug Instrua o compilador para emitir informações de depuração.
/errorreport Define relatório comportamento erros.
/fullpaths Especifica o caminho absoluto para o arquivo na saída do compilador.
/nowarn Suprime o compilador na geração de avisos especificados.
/ Avisar Define o nível de aviso.
/warnaserror Promove avisos a erros.

Preprocessor
Opção Propósito
/ Define Define símbolos de pré-processamento.

Recursos
Opção Propósito
/linkresource Cria um vínculo a um recurso gerenciado.
/Resource Incorpora um recurso do .NET Framework no arquivo de saída.
/win32icon Especifica um arquivo.ico para inserir no arquivo de saída.
/win32res Especifica um recurso do Win32 para inserir no arquivo de saída.

Diversos
Opção Propósito
@ Especifica um arquivo de resposta.
/? Lista opções do compilador para STDOUT.
/BaseAddress Especifica o endereço base preferido no qual se carregar um DLL.
/Codepage Especifica a página de códigos a ser usado para todos os arquivos de código de
fonte a compilação.
/help Lista opções do compilador para STDOUT.
/langversion Especifica qual versão do idioma a ser usado.
/ Principal Especifica o local do método Main.
/noconfig Instrui o compilador não para compilar com CSC.RSP.
/nologo Evita Suprime as informações de faixa do compilador.
/recurse Procura subdiretórios para arquivos de origem para compilar.

Visual C# Consolidado 265


/ unsafe Permite compilação do código que usa a Não seguro palavra-chave.
/utf8output Exibe compilador saída usando a codificação UTF-8.

Obsoleto opções

/incremental Permite compilação incremental.

Opções do compilador C# listadas Alfabeticamente


As seguintes opções do compilador são classificadas em ordem alfabética. Para obter uma lista
categorical, consulte Opções do compilador C# listadas por categoria.
Opção Propósito
@ Lê um arquivo de resposta para obter mais opções.
/? Exibe uma mensagem de uso para STDOUT.
/addmodule Vincula os módulos especificados para este conjunto de módulos (assembly)
/BaseAddress Especifica o endereço base para a biblioteca a ser criado.
/bugreport Cria um arquivo ' Relatório de erros '. Este arquivo será enviado junto com
qualquer informação de falha se usado com /errorreport:prompt ou
/errorreport:Send.
/ selecionada Faz o compilador para gerar verificações de estouro.
/Codepage Especifica a página de código a ser utilizado quando abrir arquivos de origem.
/Debug Emite as informações de depuração.
/ Define Define símbolos de compilação condicional.
/delaysign Signs atraso-o conjunto usando somente a parte pública da chave do nome de alta
segurança.
/Doc Especifica um arquivo de documentação XML para gerar.
/errorreport Especifica como lidar com erros de compilador interno: prompt, envio, ou nenhum.
O padrão é Nenhum.
/filealign Especifica o alinhamento usado para seções de arquivo de saída.
/fullpaths Faz o compilador para gerar caminhos totalmente qualificados.
/help Exibe uma mensagem de uso para STDOUT.
/incremental Permite compilação incremental [obsoleta].
/keycontainer Especifica um recipiente de chave de nome de alta segurança.
/KeyFile Especifica um arquivo de chave de nome de alta segurança.
/langversion Especifica modos de versão de idioma: ISO-1 ou padrão.
/lib Especificar diretórios adicionais para procurar por referências em.
/linkresource Vincula o recurso especificado a este conjunto.
/ Principal Especifica o tipo que contém o ponto de entrada (Ignorar todos os outros pontos
de entrada possíveis).
/noconfig Instrui o compilador não para automaticamente incluir arquivo CSC.RSP.
/nologo Evita Suprime mensagem de direitos autorais do compilador.

Visual C# Consolidado 266


/nostdlib Instrui o compilador não à referência biblioteca padrão (mscorlib.dll).
/nowarn Desativa específico mensagens de aviso
/ Otimizar Ativa / desativa otimizações.
/ Fora Especifica o nome do arquivo de saída (padrão:). base Nome do arquivo com
classe principal ou primeiro arquivo
/PDB Especifica o nome de arquivo e local do arquivo.pdb.
/platform Limites que plataformas esse código pode executado em: x 86, Itanium, x 64, ou
anycpu. O padrão é anycpu.
/recurse Inclui todos os arquivos no diretório atual e subdiretórios de acordo com as
especificações curinga.
/Reference Metadados referências a partir dos arquivos conjunto especificado.
/Resource Incorpora o recurso especificado.
/target Especifica o formato do arquivo de saída usando uma das quatro opções:
/Target:exe/Target:Library/Target:Module/Target:winexe
/ unsafe Permite que Não seguro o código.
/utf8output Saídas Mensagens do compilador em codificação UTF-8.
/ Avisar Define o nível de aviso (0-4).
/warnaserror Relatórios específicos avisos como erros.
/win32icon Usa este ícone para a saída.
/win32res Especifica o arquivo de recurso do Win32 (. res).

Como localizar ajuda para erros do compilador:


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 (Importar e Exportar Configurações) no menu Tools
(Ferramentas). Para obter mais informações, consulte Configurações do Visual Studio.

Todos os Erros de compilador C# ter correspondentes tópicos que explique por que um erro é
gerado, e em alguns casos, como corrigir o erro. Para obter ajuda sobre uma mensagem de erro
específica, tente um destes procedimentos:
Procedimento

Para encontrar Ajuda para um erro


• Clique no número de erro no e pressione F1. o Janela Output,
Ou-
Digite o número do erro na caixa Look for no índice.
Ou-
Digite o número de erro na página Search.

Visual C# Consolidado 267


EXEMPLOS DO VISUAL C#
Você pode acessar código de exemplo, procurando resumos de Exemplo nesta seção. Cada
abstrato contém um link para abrir ou copiar o Exemplo na arquivos. Além disso, o SDK do .NET
Framework inclui tecnologia e aplicativo Exemplos e tutoriais QuickStart que demonstram recursos
.NET Framework e código Visual C#.
Os tutoriais QuickStart são a maneira mais rápida para entender o que a tecnologia .NET
Framework oferece desenvolvedores líder-borda. Os QuickStarts são uma série de exemplos e
suporte documentação projetadas para rapidamente acquaint você com a sintaxe, arquitetura, e
poder do Visual Studio e o .NET Framework. Do ASP.NET Os tutoriais QuickStart inclui exemplos
na e aplicativos Windows Forms, além de muitos aplicativos instrução que abrangem os recursos
da tecnologia .NET Framework mais atraentes.
Para acessar o QuickStarts, clique em Start, aponte para Programs, aponte para Microsoft
.NET Framework SDK v2.0, e clique em QuickStart Tutorials. Uma página da Web do
aplicativo " tutoriais QuickStart SDK Microsoft .NET Framework " é exibida. Para executar o
QuickStarts, siga as instruções na página, que configura o banco de dados amostras e conclui a
instalação. Para obter mais informações, consulte Amostras e QuickStarts.
Exemplos de introdução

Anônimo Exemplo Demonstra o uso de representantes para reduzir a complexidade de


representantes aplicativos sem nome.
Exemplo matrizes Mostra como usar matrizes.
Coleção Exemplo Mostra como fazer classes coleção Generic não-que podem ser usados
classes com a foreach instrução.
Exemplo generics (C#) Mostra como fazer classes a coleção genérica que podem ser usados
com a foreach instrução.
Exemplo de parâmetros Demonstra simples processamento de linha de comando e matriz
da linha de comando indexação.
Exemplo dos Métodos Demonstra condicionais métodos, que fornecem um poderoso
condicional mecanismo pelo qual chamadas para métodos podem ser incluídos ou
omitido dependendo se um símbolo é definido.
Exemplo representantes Mostra como representantes são declaradas, mapeado, e combinados.
Exemplo eventos Mostra como usar eventos em C#.
Exemplo de Demonstra como explicitamente implementar membros de interface.
implementação de
interface explícita
Exemplo World de Um aplicativo hello world.
saudação
Exemplo indexadores Mostra como usar notação de matriz para acessar um objeto.
Indexado Exemplo Mostra como a implementar uma classe que usa propriedades
propriedades indexadas. Propriedades indexadas permitem que você para usar uma
classe que representa uma coleção de vários tipos diferentes de itens
semelhantes matriz-.
Exemplo propriedades Mostra como propriedades são declaradas e usados; também
demonstra propriedades abstratas.

Visual C# Consolidado 268


Exemplo Structs Mostra como usar structs em C#.
Exemplo Overloading Mostra como definido pelo usuário classes poderá sobrecarregar
do operador operadores.
Exemplo Conversions Mostra como definir conversões de e para tipos definidos pelo usuário.
definidas pelo usuário
Exemplo de versão Do override demonstra versão em C# através do uso de e new
palavras-chave.
Produzir exemplo Demonstra a palavra-chave rendimento para filtrar itens em uma
coleção.

Exemplos intermediário e Avançado

Exemplo atributos Mostra como criar classes de atributo personalizado, usá-los em código, e
consultá-los através de reflexão.
Exemplo parte 1 Mostra como usar C# para interoperar com objetos COM.
Interop COM
Exemplo parte 2 Mostra como um servidor use um C# com um cliente com C++.
Interop COM
Exemplo bibliotecas Mostra como usar opções do compilador para criar uma DLL de vários
arquivos de origem; além disso, como usar a biblioteca em outros
programas.
Exemplo anulável Demonstra tipos de valores que podem ser definidos como nulo.
Exemplo BD OLE Demonstra como usar um banco de dados do Microsoft Access do C#. Ele
mostra como você pode criar um DataSet e adicionar tabelas a ela a partir
de um banco de dados.
Exemplo tipos parcial Demonstra como classes e estruturas podem ser definidas em vários
arquivos código fonte-C#.
Plataforma Invoke Mostra como chamar exportadas funções DLL do C#.
exemplo
Exemplo de Discute a segurança do .NET Framework e mostra duas maneiras de
segurança modificar as permissões de segurança em C#: Usando classes de
permissão e atributos de permissão.
Segmentação de Demonstra várias atividades do segmento, como criando e executando um
exemplo segmento, sincronizando segmentos, interagir entre segmentos, e usando
um pool de segmentos.
Exemplo de código Mostra como usar ponteiros.
não seguros
Exemplo de Mostra como a documentar código usando XML.
documentação XML

Exemplo World de saudação


Download sample
Este Exemplo mostra várias versões de um programa hello world em C#.

Observação de segurança

Visual C# Consolidado 269


Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir os arquivos de Exemplo no Solution Explorer


1. Clique em Download Sample.
A caixa de mensagem Download de arquivo será exibida.
2. Clique em Open e, na coluna esquerda da pasta CEP, clique em Extract all files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta os arquivos serão extraídos para, ou clique em
Next novamente.
4. Certifique-se de que a Show extracted files caixa de seleção esteja marcada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz a solução do projeto não é confiável. Clique OK para continuar.
Para criar e executar os exemplos hello world no Visual Studio
1. Abra a solução (HelloWorld.sln).
2. No Solution Explorer, clique com o projeto HelloWorld1, e clique em Set as
StartUp Project.
3. No menu Debug, clique em Start Without Debugging.
4. Pressione qualquer tecla para fechar HelloWorld1.
5. No Solution Explorer, clique com o projeto HelloWorld2, e clique em Set as
StartUp Project.
6. No menu Debug, clique em Start Without Debugging.
7. Pressione qualquer tecla para fechar HelloWorld2.
8. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Set as
StartUp Project.
9. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Properties.
10. Abra a Configuration Properties pasta, e clique em Debug.
11. Na Command Line Arguments propriedade, tipo A B C D e clique em OK.
12. No menu Debug, clique em Start Without Debugging.
13. Pressione qualquer tecla para fechar HelloWorld3.
14. No Solution Explorer, clique com o projeto HelloWorld4, e clique em Set as
StartUp Project.
15. No menu Debug, clique em Start Without Debugging.
16. Pressione qualquer tecla para fechar HelloWorld4.
Para criar e executar os exemplos hello world a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório HelloWorld.
2. Digite o seguinte:

Visual C# Consolidado 270


cd HelloWorld1 csc Hello1.cs Hello1
3. Digite o seguinte:
cd ..\HelloWorld2 csc Hello2.cs Hello2
4. Digite o seguinte:
cd ..\HelloWorld3 csc Hello3.cs Hello3 A B C D
5. Digite o seguinte:
cd ..\HelloWorld4 csc Hello4.cs Hello4
Consulte também

Exemplo de parâmetros da linha de comando


Download sample
Este Exemplo mostra como a linha de comando pode ser acessada e duas maneiras de acessar a
matriz de parâmetros de linha de comando.

Observação de segurança
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos parâmetros de linha de comando no Visual Studio
1. No Solution Explorer, clique com o projeto CmdLine1, e clique em Set as StartUp
Project.
2. No Solution Explorer, clique com o projeto, e clique em Properties.
3. Abra a Configuration Properties pasta, e clique em Debug.
4. Na propriedade Command Line Arguments, digite os parâmetros da linha de
comando, e clique em OK. (Consulte o tutorial para obter um exemplo.)
5. No menu Debug, clique em Start Without Debugging.
6. Repita as etapas anteriores para CmdLine2.
Para criar e executar os exemplos parâmetros de linha de comando a partir da linha de comando

Visual C# Consolidado 271


1. Use o Change Directory comando para alterar para o diretório CmdLine1.
2. Digite o seguinte:
csc cmdline1.cs cmdline1 A B C
3. Use o Change Directory comando para alterar para o diretório CmdLine2.
4. Digite o seguinte:
csc cmdline2.cs cmdline2 John Paul Mary

Exemplo matrizes
Download sample
Este Exemplo descreve e mostra como matrizes funcionam em C#. Para obter mais informações,
consulte Matrizes (Guia de programação do C#).

Observação de segurança
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo matrizes no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo matrizes a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc arrays.cs arrays

Exemplo propriedades
Download sample
Este Exemplo mostra como propriedades são uma parte integral da C# linguagem de
programação. Ele demonstra como propriedades são declaradas e usados. Consulte
Propriedades Para obter mais informações.

Observação de segurança

Visual C# Consolidado 272


Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos propriedades no Visual Studio
1. No Solution Explorer, clique com o projeto pessoa e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para shapetest.
Para criar e executar os exemplos Propriedades a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório pessoa.
2. Digite o seguinte:
csc person.cs person
3. Use o Change Directory comando para alterar para o diretório shapetest.
4. Digite o seguinte:
csc abstractshape.cs shapes.cs shapetest.cs shapetest

Exemplo bibliotecas
Download sample
Este Exemplo mostra como criar e usar uma DLL em C#.

Observação de segurança
Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.

Visual C# Consolidado 273


2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo bibliotecas no Visual Studio
1. No Solution Explorer, clique com o projeto FunctionTest, e clique em Set as
StartUp Project.
2. No Solution Explorer, clique com o projeto FunctionTest, e clique em Properties.
3. Abra a Configuration Properties pasta e clique em Debug.
4. Na propriedade Command Line Arguments, insira 3 5 10.
5. Clique em OK.
6. No menu Debug, clique em Start Without Debugging. Isso automaticamente criar a
biblioteca em funções e executar o programa.
Para criar e executar o Exemplo bibliotecas a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório funções.
2. Digite o seguinte:
csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
3. Use o Change Directory comando para alterar para o diretório FunctionTest.
4. Digite o seguinte:
copy ..\Functions\Functions.dll . csc /out:FunctionTest.exe /R:Functions.DLL
FunctionClient.cs FunctionTest 3 5 10

Exemplo de versão
Download sample
Este Exemplo demonstra versão em C# através do uso de e new palavras-chave. o override
Versão ajuda manter a compatibilidade entre classes base e derivados como eles evoluir. Para
obter informações adicionais, consulte Versão com o substituição e palavras-chave new (guia de
programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer

Visual C# Consolidado 274


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo versão no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo versão a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc versioning.cs versioning

Coleção Exemplo classes


Download sample
Este Exemplo mostra como a implementar uma classe coleção que pode ser usado com a
foreach instrução. Para obter mais informações, consulte Classes coleção (guia de
programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.

Visual C# Consolidado 275


A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos classes coleção no Visual Studio
1. No Solution Explorer, clique com o projeto CollectionClasses1 e clique em Set as
StartUp Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para CollectionClasses2.
Para criar e executar os exemplos classes coleção a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório CollectionClasses1.
2. Digite o seguinte:
csc tokens.cs tokens
3. Use o Change Directory comando para alterar para o diretório CollectionClasses2.
4. Digite o seguinte:
csc tokens2.cs tokens2

Exemplo Structs
Download sample
Este Exemplo apresenta a sintaxe e uso de estruturas. Ele também aborda as diferenças
importantes entre classes e estruturas. Consulte Objetos, classes e Structs (guia de programação
C#) Para obter mais informações.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Structs no Visual Studio

Visual C# Consolidado 276


1. No Solution Explorer, clique com o projeto Struct1 e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Struct2.
Para criar e executar os exemplos Structs a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Struct1.
2. Digite o seguinte:
csc struct1.cs struct1
3. Use o Change Directory comando para alterar para o diretório Struct2.
4. Digite o seguinte:
csc struct2.cs struct2

Exemplo indexadores
Download sample
Este Exemplo mostra como classes C# podem declarar indexadores para fornecer acesso
semelhante matriz-às classes.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo Indexers no Visual Studio
1. No Solution Explorer, clique com o projeto indexadores, e clique em Properties.
2. Abra a Configuration Properties pasta, e clique em Debug.
3. Na propriedade Command Line Arguments, insira ..\..\Test.txt.
4. Clique em OK.

Visual C# Consolidado 277


5. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo Indexers a partir da linha de comando
1. Para compilar o programa de exemplo, digite o seguinte no prompt de comando:
csc indexer.cs
O programa de Exemplo inverte os bytes em um arquivo fornecido como um argumento da linha
de comando. Por exemplo, para reverter os bytes em Test.txt e ver o resultado, emitir os seguintes
comandos:
indexers Test.txt type Test.txt
2. Para alterar o arquivo revertido para Normal, execute o programa no mesmo arquivo
novamente.

Indexado Exemplo propriedades


Download sample
Este Exemplo mostra como classes C# podem declarar indexadas propriedades para representa
uma coleção de tipos diferentes de itens semelhantes matriz-. Para obter mais informações,
consulte Propriedades (Guia de programação do C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo indexado propriedades no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo indexado Propriedades a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc indexedproperty.cs indexedproperty

Visual C# Consolidado 278


Exemplo Conversions definidas pelo usuário
Download sample
Este Exemplo mostra como definir conversões de ou para classes ou estruturas, e como essas
conversões são usados. Consulte Operadores de conversão (guia de programação C#) Para obter
mais informações.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Conversions pelo usuário no Visual Studio
1. No Solution Explorer, clique com o projeto Conversion1 e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Conversion2.
Para criar e executar os exemplos Conversions pelo usuário a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Conversion1.
2. Digite o seguinte:
csc conversion.cs conversion
3. Use o Change Directory comando para alterar para o diretório Conversion2.
4. Digite o seguinte:
csc structconversion.cs structconversion

Exemplo generics (C#)


Download sample
Este Exemplo mostra como criar uma classe personalizada lista genérico com um parâmetro único
tipo, e como implementá IEnumerable<T> Para ativar foreach iteração através do conteúdo

Visual C# Consolidado 279


da lista. O Exemplo também mostra como código de cliente cria uma instância da classe,
especificando um argumento Tipo, e como restrições sobre o parâmetro type ativar operações
adicionais a serem executadas sobre os argumentos Tipo.
Para obter um Exemplo de uma classe a coleção genérica que implementa um bloco do iterador,
consulte COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo Generics no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo Generics a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc generics.cs generics
Comentários
Este Exemplo é fornecido para fins de demonstração e não se destina a ser usado sem
modificações no código de produção. Para código de qualidade de produção, ele é recomendável
que você usar as classes coleção no espaço para nome System.Collections.Generic sempre que
possível.

Exemplo Overloading do operador


Download sample
Este Exemplo demonstra classes definidas pelo usuário como poderá sobrecarregar operadores.
Consulte Operadores C# Para obter mais informações.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos

Visual C# Consolidado 280


ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Overloading operador no Visual Studio
1. No Solution Explorer, clique com o projeto complexo e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Dbbool.
Para criar e executar os exemplos operador Overloading a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório complexo.
2. Digite o seguinte:
csc complex.cs complex
3. Use o Change Directory comando para alterar para o diretório Dbbool.
4. Digite o seguinte:
csc dbbool.cs dbbool

Exemplo representantes
Download sample
Este Exemplo demonstra os tipos de representante. Ele mostra como para mapear delegados
para estáticos e métodos da instância, e como combiná-las para criar representantes de difusão
seletiva.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


Visual C# Consolidado 281
1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos representantes no Visual Studio
1. No Solution Explorer, clique com o projeto Delegates1, e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Delegates2.
Para criar e executar os exemplos representantes a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Delegates1.
2. Digite o seguinte:
csc bookstore.cs bookstore
3. Use o Change Directory comando para alterar para o diretório Delegates2.
4. Digite o seguinte:
csc compose.cs compose

Exemplo eventos
Download sample
Este Exemplo mostra como a declarar, chamar, e configurar eventos em C#. Para obter mais
informações, consulte Eventos (Guia de programação do C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.

Visual C# Consolidado 282


O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos eventos no Visual Studio
1. No Solution Explorer, clique com o projeto Events1, e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Events2.
Para criar e executar os exemplos eventos a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Events1.
2. Digite o seguinte:
csc events1.cs events1
3. Use o Change Directory comando para alterar para o diretório Events2.
4. Digite o seguinte:
csc events2.cs events2

Exemplo de implementação de interface explícita


Download sample
Este Exemplo demonstra como explicitamente implementar membros de interface e como acessar
esses participantes a partir de ocorrências interface. Para informações de plano de fundo,
consulte Interfaces (guia de programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.

Visual C# Consolidado 283


Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Explicit implementação interface no Visual Studio
1. No Solution Explorer, clique com o projeto ExplicitInterface1 e clique em Set as
StartUp Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para ExplicitInterface2.
Para criar e executar os exemplos Explicit implementação interface a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório ExplicitInterface1.
2. Digite o seguinte:
csc explicit1.cs explicit1
3. Use o Change Directory comando para alterar para o diretório ExplicitInterface2.
4. Digite o seguinte:
csc explicit2.cs explicit2

Exemplo dos Métodos condicional


Download sample
Este Exemplo demonstra condicionais métodos, que fornecem um poderoso mecanismo pelo qual
chamadas para métodos podem ser incluídos ou omitido dependendo se um símbolo é definido.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.

Visual C# Consolidado 284


Para criar e executar o Exemplo métodos condicional no Visual Studio
1. No Solution Explorer, clique com o projeto e clique em Properties.
2. Abra a pasta Propriedades de configuração, e clique em Debug.
3. Defina a Command Line Arguments propriedade para A B C.
4. Na pasta Propriedades de configuração, clique em Build.
5. Modificar a Conditional Compilation Constants propriedade. Por exemplo,
adicionar ou excluir Debug. Clique em OK.
6. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo métodos condicional a partir da linha de comando
• Para incluir o método condicional, compilar e execute o programa de exemplo, digitando o
seguinte no prompt de comando:
csc CondMethod.cs tracetest.cs /d:DEBUG tracetest A B C

Exemplo de documentação XML


Download sample
Este Exemplo mostra como usar XML ao documento código. Consulte Comentários de
documentação XML (Guia de programação C#) Para obter informações adicionais.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar o Exemplo documentação XML no Visual Studio
1. No Solution Explorer, clique com o projeto e clique em Properties.
2. Abra a pasta Propriedades de configuração e clique em Build.
3. Defina a propriedade arquivo documentação XML como XMLsample.xml.

Visual C# Consolidado 285


4. No menu Build, clique em Build. O arquivo de saída XML poderá ser no diretório de
depuração.
Para criar o Exemplo documentação XML a partir da linha de comando
1. Para gerar a documentação XML de exemplo, digite o seguinte no prompt de comando:
csc XMLsample.cs /doc:XMLsample.xml
2. Para ver o XML gerado, emita o seguinte comando:
type XMLsample.xml

Plataforma Invoke Exemplo


Download sample
Este Exemplo demonstra como chamar plataforma chama (funções exportadas DLL) do C#.
Consulte Interoperabilidade (guia de programação C#) Para obter mais informações.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Platform Invoke no Visual Studio
1. No Solution Explorer, clique com o projeto PinvokeTest e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para Marshal e PInvoke.
Para criar e executar os exemplos Platform Invoke a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório PinvokeTest.
2. Digite o seguinte:
csc PinvokeTest.cs PinvokeTest
3. Use o Change Directory comando para alterar para o diretório Marshal.

Visual C# Consolidado 286


4. Digite o seguinte:
csc Marshal.cs Marshal
5. Use o Change Directory comando para alterar para o diretório PInvoke.
6. Digite o seguinte:
csc logfont.cs pinvoke.cs pinvoke

Exemplo parte 1 Interop COM


Download sample
Este Exemplo demonstra como um programa C# pode interoperar com um componente COM não
gerenciado.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos com Interop parte 1 no Visual Studio
1. No Solution Explorer, clique com o projeto Interop1, e clique em Set as StartUp
Project.
2. No Solution Explorer, clique com o projeto Interop1, e clique em Properties.
3. Abra a Configuration Properties pasta, e clique em Debug.
4. Na propriedade argumentos de linha de comando, digite um arquivo AVI como
c:\winnt\clock.avi.
5. Clique em OK.
6. No menu Debug, clique em Start Without Debugging.
7. Repita as etapas anteriores para Interop2.
Se o QuartzTypeLib.dll incluído com Interop1 está desatualizado
1. No Solution Explorer, abrir References para Interop1.

Visual C# Consolidado 287


2. Clique com o botão direito do mouse QuartzTypeLib e, clique em Remove.
3. Clique com o botão direito do mouse References e, clique em Add Reference.
4. Na guia COM, selecione o componente denominado, " biblioteca Tipo de Controle
ActiveMovie ".
5. Clique em Select e, clique em OK.
6. Recrie Interop1.

Observação

Adicionando uma referência para o componente faz a mesma coisa que chamar TLBIMP na linha
de comando para criar QuartzTypeLib.dll (como mostrado abaixo).

Para criar e executar os exemplos com Interop Parte 1 a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Interop1.
2. Digite o seguinte:
tlbimp %windir%\system32\quartz.dll /out:QuartzTypeLib.dll csc /r:QuartzTypeLib.dll
interop1.cs interop1 %windir%\clock.avi
3. Use o Change Directory comando para alterar para o diretório Interop2.
4. Digite o seguinte:
csc interop2.cs interop2 %windir%\clock.avi

Exemplo parte 2 Interop COM


Download sample
Este Exemplo demonstra usando um servidor C# com um cliente com C++.

Observação

É preciso instalar para compilar Este Exemplo Visual C++.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.

Visual C# Consolidado 288


Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo 2 Part Interop COM no Visual Studio
1. No Solution Explorer, clique com o projeto COMClient, e clique em Properties.
2. Abra a Configuration Properties pasta, e clique em Debug.
3. Na propriedade Command Line Arguments, digite um nome.
4. Clique em OK.
5. No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo 2 Part Interop COM a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório
COMInteropPart2\COMClient.
2. Copie o código do servidor C# para o diretório COMClient:
copy ..\CSharpServer\CSharpServer.cs
3. Compilar o servidor:
csc /target:library CSharpServer.cs regasm CSharpServer.dll /tlb:CSharpServer.tlb
4. Compilar o cliente (verifique se as variáveis Caminho e ambiente são definidas
corretamente com vcvars32.bat)::
cl COMClient.cpp
5. Execute o cliente:
COMClient friend

Exemplo atributos
Download sample
Este Exemplo demonstra como criar classes de atributo personalizado, usá-los em código, e
consultá-los através de reflexão. Para obter mais informações sobre atributos, consulte Atributos
(guia de programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.

Visual C# Consolidado 289


3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo atributos no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo atributos a partir da linha de comando
• Digite o seguinte no prompt de comando:
csc AttributesTutorial.cs AttributesTutorial

Exemplo de segurança
Download sample
Este Exemplo demonstra como modificar as permissões de segurança através de classes de
permissão e atributos de permissão. Para obter informações adicionais, consulte Segurança (guia
de programação C#).

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos de segurança no Visual Studio
1. No Solution Explorer, clique com o projeto Security1 e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.

Visual C# Consolidado 290


3. Repita as etapas anteriores para Security2 e Security3.
Para criar e executar os exemplos de segurança a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório Security1.
2. Digite o seguinte:
csc ImperativeSecurity.cs ImperativeSecurity
3. Use o Change Directory comando para alterar para o diretório Security2.
4. Digite o seguinte:
csc DeclarativeSecurity.cs DeclarativeSecurity
5. Use o Change Directory comando para alterar para o diretório Security3.
6. Digite o seguinte:
csc SuppressSecurity.cs SuppressSecurity

Segmentação de Exemplo
Download sample
Este Exemplo demonstra as seguintes técnicas segmentação. Consulte Segmentação (guia de
programação C#) Para obter mais informações.
• Criar, iniciar, e Finalizando um segmento
• Usando um pool de segmentos
• Segmento Sincronização e interação

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos Threading no Visual Studio

Visual C# Consolidado 291


1. No Solution Explorer, clique com o projeto ThreadStartStop e clique em Set as
StartUp Project.
2. No menu Debug, clique em Start Without Debugging.
3. Repita as etapas anteriores para ThreadPool, e ThreadSync.
Para criar e executar os exemplos Threading a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório segmentos.
2. Digite o seguinte:
cd ThreadStartStop csc ThreadStartStop.cs ThreadStartStop
3. Digite o seguinte:
cd ..\ThreadPool csc ThreadPool.cs ThreadPool
4. Digite o seguinte:
cd ..\ThreadSync csc ThreadSync.cs ThreadSync

Exemplo de código não seguros


Download sample
Este Exemplo demonstra como usar código não gerenciado (código usando ponteiros) no C#.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar os exemplos UNSAFE código no Visual Studio
1. No Solution Explorer, clique com o projeto FastCopy, e clique em Set as StartUp
Project.
2. No menu Debug, clique em Start Without Debugging.

Visual C# Consolidado 292


3. No Solution Explorer, clique com o projeto ReadFile, e clique em Set as StartUp
Project.
4. No Solution Explorer, clique com o projeto ReadFile, e clique em Properties.
5. Abra a pasta Propriedades de configuração, e clique em Debug.
6. Na propriedade argumentos da linha de comando, insira ..\..\ReadFile.cs.
7. Clique em OK.
8. No menu Debug, clique em Start Without Debugging.
9. No Solution Explorer, clique com o projeto PrintVersion, e clique em Set as
StartUp Project.
10. No menu Debug, clique em Start Without Debugging.
Para criar e executar os exemplos de código UNSAFE a partir da linha de comando
1. Use o Change Directory comando para alterar para o diretório UNSAFE.
2. Digite o seguinte:
cd FastCopy csc FastCopy.cs /unsafe FastCopy
3. Digite o seguinte:
cd ..\ReadFile csc ReadFile.cs /unsafe ReadFile ReadFile.cs
4. Digite o seguinte:
cd ..\PrintVersion csc PrintVersion.cs /unsafe PrintVersion

Exemplo BD OLE
Download sample
Este Exemplo demonstra como usar um banco de dados do Microsoft Access do C#. Ele mostra
como você pode criar um DataSet e adicionar tabelas a ela a partir de um banco de dados. O
banco de dados BugTypes.MDB usado no programa de Exemplo é um arquivo.mdb do Microsoft
Access 2000.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.

Visual C# Consolidado 293


Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo de banco de dados OLE no Visual Studio
• No menu Debug, clique em Start Without Debugging.

Observação

Se você estiver criando a solução no modo Release, copie BugTypes.mdb para a pasta
\bin\release.

Para criar e executar o Exemplo OLE DB a partir da linha de comando


• Digite o seguinte no prompt de comando:
csc oledbsample.cs oledbsample

Produzir Exemplo
Download sample
Este Exemplo mostra como criar uma classe lista que implementa IEnumerable<int> e
palavra-chave yield Para ativar foreach iteração através do conteúdo da lista. Duas
propriedades são definidas, um retornar os números ímpares, o outro retornar os números pares.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo YIELD código no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo YIELD código a partir da linha de comando

Visual C# Consolidado 294


1. Use o Change Directory (cd) comando para alterar para o Yield Diretório.
2. Digite o seguinte:
csc Yield.cs Yield

Anônimo Exemplo representantes


Download sample
Este Exemplo demonstra usar um representante anônimo para calcular um bônus do salário de
um funcionário. Usar um representante anônimo simplifica o programa porque não é necessário
para definir um método separado.
Os dados para cada funcionário são armazenados em um objeto que contém detalhes pessoais,
bem como um representante que referencia o algoritmo necessário para calcular o bônus.
Definindo o algoritmo por meio de um representante, o mesmo método pode ser usado para
executar o cálculo do bônus, independentemente de como ele é realmente calculado. De
anotação, uma variável local, multiplicador, também se torna uma variável externo capturado
porque ele é mencionado em um cálculo delegado.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
Certifique-se de que a Show extracted files caixa de seleção está selecionada e clique
em Finish.
Clique duas vezes o Exemplo na Arquivo.sln.
A solução de Exemplo é exibida no Solution Explorer. Você pode receber um aviso de
segurança que diz o local de solução não é confiável. Clique OK para continuar.
Para criar e executar o Exemplo de código AnonymousDelegates no Visual Studio
• No menu Debug, clique em Start Without Debugging.
Para criar e executar o Exemplo de código AnonymousDelegates a partir da linha de comando
1. Use o Change Directory (cd) comando para alterar para o diretório
AnonymousDelegates.
2. Digite o seguinte:
csc AnonymousDelegates.cs AnonymousDelegates

Visual C# Consolidado 295


Exemplo tipos parcial
Download sample
Este Exemplo demonstra o uso de tipos parciais que permitem class ou struct para ser definidos
em dois ou mais arquivos C#. Isso permite que vários programadores para trabalhar em partes
diferentes de uma classe em paralela, e para aspectos diferentes de uma classe complexo a
serem mantidos em arquivos separados.

Observação de segurança

Este código de Exemplo é fornecido para ilustrar um conceito e não deve ser usado em aplicativos
ou sites da Web, como não-pode ilustrar as práticas de codificação mais segura. Microsoft supõe
que nenhum RESPONSABILIDADE POR DANOS INCIDENTAIS OU CONSEQÜENCIAIS o
código do Exemplo deve ser usado para fins diferente da maneira desejada

Para abrir o arquivo de Exemplo no Solution Explorer


1. Clique em Download Sample.
A File Download caixa de mensagem será exibida.
2. Clique em Open e, na coluna esquerda da janela pasta CEP, clique em Extract all
files.
O Extraction Wizard abre.
3. Clique em Next. Você pode mudar a pasta que os arquivos serão extraídos para, e clique
em Next novamente.
C