Apostila Visual C# (Consolidada) - PT-BR

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
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
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
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
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 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 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
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
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
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
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
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
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
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 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
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
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 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
Vinculação de Dados para controles em um painel Ações do Excel Walkthrough:............................................1112
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 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
Para testar a implantação ...................................................................................................................................1120
Implantando um Word ou Solution do Excel usando um arquivo do Windows Installer Walkthrough: .............1121
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 remover um grupo de códigos ....................................................................................................................1127
Para criar um nome forte ....................................................................................................................................1128
Para conceder confiança com base em nome forte .............................................................................................1128
O Word Usando Explicações Passo-a-passo.......................................................................................................1129
Walkthrough: Changing Document formatação usando controles CheckBox ....................................................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
Exibindo texto em uma caixa de texto em um documento usando um botão Walkthrough: ................................1132
Para adicionar um botão e uma caixa de texto ...................................................................................................1133
Para escrever para a caixa de texto quando o botão é clicado...........................................................................1133
Walkthrough: Criando menus de atalho para indicadores .................................................................................1134
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
Walkthrough: atualizando um gráfico em um documento usando botões de opção............................................1137
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
Vinculação de Dados para controles em um painel Ações do Word Walkthrough:............................................1142
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
Walkthrough: criar uma marca inteligente que converte Temperatures de Fahrenheit para Celsius ................1148
Para configurar seu projeto ................................................................................................................................1148
Para criar a marca inteligente ............................................................................................................................1149
Para criar o manipulador de eventos..................................................................................................................1149
Implantando um Word ou Solution do Excel usando um manifesto Deployment Walkthrough: .........................1150
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 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 remover um grupo de códigos ....................................................................................................................1161
Para criar um nome forte ....................................................................................................................................1162
Para conceder confiança com base em nome forte .............................................................................................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
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#
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#.
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.
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.
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.
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
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.
• 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
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.
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)
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.
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#.

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#.
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
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.
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:
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#).
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.
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.
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.
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.
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
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.
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.
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:
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 .
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.
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.
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.
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.
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
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.
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:
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.
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.
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.
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.
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:
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
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.
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
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.
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
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
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.
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
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
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.
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.
• 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.
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#.
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.
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.
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.
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
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.
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.
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.

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
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.
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
Pré-requisitos
• 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.
• 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:

Name applyItalicFont
Text Itálico
6. Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes

propriedades:

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

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#
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.
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.
• Adicionar controles a uma planilha.
• Preencher uma caixa de texto quando um botão é clicado.
Observação
Pré-requisitos
• Excel.
Criando o projeto
Excel.
• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Button. Verifique
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:

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
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.
2. Clique no botão.
3. Confirme que Hello World! aparece na caixa de texto.
Próximas etapas
em planilhas do Excel. Aqui estão algumas tarefas que podem vie em seguida:
• 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.
• Adicionar um NamedRange controle para uma planilha.
• Programa contra NamedRange Eventos de controle.
Observação
Pré-requisitos
Criando o projeto
Nesta etapa, você irá criar pasta de trabalho Excel usando Visual Studio Tools for Office Um do
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
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.
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.
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
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 é
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
2. Coloque o cursor no namedRange1, e verificar que o texto sobre o SelectionChange
evento é inserido e que um comentário é inserido na planilha.
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:
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
• Remova a configuração de segurança padrão.
• Adicionar um novo conjunto de permissões.
Pré-requisitos
Criando o projeto
Nesta etapa, você irá criar um projeto de pasta de trabalho do Excel.
• Criar um projeto de pasta de trabalho do Excel com o nome My Security Test.
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
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.
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.
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.
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.
• Criar uma fonte de dados para um projeto do Excel.
• Rolar pelos registros do banco de dados.
Observação
Pré-requisitos
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.
• 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.
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.
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
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)
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
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#
this.customersBindingSource.MovePrevious(); }
Para mover para o próximo registro
o código a seguir para avançar a posição em um:
C#
this.customersBindingSource.MoveNext(); }
Para mover para o último registro
o código a seguir para mover para o último registro:
C#
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.
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.
• Salva qualquer alteração de dados de volta para o banco de dados.
Observação
Pré-requisitos
• 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
menu.
Observação
Wizard.
7. Marque a caixa de seleção ao lado da Employees tabela.
O assistente adicionará a Employees tabela para a Data Sources janela. Ele também
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
1. Verifique se a My Complex Data Binding.xls pasta de trabalho é aberta no designer
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
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
C#
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); } }
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.
As linhas são classificadas em ordem alfabética por sobrenome.
Para filtrar informações
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:
• 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.
• Configurar um DataSet para ser armazenados em uma planilha.
• Adicione código para Habilitar rolagem pelos registros.
Observação
Pré-requisitos
Acesso ao Exemplo de SQL Server do Northwind. O banco de dados pode ser no seu computador
de desenvolvimento ou em um servidor.
• 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
menu.
Wizard.
adicionar uma nova conexão usando o New Connection botão.
4. Após selecionar ou criar uma conexão, clique em Next.
7. Selecione a Orders tabela e a Order Details tabela.
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.
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
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
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
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
Toolbox,
2. Adicionar um outro Button controle a célula B3 da planilha.
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.
Ao inicializar os dados e os controles
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 = ">";
C#
EventHandler(button2_Click);
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:
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
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
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:
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.
• Adicionar um controle de usuário para uma planilha.
• Alterar o estilo do gráfico quando uma opção está selecionada.
Observação
Pré-requisitos
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.
7. Na lista As object in:, selecione Sheet1.
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.
Excel.
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,
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.
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:

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

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:

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:

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
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
Microsoft.Office.Interop.Excel.XlChartType.xlBarClustered; if (this.SelectionChanged != null) {
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
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
Microsoft.Office.Interop.Excel.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) {
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
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.
Sheet1.cs. e selecione View Designer
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
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.
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:
Office:.
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.
• 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.
Observação
Pré-requisitos
Criando o projeto
A primeira etapa é para criar um projeto de pasta de trabalho do Excel.
• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Actions Pane.
Actions Pane projeto para Solution Explorer.
Adicionar uma nova fonte de dados ao projeto
Para adicionar uma nova fonte de dados para o projeto
menu.
Observação
Se Show Data Sources clique dentro na planilha do Excel e depois verificar novamente. não
estiver disponível,
Wizard.
4. Clique em Next.

7. Marque a caixa de seleção ao lado da Suppliers tabela.
8. Expandir a Products tabela e selecione ProductName, SupplierID,
QuantityPerUnit. e UnitPrice
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.
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
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.

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
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.
2. Confirme se o painel Actions está visível.

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:
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.
• 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
• 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.
• 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.
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."); }
Inicia o Word e a caixa de mensagem aparece.
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.

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

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

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\.
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.
• 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
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
• Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment.
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.
2. Adicione o seguinte código ao manipulador Startup de eventos dentro a ThisWorkbook
C#

MessageBox.Show("The workbook is deployed successfully."); }
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.

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

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
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.
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
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.
Passo-a-passo: Concedendo e removendo permissões para uma solução

do Office
Pré-requisitos
Criando o projeto

C#
6. Clique em Save.
9. Feche o Excel.
Visual Studio.
nível do usuário.

5. Clique em Yes.
7. Clique em OK.
8. Feche o Excel.
Microsoft .NET.
prova.
Key file name.
7. Clique em OK.
nome forte.
no nome forte.
atalho
em Next.

7. Clique em Next.
Testar o aplicativo

O WORD USANDO EXPLICAÇÕES
PASSO-A-PASSO
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.
• Adicione texto e um controle a um documento.
Observação
Pré-requisitos
• O Microsoft Office Word 2003.
Criando o projeto
Neste procedimento, você irá criar projeto usando Visual Studio Tools for Office um documento do
Word.
• Criar um projeto Documento do Word com o nome My Word Formatting. Verifique
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.

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

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:

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:

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.

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

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

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.
Observação
Pré-requisitos
Criando o projeto
Nesta etapa, você irá criar projeto usando Visual Studio Tools for Office um documento do Word.
• Criar um projeto Documento do Word com o nome My Word Button. Verifique que
Abre o novo documento do Word no designer e adiciona o My Word Button projeto para
Adicionar controles ao documento do Word
Nesta seção, você adicionará um botão e uma caixa de texto para o documento Word.
2. Na guia Common Controls da Toolbox, arraste um TextBox controle para o
documento.

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.

5. Arraste um Button controle para o documento e alterar as seguintes propriedades:

Name insertText
Text Inserir texto

Preencher a caixa de texto quando o botão É Clicked
1. Na Solution Explorer, clique com o botão direito do mouse ThisDocument e, em
seguida clique View Code no menu de atalho.
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#
Testar o aplicativo
Agora você pode testar seu documento para certificar-se que a mensagem Hello World!
Próximas etapas
em documentos do Word. Aqui estão algumas tarefas que podem vie em seguida:
• 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.

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.
• 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.
Observação
Pré-requisitos
Criando o projeto
Nesta etapa, você irá criar um projeto Documento do Word no Visual Studio.
• Criar um projeto Documento do Word com o nome My Bookmark Shortcut Menu.
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.
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.

3. Adicionar outro Bookmark controle com as palavras right-click the text in a
bookmark.
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
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; } } }

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

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.
• Adicionar um gráfico a um documento.
• Adicionar um controle de usuário a um documento.
Observação
Pré-requisitos
Criando o projeto
• Criar um projeto Documento do Word com o nome My Chart Options. Verifique que
Abre o novo documento do Word no designer e adiciona o My Chart Options projeto para
Adicionar um gráfico ao documento
Em seguida, adicione um gráfico para o documento.
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

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.
1. Selecione o My Chart Options projeto no Solution Explorer.
3. Na caixa Add New Item de diálogo, clique User Control, nome do controle
ChartOptions, e clique em Add

Name columnChart
3. Adicionar um segundo Radio Button ao controle de usuário, e alterar as seguintes

propriedades:

Name barChart
4. Adicionar um terceiro Radio Button ao controle de usuário, e alterar as seguintes

propriedades:

Name lineChart
5. Adicionar um quarto Radio Button ao controle de usuário, e alterar as seguintes

propriedades:

Name areaBlockChart
Adicionar Referências

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
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.
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#
Microsoft.Office.Interop.Graph.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) {
2. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart
de opção.
C#
Microsoft.Office.Interop.Graph.XlChartType.xlBarClustered; if (this.SelectionChanged != null) {
3. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão
columnChart de opção.
C#

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#
Microsoft.Office.Interop.Graph.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) {
o código para o ChartOptions Construtor, sob a chamada para InitializeComponent,
conforme mostrado abaixo. Para obter informações sobre como criar manipuladores de
do Office:.
C#
Adicionando o controle de usuário ao documento
Toolbox. Do Toolbox Você pode, então, arrastar o controle de ao seu documento.
Para adicionar o controle de usuário do documento
ThisDocument.cs. e selecione View Designer
3. Do Toolbox arraste o ChartOptions controle de para o documento.
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); } }
do Office:.

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
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
Office:
Walkthrough:.
• Alterar formatação, selecionando um estilo da caixa de combinação. Para obter mais
CheckBox.
Vinculação de Dados para controles em um painel Ações do

Word Walkthrough:
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.
• 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.
Observação
Pré-requisitos

Criando o projeto
• Criar um projeto Documento do Word com o nome My Word Actions Pane. Verifique
Abre o novo documento do Word no designer e adiciona o My Word Actions Pane projeto
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.
1. Selecione o My Word Actions Pane projeto no Solution Explorer.
ActionsControl, e clique em Add
menu.
Observação
Se Show Data Sources Clique dentro do documento do Word e marque novamente. não estiver
disponível,
Wizard.
4. Clique em Next.
7. Marque a caixa de seleção ao lado e Products tabelas. o Suppliers
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

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,

Name Inserir
Text Inserir

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#

private void ActionsControl_Load(object sender, EventArgs e) {
this.suppliersTableAdapter.Fill(this.northwindDataSet.Suppliers);
this.productsTableAdapter.Fill(this.northwindDataSet.Products); }
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 =

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
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);
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
C#
this.ActionsPane.Controls.Add(actions);
Testar o aplicativo

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.
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
um painel Ações no Word. Aqui estão algumas tarefas que podem vie em seguida:
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:.
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.
• 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
• 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
Abre o novo documento do Word no designer e adiciona o My Smart Tag projeto para

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

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.
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:
desenvolvimento.
Pré-requisitos

Observação

Criando o projeto
C#
private void ThisDocument_Startup(object sender, System.EventArgs e) {
MessageBox.Show("The document is deployed correctly."); }
5. Sair do Word.

3. Na caixa Specify the location to publish this application, digite
C:\TestDeploy.
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.
Observação

Observação
Inclui Visual Studio Tools for Office um Exemplo que demonstre como criar uma ferramenta que
consulte Aplicativo Manifest Exemplo Editor.

C#
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
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(); } }
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 <dependentAssembly> Element (Visual Studio Tools for
Office Reference).O atributo para essa explicação passo a passo deve aspecto como este:
solução.
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
<dependentAssembly
codebase="\\DeployServer\ShareFolder\WordDeployment.application"
para o servidor.

1. Crie uma WordDeployment_1.0.0.0 pasta sob a
\\DeployServer\ShareFolder compartilhamento de arquivos de rede.
Observação

Próximas etapas
Implantando um Word ou Solution do Excel usando um arquivo

do Windows Installer Walkthrough:
Office Word 2003.

Installer.
solução.
Observação
Pré-requisitos
Observação
Criando o projeto
• Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment.

C#
MessageBox.Show("The workbook is deployed successfully."); }
5. Saia do Excel.
Deployment.
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.
Explorer.
7. Clique em OK.

8. No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó
de projeto.
Windows.
6. Clique em OK.
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 é

5. Do ManifestEditor.cs clique com o botão direito do mouse no Solution Explorer,
ou ManifestEditor.vb arquivo e clique em View Code.
C#
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.
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
Explorer.
Custom Action.
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
9. Clique com o botão direito do mouse Primary output from ExcelCustomAction
(Active) e, em seguida clique em Properties Window.

seqüência:
CustomActionData.
Passo-a-passo: Concedendo e removendo permissões para uma

solução do Office
Pré-requisitos
Criando o projeto

C#
6. Clique em Save.
9. Feche o Excel.
Visual Studio.
nível do usuário.
5. Clique em Yes.

7. Clique em OK.
8. Feche o Excel.
Microsoft .NET.
prova.
Key file name.
7. Clique em OK.
nome forte.
no nome forte.
atalho
em Next.
7. Clique em Next.
Testar o aplicativo


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

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

Para adicionar um controle Windows Forms para o documento clicando uma única vez
sobre o controle
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
Para adicionar um controle Windows Forms para o documento clicando duas vezes no
controle
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
Para adicionar um controle Windows Forms para o documento, pressionando a tecla

ENTER
Office:.
2. Na guia Common Controls Da Clique no controle que você deseja adicionar e
pressione a tecla ENTER. o Toolbox,
Observação
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

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

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

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#

// 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 =
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 =
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); }

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 é

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.

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.

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

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

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

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

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

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

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

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

" 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#
Ele também pode retornar um int:
C#
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

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

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

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 }

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

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

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#

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"

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,

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

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.

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.

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

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:

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.

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();

}
}
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;
}
}
{
add
{
}
remove
{
}
}
{
add
{
}
remove
{
}

}
{
add
{
}
remove
{
}
}
{
add
{
}
remove
{
}
}
{
add
{
}
remove
{
}
}
}
public class MyClass
{
{
}
}
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

{
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");
}
}
{
{
}
}
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();

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 ()
{
}

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

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

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 static int x = 55;

public static int e = 22;
}

{
new public static int x = 100; // Name hiding
{
// 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 int x = 200;
public int y;
}
}

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

{
// 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:
Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes
datributo, veja 17. Atributos.

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

// 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
{
{
// 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
{
{
// Declare an object:
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

{
}
public class IsTest
{
{
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

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

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
{
{
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
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 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 {
{
Empoyee E = new Empoyee();

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)
{
}

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

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

// 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;
{
[DllImport("Cmdll.dll")]
public static extern int MyMethod(int x);
{
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;

}
public class MyClass2

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

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

{
{
// Criate objects:
Empoyee E1 = new Empoyee ("John M. Trainer", "jtrainer");
// Display results:
E1.printEmpoyee();
}

}
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
{
{
Console.Write("Enter a character: ");
char c = (char) Console.Read();
if (Char.IsLetter(c))

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

class test
{
{
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.

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
{
{
Fraction a = new Fraction(1, 2);
Fraction b = new Fraction(3, 7);

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

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
{
{
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
{
{
Console.Write("Enter your selection (1, 2, or 3): ");
int n = Int32.Parse(s);
switch(n)
{
case 1:
Console.WriteLine("Current value is {0}", 1);
break;
case 2:
break;

case 3:
break;
default:
Console.WriteLine("Sorry, invalid selection.");
break;
}
}
}
Entrada
1
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
{
{
int i = 123;
string s = "Some string";
object ou = s;

try
{
// Invalid conversion; ou contains a string not an int
i = (int) o;
}
finally
{
Console.Write("i = {0}", i);
}
}
}
Resultado
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

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

{
char i; // variável need not be initialized
Console.WriteLine(TestOut(out 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

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

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:

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

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

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()));
}
}
{
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
...
t r y try-bock c a t c h catch-bock
de onde:
try-bock
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 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:
{
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.
{
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
{
{
MyClass x = new MyClass();
try
{
string s = null;
x.MyFn(s);
}
catch (Exception e)
{
}
}
public void MyFn(string s)
{
if (s == null)
}
}
Resultado
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
{
{
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);
}
}
{
if (s == null)
throw new ArgumentNullException();
}
}
Resultado
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

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
{
{
Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");
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

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

• 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
{
{
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 static void UseParams(params int[] list)
{
for ( int i = 0 ; i < list.Length ; i++ )
Console.WriteLine(list[i]);
}
public static void UseParams2(params object[] list)
{
for ( int i = 0 ; i < list.Length ; i++ )
Console.WriteLine(list[i]);
}
{

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 int intI;
public void MyMeth()
{
}
{

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());
}
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
{
{
int radius = 3;
Console.WriteLine("Area = {0}", radius*radius*Math.PI);
Console.WriteLine("The type is {0}",

(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
...
t r y try-bock c a t c h catch-bock
de onde:
try-bock
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:
{
}
É 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.

Se pode utilizar uma instrução throw no bloco catch para voltar a provocar a exceção capturada
pela instrução catch. Por exemplo:
{
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.
{
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
{
{
try
{
string s = null;
x.MyFn(s);
}
catch (Exception e)

{
}
}
{
if (s == null)
}
}
Resultado
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
{
{
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);
}
}
{
if (s == null)
throw new ArgumentNullException();
}
}
Resultado

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
{

{
for (int i = 1; i <= 5; 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
{
{
Empoyee e = new Empoyee();
// Accessing the public field:

string n = e.name;
// Accessing the private field:

double s = e.AccessSalary();
}

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

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

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

}
}
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:
Informação declarativa adicional. Para obter mais informação sobre os atributos e as classes
datributo, veja 17. Atributos.
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
{
{
TakesADelegate(new MyDelegate(DelegateFunction));
}
public static void TakesADelegate(MyDelegate SomeFunction)
{

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 void InstanceMethod()
{
Console.WriteLine("A message from the instance method.");
}
static public void StaticMethod()

{
Console.WriteLine("A message from the static method.");
}
}
{
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.

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

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

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
{
{
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));
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
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

1
2
3
5
8
13
21
34
55

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.

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.

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

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
{
{
double x = 1234.7;
int a;
a = (int)x; // cast double to int
Console.WriteLine(a);

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

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

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
{
{
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
{
{
Console.WriteLine(-5/2);
Console.WriteLine(-5.0/2);
}
}

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

Exemplo
// cs_operator_OR.cs
using System;
class Test
{
{
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
{
{
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

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

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

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

using System;
class Test
{
{
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

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

{
Console.WriteLine(sinc(0.2));
}
}
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
{
{
double x;

x = 1.5;
Console.WriteLine(++x);
x = 1.5;
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
{
{
double x;
x = 1.5;
Console.WriteLine(--x);
x = 1.5;
Console.WriteLine(x--);
}
}

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");

return true;
}

{
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

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.

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

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

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

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

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

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.

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

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.

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

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

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

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.

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

Para abrir os arquivos de Exemplo no Solution Explorer

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

cd HelloWorld1 csc Hello1.cs Hello1
cd ..\HelloWorld2 csc Hello2.cs Hello2
cd ..\HelloWorld3 csc Hello3.cs Hello3 A B C D
Consulte também

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.

files.
em Next novamente.
em Finish.
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.
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.)
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

1. Use o Change Directory comando para alterar para o diretório CmdLine1.
csc cmdline1.cs cmdline1 A B C
csc cmdline2.cs cmdline2 John Paul Mary
Exemplo matrizes
Download sample

files.
em Next novamente.
em Finish.
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.


files.
em Next novamente.
em Finish.
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.
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.
csc person.cs person
3. Use o Change Directory comando para alterar para o diretório shapetest.
csc abstractshape.cs shapes.cs shapetest.cs shapetest
Exemplo bibliotecas
Download sample
Este Exemplo mostra como criar e usar uma DLL em C#.


files.
em Next novamente.
em Finish.
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.
csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
3. Use o Change Directory comando para alterar para o diretório FunctionTest.
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#).

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo versão no Visual Studio
Para criar e executar o Exemplo versão a partir da linha 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#).

files.
em Next novamente.
em Finish.

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.
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.
csc tokens.cs tokens
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.

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Structs no Visual Studio

1. No Solution Explorer, clique com o projeto Struct1 e clique em Set as StartUp
Project.
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.
csc struct1.cs struct1
Exemplo indexadores
Download sample
Este Exemplo mostra como classes C# podem declarar indexadores para fornecer acesso
semelhante matriz-às classes.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Indexers no Visual Studio
1. No Solution Explorer, clique com o projeto indexadores, e clique em Properties.
3. Na propriedade Command Line Arguments, insira ..\..\Test.txt.
4. Clique em OK.

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

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo indexado propriedades no Visual Studio
Para criar e executar o Exemplo indexado Propriedades a partir da linha de comando
csc indexedproperty.cs indexedproperty

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.

files.
em Next novamente.
em Finish.
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.
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.
csc conversion.cs conversion
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

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

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Generics no Visual Studio
Para criar e executar o Exemplo Generics a partir da linha 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.


files.
em Next novamente.
em Finish.
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.
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.
csc complex.cs complex
3. Use o Change Directory comando para alterar para o diretório Dbbool.
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.

files.
em Next novamente.
em Finish.
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.
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.
csc bookstore.cs bookstore
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#).

files.

em Next novamente.
em Finish.
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.
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.
csc events1.cs events1
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#).

files.
em Next novamente.

em Finish.
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.
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.
csc explicit1.cs explicit1
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.

files.
em Next novamente.
em Finish.

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

files.
em Next novamente.
em Finish.
Para criar o Exemplo documentação XML no Visual Studio
2. Abra a pasta Propriedades de configuração e clique em Build.
3. Defina a propriedade arquivo documentação XML como XMLsample.xml.

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.

files.
em Next novamente.
em Finish.
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.
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.
csc PinvokeTest.cs PinvokeTest
3. Use o Change Directory comando para alterar para o diretório Marshal.

csc Marshal.cs Marshal
5. Use o Change Directory comando para alterar para o diretório PInvoke.
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.

files.
em Next novamente.
em Finish.
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.
4. Na propriedade argumentos de linha de comando, digite um arquivo AVI como
c:\winnt\clock.avi.
5. Clique em OK.
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.

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.
tlbimp %windir%\system32\quartz.dll /out:QuartzTypeLib.dll csc /r:QuartzTypeLib.dll
interop1.cs interop1 %windir%\clock.avi
csc interop2.cs interop2 %windir%\clock.avi

Download sample
Este Exemplo demonstra usando um servidor C# com um cliente com C++.
Observação
É preciso instalar para compilar Este Exemplo Visual C++.

files.
em Next novamente.

em Finish.
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.
3. Na propriedade Command Line Arguments, digite um nome.
4. Clique em OK.
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#).

files.

em Next novamente.
em Finish.
Para criar e executar o Exemplo atributos no Visual Studio
Para criar e executar o Exemplo atributos a partir da linha 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#).

files.
em Next novamente.
em Finish.
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.

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.
csc ImperativeSecurity.cs ImperativeSecurity
csc DeclarativeSecurity.cs DeclarativeSecurity
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

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Threading no Visual Studio

1. No Solution Explorer, clique com o projeto ThreadStartStop e clique em Set as
StartUp Project.
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.
cd ThreadStartStop csc ThreadStartStop.cs ThreadStartStop
cd ..\ThreadPool csc ThreadPool.cs ThreadPool
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#.

files.
em Next novamente.
em Finish.
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.

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.
6. Na propriedade argumentos da linha de comando, insira ..\..\ReadFile.cs.
7. Clique em OK.
9. No Solution Explorer, clique com o projeto PrintVersion, e clique em Set as
StartUp Project.
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.
cd FastCopy csc FastCopy.cs /unsafe FastCopy
cd ..\ReadFile csc ReadFile.cs /unsafe ReadFile ReadFile.cs
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.

files.
em Next novamente.
em Finish.

Para criar e executar o Exemplo de banco de dados OLE no Visual Studio
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

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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo YIELD código no Visual Studio
Para criar e executar o Exemplo YIELD código a partir da linha de comando

1. Use o Change Directory (cd) comando para alterar para o Yield Diretório.
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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo de código AnonymousDelegates no Visual Studio
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.
csc AnonymousDelegates.cs AnonymousDelegates

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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo de código PartialTypes no Visual Studio
Para criar e executar o Exemplo de código PartialTypes a partir da linha de comando
1. Use o Change Directory (cd) comando para alterar para o PartialTypes Diretório.
csc PartialTypes.cs PartialTypes
Exemplo anulável
Download sample
Este Exemplo demonstra o uso de tipos anuláveis. Esse recurso permite que tipos de valores para
que um estado não inicializada, ou vazio, semelhante a como tipos de referência podem ser
definidos como null.
Este Observação de segurança 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

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Nullable código no Visual Studio
1. Abra Nullable.sln, o arquivo de solução, o clicando duas vezes no arquivo no Windows
Explorer, ou clicando Open no menu File.
Para criar e executar o Exemplo de código Nullable a partir da linha de comando
1. Use o Change Directory (cd) comando para alterar para o diretório Nullable.
csc Nullable.cs Nullable

TERMINOLOGIA C#
Modificador de acesso
Uma palavra-chave, como Particular, Protegido ou Pública, que restringe o acesso a um
tipo ou membro Tipo., interno Para obter mais informações, consulte Modificadores de
acesso.
Membro acessível
Um membro que pode ser acessado por um tipo determinado. Um membro acessível para
um tipo não está necessariamente acessível para um outro tipo. Para obter mais
informações, consulte Modificadores de acesso e Conjuntos de amigo.
Assessor
Um método que Define ou recupera o valor de um valor que está associado a uma
propriedade membro dados particulares. Propriedades de leitura-gravação e set ter get
assessores. Propriedades que são somente leitura têm apenas um get acessador. Para
obter mais informações, consulte Propriedades.
Método anônimo
Um método anônimo é um bloco de código que é passado como um parâmetro para um
Delegar. Para obter mais informações, consulte Métodos anônimo.
Classe base
Uma Classe que é herdado por outra classe ' derivado '. Para obter mais informações,
consulte Herança.
Chamar pilha
A série de método chama à esquerda do início do programa para a instrução atualmente
sendo executado em tempo de execução.
Classe
Um tipo de dados que descreve um objeto. Classes conter dados, e os métodos para agir
sobre os dados. Para obter mais informações, consulte Classes.
Construtor
Um método especial em class ou struct que inicializa os objetos do mesmo tipo. Para obter
mais informações, consulte Construtores.
Delegar
Um representante é um tipo que referencia um método. Depois que um representante é
atribuído um método, ele funciona exatamente como esse método. Para obter mais
informações, consulte Representantes.
Classe derivada
Um Classe que usa herança para obter, aumentar, ou modificar o comportamento e dados
de outra classe ' base '. Para obter mais informações, consulte Herança.
destruidor
Um método especial em ou struct que prepara a instância para Destruição pelo sistema.
um Classe Para obter mais informações, consulte Destructors.
Evento
Um membro da OU struct que envia notificações de alteração. um Classe Para obter mais
informações, consulte Eventos.

Campo
Um membro de dados ou struct que é acessado diretamente. um Classe
generics
Generics permitir que você a definir e ou método que são definidas com um parâmetro de
tipo. um Classe Quando código cliente instancia o tipo, ele especifica um tipo específico
como um argumento. Para obter mais informações, consulte Generics.
IDE
Ambiente de desenvolvimento integrado. O aplicativo que fornece a interface do usuário
unificada para as ferramentas de desenvolvimento vários incluindo o compilador,
depurador, editor de código, e designers.
Tipo imutável
Um tipo cujos dados de instância, campos e propriedades, não altera depois a instância for
criada. A maioria dos tipos valor são imutáveis.
Membro inacessível
Um membro que não pode ser acessado por um tipo determinado. Um membro inacessível
para um tipo é não necessariamente inacessível para outro tipo. Para obter mais
informações, consulte Modificadores de acesso.
Herança
C# herança oferece suporte, para uma Classe que deriva de outra classe, conhecido como
a classe base, herda os mesmos métodos e propriedades. Herança envolve classes base
e classes derivadas. Para obter mais informações, consulte Herança.
Interface
Um tipo que contém somente as assinaturas de métodos públicos, eventos e
representantes. Um objeto que herda a interface deve implementar todos os métodos e
eventos definidos na interface. Classes ou estruturas podem herdar qualquer número de
interfaces. Para obter mais informações, consulte Interfaces
iterador
Um iterador é um método que permite que os consumidores de uma Classe que contém
uma coleção ou matriz para usar foreach, na referência (C#) para percorrer essa coleção
ou matriz.
Membro
Um campo, propriedade, método, ou evento declarado no ou struct. um Classe
Método
Um bloco de códigos nomeado que fornece comportamento para ou struct. um Classe
Tipo mutáveis
Um tipo cujos dados de instância, campos e propriedades, podem ser alteradas após a
ocorrência é criada. A maioria Tipos de referência está mutáveis.
tipo aninhado
Um tipo declarado na declaração de outro tipo.
object
Uma instância de um Classe. Um objeto existe na memória, e tem dados e métodos que
atuam sobre os dados. Para obter mais informações, consulte Objetos, classes, e Structs.
Propriedade

Um membro de dados acessado por meio de um acessador. Para obter mais informações,
consulte Propriedades.
refatoração
Reutilizando anteriormente digitado código. Visual Express Editor código C#
inteligentemente pode reformatar código para, por exemplo, transformar um bloco de
código de realce em um método. Para obter mais informações, consulte Refatoração.
Tipo de referência
Um tipo de dados. Uma variável declarada como um ponto Tipo de referência para um
local em que os dados são armazenados. Para obter mais informações, consulte Tipos de
referência.
static
Existe uma classe ou método declarado como estático sem primeiro sendo instanciado
usando a palavra-chave new. é Main() um método estático. Para obter mais informações,
consulte Classes estáticas e membros de classe estáticos.
struct
Um tipo composto dados que é normalmente usado para conter algumas variáveis que têm
alguma relação lógica. Structs também podem conter métodos e eventos. Structs não
oferecerem suporte herança mas eles fazer suporte interfaces. É uma estrutura a Tipo de
valor,. enquanto é um Classe um Tipo de referência Para obter mais informações, consulte
Structs.
Tipo de valor
Um tipo de valor é um tipo de dados que está alocado na pilha, em um tipo de referência
que é alocado em pilha vez. Incluindo o Tipos internas, os tipos numéricos, bem como o
tipo estrutura e o tipo anulável, são todos os tipos valor. O Classe tipo e Seqüência Tipo
são Tipos de referência. Para obter mais informações, consulte Tipos valor (referência C#).

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
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.
Nesta seção
Anônimo Exemplo Demonstra o uso de representantes para reduzir a complexidade de

Coleção Exemplo Mostra como fazer classes coleção Generic não-que podem ser usados



implementação de

saudação
Indexado Exemplo Mostra como a implementar uma classe que usa propriedades


palavras-chave.

coleção.
Interop COM
Interop COM
programas.


exemplo



não seguros

documentação XML
Exemplo World de saudação

Download sample
Este Exemplo mostra várias versões de um programa hello world em C#.
Para abrir os arquivos de Exemplo no Solution Explorer

A caixa de mensagem Download de arquivo será exibida.
6. Clique em Open e, na coluna esquerda da pasta CEP, clique em Extract all files.
7. Clique em Next. Você pode mudar a pasta os arquivos serão extraídos para, ou clique em
Next novamente.
8. Certifique-se de que a Show extracted files caixa de seleção esteja marcada e clique
em Finish.
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

17. Abra a solução (HelloWorld.sln).
StartUp Project.
StartUp Project.
StartUp Project.
25. No Solution Explorer, clique com o projeto HelloWorld3, e clique em Properties.
27. Na Command Line Arguments propriedade, tipo A B C D e clique em OK.
StartUp Project.
Para criar e executar os exemplos hello world a partir da linha de comando
6. Use o Change Directory comando para alterar para o diretório HelloWorld.
cd HelloWorld1 csc Hello1.cs Hello1
cd ..\HelloWorld3 csc Hello3.cs Hello3 A B C D

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.


files.
em Next novamente.
em Finish.
Para criar e executar os exemplos parâmetros de linha de comando no Visual Studio
7. No Solution Explorer, clique com o projeto CmdLine1, e clique em Set as StartUp
Project.
8. No Solution Explorer, clique com o projeto, e clique em Properties.
10. Na propriedade Command Line Arguments, digite os parâmetros da linha de
comando, e clique em OK. (Consulte o tutorial para obter um exemplo.)
12. Repita as etapas anteriores para CmdLine2.
Para criar e executar os exemplos parâmetros de linha de comando a partir da linha de comando
csc cmdline1.cs cmdline1 A B C
csc cmdline2.cs cmdline2 John Paul Mary
Exemplo matrizes
Download sample


files.
em Next novamente.
em Finish.
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.

files.
em Next novamente.

em Finish.
Para criar e executar os exemplos propriedades no Visual Studio
4. No Solution Explorer, clique com o projeto pessoa e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para shapetest.
Para criar e executar os exemplos Propriedades a partir da linha de comando
5. Use o Change Directory comando para alterar para o diretório pessoa.
csc person.cs person
7. Use o Change Directory comando para alterar para o diretório shapetest.
csc abstractshape.cs shapes.cs shapetest.cs shapetest
Exemplo bibliotecas
Download sample
Este Exemplo mostra como criar e usar uma DLL em C#.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo bibliotecas no Visual Studio
7. No Solution Explorer, clique com o projeto FunctionTest, e clique em Set as
StartUp Project.
8. No Solution Explorer, clique com o projeto FunctionTest, e clique em Properties.
9. Abra a Configuration Properties pasta e clique em Debug.
10. Na propriedade Command Line Arguments, insira 3 5 10.
11. Clique em OK.
12. 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
5. Use o Change Directory comando para alterar para o diretório funções.
csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
7. Use o Change Directory comando para alterar para o diretório FunctionTest.
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#).

files.
em Next novamente.
em Finish.

Para criar e executar o Exemplo versão no Visual Studio
Para criar e executar o Exemplo versão a partir da linha 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#).

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos classes coleção no Visual Studio
4. No Solution Explorer, clique com o projeto CollectionClasses1 e clique em Set as
StartUp Project.
6. Repita as etapas anteriores para CollectionClasses2.
Para criar e executar os exemplos classes coleção a partir da linha de comando
csc tokens.cs tokens

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.

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Structs no Visual Studio
4. No Solution Explorer, clique com o projeto Struct1 e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Struct2.
Para criar e executar os exemplos Structs a partir da linha de comando

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

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Indexers no Visual Studio
6. No Solution Explorer, clique com o projeto indexadores, e clique em Properties.
8. Na propriedade Command Line Arguments, insira ..\..\Test.txt.
9. Clique em OK.
Para criar e executar o Exemplo Indexers a partir da linha de comando
3. 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
4. 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#).

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo indexado propriedades no Visual Studio
Para criar e executar o Exemplo indexado Propriedades a partir da linha de comando
csc indexedproperty.cs indexedproperty
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.


files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Conversions pelo usuário no Visual Studio
4. No Solution Explorer, clique com o projeto Conversion1 e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Conversion2.
Para criar e executar os exemplos Conversions pelo usuário a partir da linha de comando
csc conversion.cs conversion
csc structconversion.cs structconversion
Exemplo generics (C#)

Download sample (http://download.microsoft.com/download/9/A/6/9A639BEE-F7B0-
423D-BFFD-4356299205D8/Generics.zip.exe)
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
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#).


files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Generics no Visual Studio
Para criar e executar o Exemplo Generics a partir da linha 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.

files.
em Next novamente.
em Finish.

Para criar e executar os exemplos Overloading operador no Visual Studio
4. No Solution Explorer, clique com o projeto complexo e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Dbbool.
Para criar e executar os exemplos operador Overloading a partir da linha de comando
5. Use o Change Directory comando para alterar para o diretório complexo.
csc complex.cs complex
7. Use o Change Directory comando para alterar para o diretório Dbbool.
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.

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos representantes no Visual Studio

4. No Solution Explorer, clique com o projeto Delegates1, e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Delegates2.
Para criar e executar os exemplos representantes a partir da linha de comando
csc bookstore.cs bookstore
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#).

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos eventos no Visual Studio
4. No Solution Explorer, clique com o projeto Events1, e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Events2.
Para criar e executar os exemplos eventos a partir da linha de comando
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#).

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Explicit implementação interface no Visual Studio
4. No Solution Explorer, clique com o projeto ExplicitInterface1 e clique em Set as
StartUp Project.
6. Repita as etapas anteriores para ExplicitInterface2.
Para criar e executar os exemplos Explicit implementação interface a partir da linha de comando

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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo métodos condicional no Visual Studio
9. Defina a Command Line Arguments propriedade para A B C.
10. Na pasta Propriedades de configuração, clique em Build.
11. Modificar a Conditional Compilation Constants propriedade. Por exemplo,
adicionar ou excluir Debug. Clique em OK.
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.

files.
em Next novamente.
em Finish.
Para criar o Exemplo documentação XML no Visual Studio
6. Abra a pasta Propriedades de configuração e clique em Build.
7. Defina a propriedade arquivo documentação XML como XMLsample.xml.
8. 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
3. Para gerar a documentação XML de exemplo, digite o seguinte no prompt de comando:
csc XMLsample.cs /doc:XMLsample.xml
4. 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.


files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Platform Invoke no Visual Studio
4. No Solution Explorer, clique com o projeto PinvokeTest e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Marshal e PInvoke.
Para criar e executar os exemplos Platform Invoke a partir da linha de comando
7. Use o Change Directory comando para alterar para o diretório PinvokeTest.
csc PinvokeTest.cs PinvokeTest
9. Use o Change Directory comando para alterar para o diretório Marshal.
csc Marshal.cs Marshal
11. Use o Change Directory comando para alterar para o diretório PInvoke.
csc logfont.cs pinvoke.cs pinvoke

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


files.
em Next novamente.
em Finish.
Para criar e executar os exemplos com Interop parte 1 no Visual Studio
8. No Solution Explorer, clique com o projeto Interop1, e clique em Set as StartUp
Project.
9. No Solution Explorer, clique com o projeto Interop1, e clique em Properties.
11. Na propriedade argumentos de linha de comando, digite um arquivo AVI como
c:\winnt\clock.avi.
12. Clique em OK.
14. Repita as etapas anteriores para Interop2.
Se o QuartzTypeLib.dll incluído com Interop1 está desatualizado
7. No Solution Explorer, abrir References para Interop1.
8. Clique com o botão direito do mouse QuartzTypeLib e, clique em Remove.
9. Clique com o botão direito do mouse References e, clique em Add Reference.
10. Na guia COM, selecione o componente denominado, " biblioteca Tipo de Controle
ActiveMovie ".
11. Clique em Select e, clique em OK.
12. 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

tlbimp %windir%\system32\quartz.dll /out:QuartzTypeLib.dll csc /r:QuartzTypeLib.dll
interop1.cs interop1 %windir%\clock.avi
csc interop2.cs interop2 %windir%\clock.avi

Download sample
Este Exemplo demonstra usando um servidor C# com um cliente com C++.
Observação
É preciso instalar para compilar Este Exemplo Visual C++.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo 2 Part Interop COM no Visual Studio
6. No Solution Explorer, clique com o projeto COMClient, e clique em Properties.
8. Na propriedade Command Line Arguments, digite um nome.
9. Clique em OK.

Para criar e executar o Exemplo 2 Part Interop COM a partir da linha de comando
6. Use o Change Directory comando para alterar para o diretório
COMInteropPart2\COMClient.
7. Copie o código do servidor C# para o diretório COMClient:
copy ..\CSharpServer\CSharpServer.cs
8. Compilar o servidor:
csc /target:library CSharpServer.cs regasm CSharpServer.dll /tlb:CSharpServer.tlb
9. Compilar o cliente (verifique se as variáveis Caminho e ambiente são definidas
corretamente com vcvars32.bat)::
cl COMClient.cpp
10. 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#).

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo atributos no Visual Studio
Para criar e executar o Exemplo atributos a partir da linha 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#).

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos de segurança no Visual Studio
4. No Solution Explorer, clique com o projeto Security1 e clique em Set as StartUp
Project.
6. Repita as etapas anteriores para Security2 e Security3.
Para criar e executar os exemplos de segurança a partir da linha de comando
csc ImperativeSecurity.cs ImperativeSecurity
csc DeclarativeSecurity.cs DeclarativeSecurity
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

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos Threading no Visual Studio
4. No Solution Explorer, clique com o projeto ThreadStartStop e clique em Set as
StartUp Project.
6. Repita as etapas anteriores para ThreadPool, e ThreadSync.
Para criar e executar os exemplos Threading a partir da linha de comando
5. Use o Change Directory comando para alterar para o diretório segmentos.
cd ThreadStartStop csc ThreadStartStop.cs ThreadStartStop
cd ..\ThreadPool csc ThreadPool.cs ThreadPool
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#.

files.
em Next novamente.
em Finish.
Para criar e executar os exemplos UNSAFE código no Visual Studio
11. No Solution Explorer, clique com o projeto FastCopy, e clique em Set as StartUp
Project.
13. No Solution Explorer, clique com o projeto ReadFile, e clique em Set as StartUp
Project.
14. No Solution Explorer, clique com o projeto ReadFile, e clique em Properties.
16. Na propriedade argumentos da linha de comando, insira ..\..\ReadFile.cs.
17. Clique em OK.
19. No Solution Explorer, clique com o projeto PrintVersion, e clique em Set as
StartUp Project.
Para criar e executar os exemplos de código UNSAFE a partir da linha de comando
5. Use o Change Directory comando para alterar para o diretório UNSAFE.
cd FastCopy csc FastCopy.cs /unsafe FastCopy
cd ..\ReadFile csc ReadFile.cs /unsafe ReadFile ReadFile.cs
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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo de banco de dados OLE no Visual Studio
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

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.

files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo YIELD código no Visual Studio
Para criar e executar o Exemplo YIELD código a partir da linha de comando
3. Use o Change Directory (cd) comando para alterar para o Yield Diretório.
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.


files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo de código AnonymousDelegates no Visual Studio
Para criar e executar o Exemplo de código AnonymousDelegates a partir da linha de comando
3. Use o Change Directory (cd) comando para alterar para o diretório
AnonymousDelegates.
csc AnonymousDelegates.cs AnonymousDelegates
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.


files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo de código PartialTypes no Visual Studio
Para criar e executar o Exemplo de código PartialTypes a partir da linha de comando
3. Use o Change Directory (cd) comando para alterar para o PartialTypes Diretório.
csc PartialTypes.cs PartialTypes
Exemplo anulável
Download sample
Este Exemplo demonstra o uso de tipos anuláveis. Esse recurso permite que tipos de valores para
que um estado não inicializada, ou vazio, semelhante a como tipos de referência podem ser
definidos como null.
Este Observação de segurança 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
files.
em Next novamente.
em Finish.
Para criar e executar o Exemplo Nullable código no Visual Studio

3. Abra Nullable.sln, o arquivo de solução, o clicando duas vezes no arquivo no Windows
Explorer, ou clicando Open no menu File.
Para criar e executar o Exemplo de código Nullable a partir da linha de comando
3. Use o Change Directory (cd) comando para alterar para o diretório Nullable.
csc Nullable.cs Nullable

Como Fazer em C#
http://msdnwiki.microsoft.com/pt-br/mtpswiki/ms186211.aspx
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

O que há de novo em Projetos para Dispositivos Inteligentes... Programação para
Dispositivos Inteligentes... Depuração em Dispositivos Inteligentes... mais
Implantação
ClickOnce… O Windows Installer

Linguagem C# (como eu faço em C#)
Esta página possui links para ajudá-lo com tarefas frequentemente executadas na linguagem C#.
Para ver outras categorias de tarefas populares abordadas na ajuda, consulte Como eu faço em
C#.
A linguagem C#
O que há de novo na linguagem e no compilador C# 2.0
Contém informações sobre os novos recursos, incluindo classes genéricas, iteradores,

métodos anônimos e tipos parciais.
Usando o Starter Kit para C#
Explica como carregar e compilar um Starter Kit no Visual C#.
Especificação da linguagem C#
Ponteiros para a versão mais recente da especificação em formato Microsoft Word.
Linha de comando
Explica o método Main, o ponto de entrada do seu programa, onde você cria objetos e
chama outros métodos. Só pode haver um ponto de entrada em um programa C#.
COMO: Acessar argumentos de linha de comando usando foreach (Guia de programação C#)
Fornece um exemplo de código que mostra como acessar os parâmetros da linha de

comando.
COMO: Exibir argumentos de linha de comando (Guia de programação C#)
Explica como exibir argumentos de linha de comando através do vetor de seqüências

args.
Explica os possíveis valores retornados pelo método principal.
Classes e herança
Base (Referência C#)
Explica como especificar o construtor da classe base chamado ao criar instâncias de uma
classe derivada.
COMO: Saber as diferenças entre passar uma estrutura e passar uma referência de classe para
um método (Guia de programação C#)
Contém um exemplo de código que mostra que quando uma estrutura (struct) é passada
para um método, uma cópia da estrutura é passada, mas quando uma instância de classe
é passada, uma referência é passada.

Construtores de instância (Guia de programação C#)
Explica construtores de classe e herança.
Propriedades
COMO: Declarar e usar propriedades de leitura/escrita (Guia de programação C#)
Contém um exemplo que mostra como declarar e usar propriedades de leitura/escrita.
COMO: Definir propriedades abstratas (Guia de programação C#)
Contém um exemplo de código que mostra como definir propriedades abstratas.
Eventos
COMO: Criar um controle que responde a eventos (Guia de programação C#)
Contém um exemplo de código que mostra uma classe, ListWithChangedEvent, que é

semelhante à classe padrão ArrayList mas também chama um evento Changed sempre
que o conteúdo da lista é alterado.
COMO: Criar eventos que estejam de acordo com as diretrizes do .NET Framework (Guia de
programação C#)
Contém um exemplo que cria um controle que responde a eventos, seguindo as

orientações das .NET Framework Guidelines.
COMO: Declarar um evento em uma interface e implementá-lo em uma classe (Guia de

programação C#)
Mostra que é possível declarar um evento em uma interface e implementá-lo em uma

classe.
COMO: Usar um dicionário para armazenar instâncias de eventos (Guia de programação C#)
Explica como usar uma tabela de hash para armazenar as instâncias de eventos.
COMO: Implementar duas interfaces que possuam um evento com o mesmo nome (Guia de
programação C#)
Explica a situação onde você implementa duas interfaces, cada uma com um evento com o
mesmo nome. Nesse caso, você deve usar uma propriedade de evento explicitamente de
implementação.
COMO: Criar manipuladores de evento no Visual C# Code Editor (Guia de programação C#)
Oferece uma maneira fácil para criar manipuladores de eventos para seus Windows Forms
quando no modo de design. A alternativa é exibir o código fonte no modo de exibição
Source e adicionar o manipulador de eventos no código.
Interfaces
COMO: Implementar explicitamente membros de uma interface (Guia de programação C#)
Mostra como declarar uma classe que explicitamente implementa uma interface e como
acessar seus membros através da instância da interface.

COMO: Implementar explicitamente membros de uma interface com herança (Guia de
programação C#)
Fornece um exemplo que exibe as dimensões de uma caixa em unidades métrica e do

sistema inglês.
Classes Genéricas
Uma introdução ao Generics C#
Descreve como classes genéricas permitem que você defina classes de coleção que são
fortemente tipadas (Type-Safe). Você implementa a classe genérica somente uma vez,
mas você pode declará-la e usá-la com qualquer tipo.
Classes genéricas no .NET Framework
Explica os recursos e o uso do novo conjunto de coleções genéricas no espaço de nomes

System.Collections.Generic.
A palavra-chave default em código fonte "genérico" (Guia de programação C#)
Fornece um exemplo de código que demonstra como usar a palavra-chave default para
tipo parâmetros.
Métodos genéricos (Guia de programação C#)
Apresenta a sintaxe para declarar um método genérico. E também mostra um exemplo de

como usar métodos genéricos em um aplicativo.
Restrições em parâmetros de tipo (Guia de programação C#)
Mostra como restringir parâmetros de tipo para permitir o acesso a métodos e

propriedades dos tipos usados para instanciar a classe genérica.
Representantes genéricos (Guia de programação C#)
Contém a sintaxe para declarar representantes (delegates) genéricos. E também inclui

comentários importantes sobre como instanciar e usar representantes genéricos, assim
como exemplos de código.
Espaços de nomes
COMO: Usar o qualificador de espaço de nomes Alias (Guia de programação C#)
Discute a capacidade de acessar um membro no espaço de nomes global quando o

membro pode estar oculto por outra entidade com o mesmo nome.
Iteradores
COMO: Criar um bloco iterador para uma lista genérica (Guia de programação C#)
Fornece um exemplo onde um vetor de inteiros é usado para criar a lista SampleCollection.
Um laço for itera através da coleção e produz o valor de cada item. Depois um laço
foreach é usado para exibir os itens da coleção.

Fornece um exemplo onde uma classe genérica Stack<T> implementa uma interface
genérica IEnumerator<T>. Um vetor de T tipo é declarado e a ele são atribuídos valores
usando o método Push. No método GetEnumerator, os valores do vetor são retornados
usando a instrução de retorno yield.
Representantes (Delegates)
COMO: Combinar representantes (Representantes Multicast) (Guia de programação C#)
Fornece um exemplo que demonstra como compor representantes de difusão seletiva.
COMO: Declarar, instanciar e usar um representante (Guia de programação C#)
Fornece um exemplo que ilustra como declarar, criar e usar um representate (delegate).
Sobrecarga de operador
COMO: Usar sobrecarga de operador para criar uma classe para números complexos (Guia de
programação C#)
Mostra como você pode utilizar sobrecarga de operador para criar uma classe para
números complexos chamada Complex e que define adição de complexos.
Interoperabilidade
COMO: Usar interoperabilidade COM para verificar ortografia usando o Word (Guia de
programação C#)
Este exemplo ilustra como usar o verificador ortográfico do Word em um aplicativo C#.
COMO: Usar interoperabilidade COM para criar uma planilha do Excel (Guia de programação C#)
Este exemplo ilustra como abrir uma planilha já existente do Excel em C# usando
funcionalidades de interoperabilidade COM no .NET Framework.
COMO: Usar código gerenciado como um suplemento de automação para o Excel (Guia de
programação C#)
Este exemplo ilustra como criar um suplemento C# para calcular taxa de imposto de renda
em uma célula em uma planilha do Excel.
COMO: Usar serviços de chamada da plataforma para reproduzir um arquivo WAVE (Guia de
programação C#)
Este exemplo ilustra como usar serviços de chamada da plataforma para reproduzir um
arquivo de som wave na plataforma Windows.
Código não gerenciado

COMO: Usar ponteiros para copiar um vetor de bytes (Guia de programação C#)
Mostra como usar ponteiros para copiar bytes de um vetor para outro, usando ponteiros.
COMO: Usar a função ReadFile do Windows (Guia de programação C#)
Mostra como chamar a função ReadFile do Windows, que requer o uso de um contexto
não gerenciado pois o buffer de leitura requer um ponteiro como parâmetro.

Lidando com threads
Usando segmentos e Threading
Fornece uma lista de tópicos que abordam a criação e o gerenciamento de threads

gerenciados e como evitar conseqüências não intencionais.
COMO: Criar e terminar threads (Guia de programação C#)
Fornece um exemplo que demonstra como criar e iniciar uma thread e mostra a interação
entre duas threads em execução simultânea dentro do mesmo processo.
COMO: Sincronizar uma thread Produtor e uma thread Consumidor (Guia de programação C#)
Fornece um exemplo que mostra como sincronização pode ser feita usando a palavra-
chave lock de C# e o método Pulse do objeto Monitor.
COMO: Usar um pool de threads (Guia de programação C#)
Explica um exemplo que mostra como usar um pool de threads.
Seqüências de caracteres
COMO: Pesquisar em seqüências de caracteres utilizando expressões regulares (Guia de
programação C#)
Explica como a classe Regex pode ser usada para procurar em seqüências. Essas
pesquisas podem variar em complexidade de muito simples a fazer uso total de
expressões regulares.
COMO: Unir várias seqüências de caracteres (Guia de programação C#)
Contém um exemplo que demonstra como unir várias seqüências de caracteres.
COMO: Pesquisar em seqüências de caracteres utilizando métodos de String (Guia de

programação C#)
Contém um exemplo de código que demonstra como usar métodos de String para procurar
em uma seqüência.
COMO: Analisar seqüências usando o método Split (Guia de programação C#)
Contém um exemplo de código que demonstra como uma seqüência pode ser analisada
usando o método System.String.Split.
Atributos
COMO: Criar uma união C/C++ usando atributos (Guia de programação C#)
Contém um exemplo que usa o atributo serializable para aplicar uma característica
específica a uma classe.
Trabalhando com DLLs

COMO: Criar e usar DLLs em C# (Guia de programação C#)
Demonstra a criação e o uso de uma DLL, usando um cenário de exemplo.

Módulos (assemblies)
COMO: Determinar se um arquivo é um módulo (assembly) (Guia de programação C#)
Contém um exemplo que testa uma DLL para verificar se ela é um módulo (assembly).
COMO: Carregar e descarregar módulos (assemblies) (Guia de programação C#)
Explica como é possível carregar módulos (assemblies) específicos no domínio de

aplicação atual em tempo de execução.
COMO: Compartilhar um módulo (assembly) com outros aplicativos (Guia de programação C#)
Explica como compartilhar um assembly com outros aplicativos.
Domínios de aplicação
Executar código em outro domínio de aplicação (Guia de programação C#)
Mostra como executar um assembly que tenha sido carregado de outro domínio de
aplicação.
COMO: Criar e usar um domínio de aplicação (Guia de programação C#)
Mostra como a sobrecarga de operador pode ser usada para implementar um tipo lógico
tri-valorado.
Amostras
Exemplos no Visual C#
Contém links para abrir ou copiar arquivos dos exemplos que vão de Exemplo de Hello
World até Exemplo de classes genéricas (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:
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.
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.

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

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

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

O Main método pode ser do tipo void:
C#
Ele também pode retornar um int:
C#
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 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
base (Referência do C#)

Palavra-chave base é usada para acessar membros da classe base em uma classe derivada de:
• Chamar um método na classe base que tenha sido substituído por outro método.

• Especificar o construtor de classe base deve ser chamado ao criar instâncias da classe
derivada.
Um acesso classe base é permitido somente em um construtor, um método da instância, ou um

assessor propriedade da instância.
Ele é um erro para usar a base palavra de dentro de um método estático.
Exemplo
Neste exemplo, dois a classe base, Person,. e a classe, Employee, tem um método chamado
Getinfo derivado Usando a base palavra-chave, é possível para chamar o Getinfo método na
classe base, de dentro da 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 Employee : Person {
public string id = "ABC567EFG"; public override void GetInfo() { // Calling the base class GetInfo method:
base.GetInfo(); Console.WriteLine("Employee ID: {0}", id); } } class TestClass { static void Main() {
Employee E = new Employee(); E.GetInfo(); } }
Este exemplo mostra como para especificar o construtor de classe base chamado quando criar
instâncias de uma classe derivada.
// keywords_base2.cs using System; public class BaseClass { int num; public BaseClass() {
Console.WriteLine("in BaseClass()"); } public BaseClass(int i) { num = i; Console.WriteLine("in
BaseClass(int i)"); } public int GetNum() { return num; } } public class DerivedClass : BaseClass { // This
constructor will call BaseClass.BaseClass() public DerivedClass() : base() { } // This constructor will call
BaseClass.BaseClass(int i) public DerivedClass(int i) : base(i) { } static void Main() { DerivedClass md = new
DerivedClass(); DerivedClass md1 = new DerivedClass(1); } }
Saída
Name: John L. Malgraine SSN: 444-55-6666 Employee ID: ABC567EFG
Para obter exemplos adicionais, consulte Novo, virtual. e Substituir
Saída
in BaseClass() in BaseClass(int i)
• Classes base 1.6.3

• Acesso 7.5.8 base
COMO: Saber as diferenças entre passar uma estrutura e passar uma referência de classe
para um método (Guia de programação C#)
Este exemplo mostra que Quando. é passado para um método, uma cópia da estrutura é
passada, mas quando uma Classe instância é passada, uma referência é passada um struct

A saída do exemplo a seguir mostra que somente o valor do campo de classe é alterado quando a
instância de classe é passada para o ClassTaker método. O campo struct, no entanto, não altera,
passando sua instância para o StructTaker método. Isso ocorre porque uma cópia da estrutura é
passada para o StructTaker método, enquanto uma referência para a classe é passada para o
ClassTaker método.
Exemplo
C#
class TheClass { public string willIChange; } struct TheStruct { public string willIChange; } class
TestClassAndStruct { static void ClassTaker(TheClass c) { c.willIChange = "Changed"; } static void
StructTaker(TheStruct s) { s.willIChange = "Changed"; } static void Main() { TheClass testClass = new
TheClass(); TheStruct testStruct = new TheStruct(); testClass.willIChange = "Not Changed";
testStruct.willIChange = "Not Changed"; ClassTaker(testClass); StructTaker(testStruct);
System.Console.WriteLine("Class field = {0}", testClass.willIChange); System.Console.WriteLine("Struct
field = {0}", testStruct.willIChange); } }
Saída
Class field = Changed Struct field = Not Changed
Construtores de instância (Guia de programação C#)

Construtores Instância são usados para criar e inicializar instâncias. O construtor de classe é
invocado quando você criar um novo objeto, por exemplo:
C#
class CoOrds { public int x, y; // constructor public CoOrds() { x = 0; y = 0; } }
Observação
Para maior clareza, essa classe contém membros de dados pública. Essa é uma prática de
programação não recomendada porque ela permite que qualquer método em qualquer lugar em
um programa irrestrito e unverified acesso ao funcionamento interno do objeto. Membros de dados
geralmente deve ser particular, e devem ser acessados apenas por classe métodos e
propriedades.
Esse construtor é chamada sempre que um objeto baseado na classe CoOrds é criado. Um
construtor como esta ocorrência, que tem sem argumentos, é chamada um construtor padrão. No
entanto, geralmente é útil para fornecer construtores adicionais. Por exemplo, que pode adicionar
um construtor para a CoOrds classe que permite que nós para especificar os valores iniciais para
os membros de dados:
C#
// A constructor with two arguments: public CoOrds(int x, int y) { this.x = x; this.y = y; }
Isso permite CoOrd objetos a ser criado com padrão ou específicos valores iniciais, como este:
C#
CoOrds p1 = new CoOrds(); CoOrds p2 = new CoOrds(5, 3);

Se uma classe não tem um construtor padrão, um é gerado automaticamente e valores padrão
serão usados para inicializar os campos de objeto, por exemplo, é inicializada com 0. um Int Para
obter mais informações sobre valores padrão, consulte Tabela de valores padrão (referência C#).
Portanto, porque o CoOrds Construtor padrão de classe inicializa todos os membros de dados
como zero, ele pode ser removido totalmente sem alterar como a classe funciona. Um exemplo
completo usando vários construtores é fornecido no Exemplo 1 posteriormente contidas neste
tópico, e um exemplo de um construtor gerado automaticamente é fornecido no Exemplo 2.
Construtores instância podem ser usados para chamar as construtores da instância de classes
base. O construtor de classe pode chamar o construtor da classe base através do Inicializador, da
seguinte maneira:
C#
class Circle : Shape { public Circle(double radius) : base(radius, 0) { } }
Neste exemplo, os Circle valores passagens de classe representando raio e altura para o
construtor fornecidos por Shape do que Circle é derivado. A concluir exemplo usando Shape e Circle
aparece neste tópico como Exemplo 3.
Exemplo 1
O exemplo a seguir demonstra uma classe com construtores dois classe, uma sem argumentos e
outra com dois argumentos.
C#
class CoOrds { public int x, y; // Default constructor: public CoOrds() { x = 0; y = 0; } // A constructor with
two arguments: public CoOrds(int x, int y) { this.x = x; this.y = y; } // Override the ToString method: public
override string ToString() { return (System.String.Format("({0},{1})", x, y)); } } class MainClass { static void
Main() { CoOrds p1 = new CoOrds(); CoOrds p2 = new CoOrds(5, 3); // Display the results using the
overriden ToString method: System.Console.WriteLine("CoOrds #1 at {0}", p1);
System.Console.WriteLine("CoOrds #2 at {0}", p2); } }
Saída
CoOrds #1 at (0,0)
CoOrds #2 at (5,3)
Exemplo 2
Neste exemplo, a classe Person não tem qualquer construtores, nesse caso, um construtor padrão
é automaticamente fornecida e os campos são inicializados para seus valores padrão.
C#
public class Person { public int age; public string name; } class TestPerson { static void Main() { Person p =
new Person(); System.Console.Write("Name: {0}, Age: {1}", p.name, p.age); } }
Saída
Name: , Age: 0

Observe que é 0 o valor padrão de age e o valor padrão de name é null. Para obter mais
informações sobre valores padrão, consulte Tabela de valores padrão (referência C#).
Exemplo 3
O exemplo a seguir demonstra usando o inicializador de classe base. A Circle classe é derivada da
classe Shape geral, e a Cylinder classe é derivada de classe Circle. O construtor em cada classe
derivada está usando o inicializador de classe base.
C#
abstract class Shape { public const double pi = System.Math.PI; protected double x, y; public Shape(double x,
double y) { this.x = x; this.y = y; } public abstract double Area(); } class Circle : Shape { public Circle(double
radius) : base(radius, 0) { } public override double Area() { return pi * x * x; } } class Cylinder : Circle { public
Cylinder(double radius, double height) : base(radius) { y = height; } public override double Area() { return (2
* base.Area()) + (2 * pi * x * y); } } class TestShapes { static void Main() { double radius = 2.5; double height
= 3.0; Circle ring = new Circle(radius); Cylinder tube = new Cylinder(radius, height);
System.Console.WriteLine("Area of the circle = {0:F2}", ring.Area()); System.Console.WriteLine("Area of the
cylinder = {0:F2}", tube.Area()); } }
Saída
Area of the circle = 19.63
Area of the cylinder = 86.39
Para obter mais exemplos em chamar os construtores de classe base, consulte (referência C#)
virtual, Substituir (referência C#). e base (Referência do C#)
COMO: Declarar e usar propriedades de leitura/escrita (Guia de programação C#)
Propriedades fornecem a praticidade de membros de dados pública sem os riscos que vêm com
Acesso desprotegido, não controlada, e não-verificados aos dados de um objeto. Isso é feito
através de assessores: especiais métodos que atribuir e recuperar valores do membro de dados
subjacente. O Definir acessador permite que membros de dados a ser atribuído, e o Obter
acessador recupera valores Membro de dados.
Este exemplo mostra uma Person classe que tenha duas propriedades: Name. (Seqüência) e Age
(int) Ambas as propriedades fornecem get e set assessores, são considerados para leitura /
gravação propriedades.
Exemplo
C#
class Person { private string m_name = "N/A"; private int m_Age = 0; // Declare a Name property of type
string: public string Name { get { return m_name; } set { m_name = value; } } // Declare an Age property of
type int: public int Age { get { return m_Age; } set { m_Age = value; } } public override string ToString() {
return "Name = " + Name + ", Age = " + Age; } } class TestPerson { static void Main() { // Create a new
Person object: Person person = new Person(); // Print out the name and the age associated with the person:
System.Console.WriteLine("Person details - {0}", person); // Set some values on the person object:
person.Name = "Joe"; person.Age = 99; System.Console.WriteLine("Person details - {0}", person); //
Increment the Age property: person.Age += 1; System.Console.WriteLine("Person details - {0}", person); } }
Saída

Person details - Name = N/A, Age = 0 Person details - Name = Joe, Age = 99 Person details - Name = Joe,
Age = 100
Programação robusta
No exemplo anterior, e Age propriedades são Pública e incluir um get e um set acessador. o Name
Isso permite que qualquer objeto para ler e gravar essas propriedades. Às vezes é desejável,
entretanto, para excluir uma das assessores. Por exemplo, omitir o set acessador, faz a
propriedade somente leitura:
C#
public string Name { get { return m_name; } }
Como alternativa, você pode expor um acessador publicamente mas tornar a outros particular ou
protegido. Para obter mais informações, consulte Acessibilidade Accessor assimétrica.
Depois que as propriedades são declaradas, eles podem ser usados como se fossem campos de
classe. Isso permite para uma sintaxe muito natural quando tanto obtendo e definindo o valor de
uma propriedade, como nas instruções a seguir:
C#
person.Name = "Joe"; person.Age = 99;
Observe que, um método propriedade set uma variável Especial value está disponível. Essa
variável contenha o valor que o usuário especificado, por exemplo:
C#
m_name = value;
Observe a sintaxe limpa de incrementando a Age propriedade em um Person objeto:
C#
person.Age += 1;
Se separado set e get métodos foram usados para modelar propriedades, o código equivalente
pode parecer isso:
person.SetAge(person.GetAge() + 1);
O ToString método for substituído, neste exemplo:
C#
public override string ToString() { return "Name = " + Name + ", Age = " + Age; }
Aviso que ToString não explicitamente é usado no programa. Ele é chamado por padrão, as
WriteLine chamadas.
COMO: Definir propriedades abstratas (Guia de programação C#)
O exemplo a seguir mostra como definir abstrato propriedades. Uma declaração de propriedade
abstract não fornece uma implementação das assessores Propriedade--ele declara que a classe

suporta propriedades, mas deixa a implementação do acessador para classes derivadas. O
exemplo a seguir demonstra como implementar as propriedades herdadas da classe base
abstratas.
Este exemplo consiste três arquivos, cada um deles são compilados individualmente e seu
conjunto resultante é referido pela compilação seguinte:
• abstractshape.cs: a Shape classe que contém uma propriedade abstrata Area.

• Shapes.cs: Os subclasses da classe Shape.
• shapetest.cs:. - um programa de Teste para exibir as áreas de alguns Shape derivado
objetos
Para compilar exemplo, use o seguinte comando:
csc abstractshape.cs shapes.cs shapetest.cs
Isso criará a shapetest.exe arquivo executável.
Exemplo
Este arquivo declara a Shape classe que contém a Area propriedade do tipo double.
C#
// compile with: csc /target:library abstractshape.cs public abstract class Shape { private string m_id; public
Shape(string s) { // calling the set accessor of the Id property. Id = s; } public string Id { get { return m_id; }
set { m_id = value; } } // Area is a read-only property - only a get accessor is needed: public abstract double
Area { get; } public override string ToString() { return Id + " Area = " + string.Format("{0:F2}", Area); } }
• Modificadores sobre a propriedade são colocados na declaração Propriedade próprio. Por

exemplo:
public abstract double Area
• Quando declarar uma propriedade abstrata (tais como Area, neste exemplo), você
simplesmente indicar que assessores Propriedade estão disponíveis, mas não fazer
implementá-las. Neste exemplo, apenas um Obter acessador está disponível, portanto a
propriedade é somente leitura.
O código a seguir mostra as três subclasses da Shape e como elas substituirão a Area propriedade
para fornecer seus próprios implementação.
C#
// compile with: csc /target:library /reference:abstractshape.dll shapes.cs public class Square : Shape {
private int m_side; public Square(int side, string id) : base(id) { m_side = side; } public override double Area
{ get { // Given the side, return the area of a square: return m_side * m_side; } } } public class Circle : Shape
{ private int m_radius; public Circle(int radius, string id) : base(id) { m_radius = radius; } public override
double Area { get { // Given the radius, return the area of a circle: return m_radius * m_radius *
System.Math.PI; } } } public class Rectangle : Shape { private int m_width; private int m_height; public
Rectangle(int width, int height, string id) : base(id) { m_width = width; m_height = height; } public override
double Area { get { // Given the width and height, return the area of a rectangle: return m_width * m_height;
}}}

O código a seguir mostra um programa de teste que cria um número de Shape-derivado objetos e
imprime suas áreas.
C#
// compile with: csc /reference:abstractshape.dll;shapes.dll shapetest.cs class TestClass { static void Main() {
Shape[] shapes = { new Square(5, "Square #1"), new Circle(3, "Circle #1"), new Rectangle( 4, 5, "Rectangle
#1") }; System.Console.WriteLine("Shapes Collection"); foreach (Shape s in shapes) {
System.Console.WriteLine(s); } } }
Saída
Shapes Collection Square #1 Area = 25.00 Circle #1 Area = 28.27 Rectangle #1 Area = 20.00
COMO: Criar um controle que responde a eventos (Guia de programação C#)
A Classe, ListWithChangedEvent, que mostra o exemplo simples a seguir o conteúdo da lista a

alteração é semelhante para a classe padrão ArrayList mas também chama. sempre que um
Changed Evento Tal uma classe de propósito geral pode ser usado de várias maneiras em um
programa grande.
Por exemplo, um processador de texto pode manter uma lista dos documentos abertos. Sempre
que esta alterações da lista, muitos objetos diferentes no Processador de Texto talvez tenha que
ser notificado para que a interface do usuário pode ser atualizada. Usando eventos, o código que
mantém a lista de documentos não precisa saber quem precisa ser notificado — após a lista de
documentos é alterada, o evento é chamado automaticamente e cada objeto que precisa para ser
notificado corretamente é notificado. Usando eventos, a modularidade do programa é aumentada.
Quando criar um componente geral que pode ser usado como uma classe base para outros
componentes, você deve conta para o fato de que eventos, diferentemente de campos, só podem
ser chamados de dentro da classe que declarado-los. Classes derivadas diretamente não é
possível chamar eventos declarados na classe base. Embora esse seja o que for desejado, às
vezes geralmente é apropriado para dar a classe derivada liberdade para chamar o evento. Isso
geralmente é feito criando um método protegido chamado para o evento. Ao chamar esse método
chamado, classes derivadas podem chamar o evento. Para obter ainda mais flexibilidade, o
método chamado geralmente é declarado como virtual, que permite a classe derivada para
substituí-lo. Isso permite que a classe derivada para interceptar os eventos que a classe base é
chamar, possivelmente fazendo seu próprio processamento de-los.
No exemplo a seguir, isso foi feito com o OnChanged método. Uma classe derivada chamar ou
substituir esse método se necessário.
Uma outra diferença entre eventos e campos é que um evento pode ser colocado em uma
interface enquanto não é um campo. Ao implementar a interface, a classe implementação deve
fornecer um evento correspondente na classe que implementa a interface.
Exemplo
C#
namespace TestCollections { // A delegate type for hooking up change notifications. public delegate void
ChangedEventHandler(object sender, System.EventArgs e); // A class that works just like ArrayList, but
sends event // notifications whenever the list changes. public class ListWithChangedEvent :
System.Collections.ArrayList { // An event that clients can use to be notified whenever the // elements of the
list change. public event ChangedEventHandler Changed; // Invoke the Changed event; called whenever list
changes protected virtual void OnChanged(System.EventArgs e) { if (Changed != null) { Changed(this, e); } }

// Override some of the methods that can change the list; // invoke event after each public override int
Add(object value) { int i = base.Add(value); OnChanged(System.EventArgs.Empty); return i; } public
override void Clear() { base.Clear(); OnChanged(System.EventArgs.Empty); } public override object this[int
index] { set { base[index] = value; OnChanged(System.EventArgs.Empty); } } } } namespace TestEvents {
using TestCollections; class EventListener { private ListWithChangedEvent m_list; public
EventListener(ListWithChangedEvent list) { m_list = list; // Add "ListChanged" to the Changed event on
m_list: m_list.Changed += new ChangedEventHandler(ListChanged); } // This will be called whenever the
list changes. private void ListChanged(object sender, System.EventArgs e) { System.Console.WriteLine("This
is called when the event fires."); } public void Detach() { // Detach the event and delete the list
m_list.Changed -= new ChangedEventHandler(ListChanged); m_list = null; } } class Test { // Test the
ListWithChangedEvent class. static void Main() { // Create a new list. ListWithChangedEvent list = new
ListWithChangedEvent(); // Create a class that listens to the list's change event. EventListener listener = new
EventListener(list); // Add and remove items from the list. list.Add("item 1"); list.Clear(); listener.Detach(); }
}}
Saída
This is called when the event fires. This is called when the event fires.
• Declarar um evento
Para declarar um evento dentro uma classe, primeiro um Delegar tipo para o evento deve ser
declarado, se nenhum já está declarado.
C#
public delegate void ChangedEventHandler(object sender, System.EventArgs e);
O tipo delegate define o conjunto de argumentos que são passados para o método que
manipula o evento. Vários eventos podem compartilhar o mesmo tipo delegate, portanto, essa
etapa só é necessária se nenhum tipo delegate adequado já tiver sido declarado.
Em seguida, o evento próprio está declarado.
C#
public event ChangedEventHandler Changed;
Um evento é declarado como um campo de um tipo delegate, exceto que precede a

declaração de evento, seguindo os modificadores palavra-chave Evento. Eventos geralmente
são declarados Pública, mas qualquer modificador de acessibilidade é permitido.
• Chamar um evento
Depois que uma classe tenha declarado um evento, ele pode tratar desse evento exatamente
como um campo do tipo delegate indicado. O campo ou será nulo, se nenhum cliente tiver
conectado um representante para o evento, ou então se refere a um representante que deve
ser chamado quando o evento é chamado. Assim, chamar um evento geralmente isso, primeiro
verificando nulo e depois chamar o evento.
C#
if (Changed != null) { Changed(this, e); }
Chamar um evento só pode ser feito de dentro da classe que declarado o evento.
• Conectando backup a um evento

De fora a classe que declarado-lo, um evento parece um campo, mas acesso a esse campo é
bastante restrito. Somente as coisas que podem ser causadas são Redigir novo representante
para aquele campo, e removendo um representante de um campo (possivelmente composto).
Isso é feito com e -= operadores. o += Para começar a receber chamadas de eventos, código
de cliente primeiro cria um representante do tipo de evento que se refere ao método que deve
ser chamado a partir do evento. Depois ele composes esse representante para qualquer outros
representantes que o evento pode estar conectado ao uso +=.
C#
m_list.Changed += new ChangedEventHandler(ListChanged);
Quando o código do cliente é feito recebimento invocações de eventos, ele remove seu
representante a partir do evento usando operador -=.
C#
m_list.Changed -= new ChangedEventHandler(ListChanged);
COMO: Criar eventos que estejam de acordo com as diretrizes do .NET Framework (Guia de
programação C#)
Permite a linguagem C# para usar qualquer Delegar Tipo, mas o .NET Framework tem mais
estrita diretrizes para representantes e eventos. um Evento Caso você pretenda para o
componente a ser usado com o .NET Framework, você provavelmente será deseja siga estas
diretrizes.
As diretrizes .NET Framework indicar que o tipo delegate usado para um evento deve tomar dois
parâmetros: um Objeto de origem parâmetro que indica a fonte de evento, e um parâmetro
eventos específicos que encapsula qualquer informação adicional sobre o evento. O parâmetro
eventos específicos deve derivar da classe EventArgs. Para eventos que não usam qualquer
informação adicional, o .NET Framework fornece a EventHandler classe.
O exemplo a seguir é como o código em COMO: Criar um controle que responde a eventos (Guia
de programação C#), exceto que esta versão segue as diretrizes .NET Framework.
Exemplo
C#
namespace TestCollections { // A class that works just like ArrayList, but sends event // notifications
whenever the list changes: public class ListWithChangedEvent : System.Collections.ArrayList { // An event
that clients can use to be notified whenever the // elements of the list change: public event
System.EventHandler Changed; // Invoke the Changed event; called whenever list changes: protected virtual
void OnChanged(System.EventArgs e) { if (Changed != null) { Changed(this, e); } } // Override some of the
methods that can change the list; // invoke event after each: public override int Add(object value) { int i =
base.Add(value); OnChanged(System.EventArgs.Empty); return i; } public override void Clear() {
base.Clear(); OnChanged(System.EventArgs.Empty); } public override object this[int index] { set {
base[index] = value; OnChanged(System.EventArgs.Empty); } } } } namespace TestEvents { using
TestCollections; class EventListener { private ListWithChangedEvent m_list; public
EventListener(ListWithChangedEvent list) { m_list = list; // Add "ListChanged" to the Changed event on
m_list: m_list.Changed += new System.EventHandler(ListChanged); } // This will be called whenever the
list changes: private void ListChanged(object sender, System.EventArgs e) { System.Console.WriteLine("This
is called when the event fires."); } public void Detach() { // Detach the event and delete the list:
m_list.Changed -= new System.EventHandler(ListChanged); m_list = null; } } class Test { // Test the

ListWithChangedEvent class: static void Main() { // Create a new list: ListWithChangedEvent list = new
ListWithChangedEvent(); // Create a class that listens to the list's change event: EventListener listener =
new EventListener(list); // Add and remove items from the list: list.Add("item 1"); list.Clear();
listener.Detach(); } } }
Saída
This is called when the event fires. This is called when the event fires.
COMO: Declarar um evento em uma interface e implementá-lo em uma classe (Guia de

programação C#)
Este exemplo mostra que é possível para declarar um Evento. No e implementá-lo em um

Interface um Classe
Exemplo
C#
public delegate void TestDelegate(); // delegate declaration public interface ITestInterface { event
TestDelegate TestEvent; void FireAway(); } public class TestClass : ITestInterface { public event TestDelegate
TestEvent; public void FireAway() { if (TestEvent != null) { TestEvent(); } } } public class MainClass { static
private void F() { System.Console.WriteLine("This is called when the event fires."); } static void Main() {
ITestInterface i = new TestClass(); i.TestEvent += new TestDelegate(F); i.FireAway(); } }
COMO: Usar um dicionário para armazenar instâncias de eventos (Guia de programação C#)
Um uso para accessor-declarations é para expor um grande número de eventos sem alocando
um campo para cada evento, mas em vez disso, usar um dicionário para armazenar as instâncias
de eventos. Só é útil se você tiver um número muito grande de eventos, mas você espera que a
maioria dos eventos não será implementada.
Exemplo
C#
public delegate void Delegate1(int i); public delegate void Delegate2(string s); public class
PropertyEventsSample { private System.Collections.Generic.Dictionary<string, System.Delegate>
eventTable; public PropertyEventsSample() { eventTable = new
System.Collections.Generic.Dictionary<string, System.Delegate>(); eventTable.Add("Event1", null);
eventTable.Add("Event2", null); } public event Delegate1 Event1 { add { eventTable["Event1"] =
(Delegate1)eventTable["Event1"] + value; } remove { eventTable["Event1"] =
(Delegate1)eventTable["Event1"] - value; } } public event Delegate2 Event2 { add { eventTable["Event2"] =
(Delegate2)eventTable["Event2"] + value; } remove { eventTable["Event2"] =
(Delegate2)eventTable["Event2"] - value; } } internal void FireEvent1(int i) { Delegate1 D; if (null != (D =
(Delegate1)eventTable["Event1"])) { D(i); } } internal void FireEvent2(string s) { Delegate2 D; if (null != (D =
(Delegate2)eventTable["Event2"])) { D(s); } } } public class TestClass { public static void
Delegate1Method(int i) { System.Console.WriteLine(i); } public static void Delegate2Method(string s) {
System.Console.WriteLine(s); } static void Main() { PropertyEventsSample p = new
PropertyEventsSample(); p.Event1 += new Delegate1(TestClass.Delegate1Method); p.Event1 += new
Delegate1(TestClass.Delegate1Method); p.Event1 -= new Delegate1(TestClass.Delegate1Method);
p.FireEvent1(2); p.Event2 += new Delegate2(TestClass.Delegate2Method); p.Event2 += new

Delegate2(TestClass.Delegate2Method); p.Event2 -= new Delegate2(TestClass.Delegate2Method);
p.FireEvent2("TestString"); } }
Saída
2 TestString
COMO: Implementar duas interfaces que possuam um evento com o mesmo nome (Guia de
programação C#)
Outro uso para Evento Propriedades aborda a situação onde você estiver implementando duas
interfaces, cada um com um evento com o mesmo nome. Nesse caso, você deve usar uma
propriedade de evento explicitamente de implementação.
No entanto, ao explicitamente implementar eventos na interface, você precisará fornecer adicionar

e remover métodos.
Exemplo
C#
public delegate void Delegate1(); public delegate int Delegate2(string s); public interface I1 { event Delegate1
TestEvent; } public interface I2 { event Delegate2 TestEvent; } public class ExplicitEventsSample : I1, I2 {
public event Delegate1 TestEvent; // normal implementation of I1.TestEvent. private Delegate2
TestEvent2Storage; // underlying storage for I2.TestEvent. event Delegate2 I2.TestEvent // explicit
implementation of I2.TestEvent. { add { TestEvent2Storage += value; } remove { TestEvent2Storage -=
value; } } private void FireEvents() { if (TestEvent != null) { TestEvent(); } if (TestEvent2Storage != null) {
TestEvent2Storage("hello"); } } }
COMO: Criar manipuladores de evento no Visual C# Code Editor (Guia de programação C#)
O Editor de Código Visual C# oferece uma maneira fácil de criar manipuladores de eventos para o
Windows Forms enquanto trabalha no modo Design. A alternativa é exibir o código fonte no modo
de exibição Source e adicionar o manipulador de eventos no código.
Observação
Visual Studio configurações.
Para criar um manipulador de eventos usando o Editor de Código Visual C#

1. Se clique com o botão direito do mouse no formulário ou controle para o qual você deseja
criar um manipulador de eventos, e selecione Properties. não estiver visível, no modo
Design, o Properties Window
2. Na parte superior da Properties Window, clique no botão Events.
3. Clique duas vezes no evento que você deseja criar, por exemplo o evento Load.
Visual C# Cria um método do manipulador de evento vazio e adiciona-o para o seu código.
Como alternativa você pode adicionar o código em mãos no modo de exibição de código.
Por exemplo as seguintes linhas de código declarar um manipulador de eventos de carga
para uma Form classe chamada Form1.

C#
private void Form1_Load(object sender, System.EventArgs e) { // Add your form load event handling
code here. }
COMO: Implementar explicitamente membros de uma interface (Guia de programação C#)
Este exemplo declara um Interface, IDimensions, e uma classe, Box., explicitamente que
implementa os membros getLength de interface e getWidth Os membros são acessados através a
instância dimensions interface.
Exemplo
C#
interface IDimensions { float getLength(); float getWidth(); } class Box : IDimensions { float lengthInches;
float widthInches; Box(float length, float width) { lengthInches = length; widthInches = width; } // Explicit
interface member implementation: float IDimensions.getLength() { return lengthInches; } // Explicit
interface member implementation: float IDimensions.getWidth() { return widthInches; } static void Main() {
// Declare a class instance box1: Box box1 = new Box(30.0f, 20.0f); // Declare an interface instance
dimensions: IDimensions dimensions = (IDimensions)box1; // The following commented lines would
produce compilation // errors because they try to access an explicitly implemented // interface member from
a class instance: //System.Console.WriteLine("Length: {0}", box1.getlength());
//System.Console.WriteLine("Width: {0}", box1.getwidth()); // Print out the dimensions of the box by
calling the methods // from an instance of the interface: System.Console.WriteLine("Length: {0}",
dimensions.getLength()); System.Console.WriteLine("Width: {0}", dimensions.getWidth()); } }
Saída
Length: 30 Width: 20
• Observe que as seguintes linhas no método Main, e são comentadas porque eles
produziria erros de compilação. Um membro de interface que é implementado explicitamente
não pode ser acessado de uma Classe instância:
C#
//System.Console.WriteLine("Length: {0}", box1.getlength()); //System.Console.WriteLine("Width: {0}",
box1.getwidth());
• Observe também que as seguintes linhas no método Main, e com êxito imprima as
dimensões da caixa porque os métodos estão sendo chamados de uma instância da interface:
C#
System.Console.WriteLine("Length: {0}", dimensions.getLength()); System.Console.WriteLine("Width:
{0}", dimensions.getWidth());
COMO: Implementar explicitamente membros de uma interface com herança (Guia de

programação C#)
Implementação explícita Interface também permite que o programador para implementar duas
interfaces que têm os mesmos nomes membro e concedidos aos membros interface uma
implementação separada. Este exemplo exibe as dimensões de uma caixa na métrica e unidades
em inglês. As Box Classe interfaces IEnglishDimensions implementa dois e IMetricDimensions, que

representam os sistemas de medida diferente. As duas interfaces ter nomes idênticos membro,
Length e Width.
Exemplo
C#
// Declare the English units interface: interface IEnglishDimensions { float Length(); float Width(); } //
Declare the metric units interface: interface IMetricDimensions { float Length(); float Width(); } // Declare
the Box class that implements the two interfaces: // IEnglishDimensions and IMetricDimensions: class Box :
IEnglishDimensions, IMetricDimensions { float lengthInches; float widthInches; public Box(float length,
float width) { lengthInches = length; widthInches = width; } // Explicitly implement the members of
IEnglishDimensions: float IEnglishDimensions.Length() { return lengthInches; } float
IEnglishDimensions.Width() { return widthInches; } // Explicitly implement the members of
IMetricDimensions: float IMetricDimensions.Length() { return lengthInches * 2.54f; } float
IMetricDimensions.Width() { return widthInches * 2.54f; } static void Main() { // Declare a class instance
box1: Box box1 = new Box(30.0f, 20.0f); // Declare an instance of the English units interface:
IEnglishDimensions eDimensions = (IEnglishDimensions)box1; // Declare an instance of the metric units
interface: IMetricDimensions mDimensions = (IMetricDimensions)box1; // Print dimensions in English
units: System.Console.WriteLine("Length(in): {0}", eDimensions.Length());
System.Console.WriteLine("Width (in): {0}", eDimensions.Width()); // Print dimensions in metric units:
System.Console.WriteLine("Length(cm): {0}", mDimensions.Length()); System.Console.WriteLine("Width
(cm): {0}", mDimensions.Width()); } }
Saída
Length(in): 30 Width (in): 20 Length(cm): 76.2 Width (cm): 50.8
Se você desejar tornar as medidas padrão em inglês unidades, implementar os métodos Length e
Width Normalmente, e explicitamente implementar os métodos Comprimento e Largura da
interface IMetricDimensions:
C#
// Normal implementation: public float Length() { return lengthInches; } public float Width() { return
widthInches; } // Explicit implementation: float IMetricDimensions.Length() { return lengthInches * 2.54f; }
float IMetricDimensions.Width() { return widthInches * 2.54f; }
Nesse caso, você pode acessar as unidades inglês da instância de classe e acessar as unidades
métrica de interface a instância:
C#
public static void Test() { Box box1 = new Box(30.0f, 20.0f); IMetricDimensions mDimensions =
(IMetricDimensions)box1; System.Console.WriteLine("Length(in): {0}", box1.Length());
System.Console.WriteLine("Width (in): {0}", box1.Width()); System.Console.WriteLine("Length(cm): {0}",
mDimensions.Length()); System.Console.WriteLine("Width (cm): {0}", mDimensions.Width()); }

Classes genéricas no .NET Framework
Generics permitem que você personalizar um método, classe, estrutura ou interface para o tipo de
dados precisa Ele age sobre. Por exemplo, em vez de usar a Hashtable classe, que permite
chaves e valores sejam de qualquer tipo, você pode usar a Dictionary classe genérico e
especifique o tipo permitido para a chave e o tipo permitido para o valor. Entre os benefícios da
generics estão código maior segurança reutilização e tipo.
Do System.Collections.Generic um número de classes a coleção genérica é fornecido no .NET

Framework, no e System.Collections.ObjectModel espaços de nome. Genéricos interfaces para
implementar comparações classificar e igualdade são fornecidos no espaço para nome System,
juntamente com tipos de representante genérico para manipuladores de eventos, conversões e
predicados da pesquisa.
Suporte para generics foi adicionada ao System.Reflection para examinar tipos genéricos e
métodos genéricos para System.Reflection.Emit para emissor dinâmico conjuntos que contêm
tipos genéricos e métodos, e para System.CodeDOM para gerar origem Graphs que incluem
generics.
Visual Basic, C#, e Visual C++ fornecem suporte completo para definir e usar tipos genéricos. O
Common Language Runtime fornece nova operação 8087 e prefixos para oferecer suporte aos
tipos genéricos no Microsoft (MSIL) linguagem intermediária.
Visão geral sobre Generics no .NET Framework

Este tópico fornece uma visão geral sobre os seguintes recursos de generics no .NET Framework
e o Common Language Runtime:
• Um resumo de tipos genéricos e métodos e a terminologia para falar sobre eles.

• Do System.Collections.Generic a coleção genérica classes no e
System.Collections.ObjectModel espaços de nome.
• Outros tipos genéricos.
• Genéricos representantes de conversões, predicados de pesquisa, e ações devem ser
feitos em elementos de uma matriz ou coleção.
• Genéricos interfaces para fornecer funcionalidade Common de famílias de tipos genéricos.
O que são Generics, e como eles são usados e definido?
Generics são classes, estruturas, interfaces, e métodos que possuem espaços reservados
(parâmetros tipo) para uma ou mais dos tipos que armazenar ou usar. Uma classe a coleção
genérica pode utilizar um parâmetro tipo como espaço reservado para o tipo de objetos que ele
armazena; os parâmetros tipo aparecem como os tipos de seus campos, e os tipos de parâmetro
de seus métodos. Um método genérico pode usar seu parâmetro tipo como o tipo de seu valor de
retorno, ou como o tipo de um dos seus parâmetros formais. O código a seguir ilustra uma
definição de classe genérico simples.
C#
public class Generic<T> { public T Field; }
Quando você cria uma instância de uma classe genérico, você especificar os tipos reais para
substituir para os parâmetros tipo. Isso estabelece uma nova classe genérico, conhecido como
uma classe genérico construído, com seus tipos substituídos em todos os lugares que aparecem

os parâmetros tipo escolhidos. O resultado é uma classe Safe tipo-adequado para sua escolha de
tipos, como o código a seguir ilustra.
C#
Generic<string> g = new Generic<string>(); g.Field = "A string";
Os seguintes termos são usados para falar sobre generics no .NET Framework:
• A Definição de tipo genérico é uma classe, estrutura, ou declaração interface que funciona
como um modelo, com espaços reservados para os tipos-pode conter ou usar. Por exemplo, a
Dictionary classe pode conter dois tipos: chaves e valores. Porque ele é apenas um modelo,
você não pode criar instâncias de uma classe, estrutura ou interface que é uma definição de
tipo genérico.
• Parâmetros tipo genérico ou Parâmetros tipo, são espaços reservados em uma definição
tipo ou método genérico. O Dictionary tipo genérico tem dois parâmetros Tipo, TKey e
TValue, que representa os tipos de suas chaves e valores.
• A Construído tipo genérico, ou Tipo construído, é o resultado da especificando tipos para
os parâmetros tipo genérico de uma definição de tipo genérico.
• A Argumento tipo genérico é qualquer tipo que é substituído para um parâmetro tipo
genérico.
• O termo geral " tipo genérico " inclui os construído tipos e definições tipo genérico.
• limites são Restrições colocados em parâmetros tipo genérico. Por exemplo, você pode
limitar um parâmetro tipo para tipos que implementam a IComparer interface genérica, para
garantir que instâncias do tipo podem ser pedidas. Você também pode restringir parâmetros
tipo para tipos que tenham uma classe base específico, que tem um construtor padrão, ou que
são tipos de referência ou tipos de valores. Usuários do tipo genérico não podem substituir
argumentos tipo que não faça satisfazer as restrições.
• A definição Método genérico é um método com duas listas de parâmetro: uma lista de
parâmetros tipo genérico, e uma lista de parâmetros formais. Parâmetros tipo podem aparecer
como o tipo de retorno ou como os tipos de parâmetros formais, como no código a seguir.
C#
T Generic<T>(T arg) { T temp = arg; ...}
Métodos genéricos podem aparecer em tipos genéricos ou nongeneric. É importante para

Observe que um método é não genérico apenas porque ele pertence a um tipo genérico, ou
mesmo porque tem parâmetros formais cujos tipos são os parâmetros do tipo delimitador
genéricos. Um método é somente se tiver sua própria lista de parâmetros tipo genérico. No
código a seguir, único método G é genérico.
C#
class A { T G<T>(T arg) {...} } class Generic<T> { T M(T arg) {...} }
Visual C++, C#, e Visual Basic todos os fornecem suporte completo para definir e consumindo
generics. Para obter mais informações, consulte Tipos genérics no Visual Basic, Introdução ao
Generics (guia de programação C#). e Overview of Generics in C++
Tipos e Generics aninhadas
Um tipo aninhado em um tipo genérico pode depender os parâmetros os tipo de delimitador o tipo
genérico, e esses tipos aninhados são considerados genéricos pelo tempo de execução de idioma
comum, mesmo que eles não tenham parâmetros tipo genérico de seus próprios. Quando você

cria uma instância de um tipo aninhado, é necessário para especificar argumentos Tipo para todos
os delimitador tipos genéricos.
Genéricas coleções no .NET Framework
Do System.Collections.Generic um número de classes a coleção genérica é fornecido na

biblioteca de classe do .NET Framework, no e System.Collections.ObjectModel espaços de
nome. Para obter mais informações sobre essas classes, consulte Comumente usados tipos da
coleção.
System.Collections.Generic
Muitos dos tipos a coleção genérica são diretas analogs dos tipos nongeneric. é Dictionary uma
versão genérica do Hashtable; ele utiliza a estrutura KeyValuePair genérica para enumeração, em
vez de DictionaryEntry.
é List uma versão do ArrayList genérico. Não há genérico Queue e Stack Classes correspondente
às versões nongeneric.
Existem versões genérico e nongeneric do SortedList, ambos os quais são híbridas entre um
dicionário e uma lista, e que têm características de desempenho semelhante. A SortedDictionary
classe genérico é um dicionário que oferece características de desempenho diferente, e que
possui nenhum contraparte nongeneric puro.
A LinkedList classe genérico é uma lista vinculada verdadeira. Não tem nenhum contraparte
nongeneric.
System.Collections.ObjectModel
A Collection classe genérico oferece uma classe base para derivar seus próprios tipos a coleção
genérica. A ReadOnlyCollection classe fornece uma maneira fácil de produzir uma coleção
somente leitura de qualquer tipo que implementa a IList interface genérico. A KeyedCollection
classe genérica oferece uma maneira para armazenar objetos que contêm suas próprias chaves.
Outros tipos genérico
A Nullable estrutura genérica, você pode usar tipos valor como se eles pode ser atribuídos null.
Isso pode ser útil ao trabalhar com consultas de banco de dados, onde campos que contêm tipos
de valor podem ser ausentes. O parâmetro tipo genérico pode ser qualquer tipo de valor.
Observação
Em C# não é necessário para usar Nullable explicitamente, porque o idioma tem sintaxe para
tipos anuláveis.
A ArraySegment estrutura genérica oferece uma maneira para delimitar um intervalo de elementos
em uma matriz unidimensional, baseada em zero de qualquer tipo. O parâmetro tipo genérico é o
tipo de elementos da matriz na.
O EventHandler representante genérico elimina a necessidade para declarar um tipo delegate

para manipular eventos se o evento segue o padrão tratamento de eventos-usado pelo .NET
Framework. Por exemplo, suponha que você tiver criado uma MyEventArgs classe, derivado de

EventArgs, para manter os dados para o evento. Então você pode declarar o evento da seguinte
maneira:
C#
public event EventHandler<MyEventArgs> MyEvent;
Representantes genéricos para Manipulating matrizes e listas
O Action representante genérico representa um método que efetua alguma ação em um elemento
do tipo especificado. Você pode criar um método que executa a ação desejada no elemento,
criamos uma instância do representante Action para representar esse método, e depois passar a
matriz e o representante para o System.Array.ForEach.Action{ método estático genérico O método
é chamado para cada elemento da matriz.
A List classe genérica também oferece um ForEach método que usa o Action representante.
Esse método é não genérico.
Observação
Isso torna um ponto interessante sobre tipos genéricos e métodos. O

System.Array.ForEach.Action{ método deve ser estático (Shared. porque Array) e genérico no
Visual Basic não é um tipo genérico; o único motivo você pode especificar um tipo para
System.Array.ForEach.Action{ para operar em é que o método possui sua própria lista de
Parâmetro tipo Por outro lado, o método nongeneric
System.Collections.Generic.List.ForEach(System.Action{ pertence à classe List genérico,
para ele simplesmente utiliza o parâmetro Tipo de sua classe. A classe altamente for digitada,
portanto, o método pode ser um método de instância.
O Predicate representante genérico representa um método que determina se um determinado

elemento atende critérios você definir. Poderá usá-lo com os seguintes métodos estáticos
genéricos de Array para procurar por um elemento ou um conjunto de elementos: Exists.,
FindLastFindIndex, FindAllFind, FindLastIndex e TrueForAll
Também Predicate funciona com os métodos correspondentes nongeneric da instância da classe

List genérico.
O Comparison representante genérico permite que você para fornecer uma ordem de
classificação de matriz ou lista elementos que não têm uma ordem de classificação nativo, ou para
substituir a ordem de classificação nativo. Criar um método que executa a comparação, criar uma
instância do representante Comparison para representar o método, e depois passar a matriz e o
representante para o System.Array.Sort.Comparison{ método genérico estático. A List classe
genérico oferece uma sobrecarga método da instância correspondente,
System.Collections.Generic.List.Sort(System.Comparison{.
O Converter representante genérico permite que você para definir uma conversão entre dois tipos,
e para converter uma matriz de um tipo em uma matriz de outro, ou para converter uma lista de
um tipo em uma lista do outro. Criar um método que converte os elementos de lista existente para
um novo tipo, criar uma instância delegado para representar o método, e use o
System.Array.ConvertAll.Converter{ método estático genérico para produzir uma matriz do novo
tipo da matriz original, ou o System.Collections.Generic.List.ConvertAll.Converter{ método da
instância genérico para produzir uma lista do novo tipo a partir da lista original.

O encadeamento representantes
Muitos dos métodos que usam esses representantes retornar uma matriz ou lista, que pode ser
passada para outro método. Por exemplo, se você desejar selecionar determinados elementos de
uma matriz, converter esses elementos para um novo tipo, e salvá-las em uma nova matriz, você
pode passar a matriz retornada pelo método FindAll genérico para o ConvertAll método
genérico. Se o novo tipo elemento possui uma ordem de classificação natural, você poderá passar
a matriz retornada pelo método ConvertAll genérico para o Sort método genérico.
Interfaces genérico
Interfaces genéricos fornecem contrapartes Safe tipo-a nongeneric interfaces para Ordem e
igualdade comparações e para funcionalidade compartilhado por tipos a coleção genérica.
Igualdade e classificação Comparisons
Do System.IComparable no espaço para nome System, e System.IEquatable genéricos interfaces,

como suas contrapartes nongeneric, definir métodos para ordenar comparações e comparações
de igualdade, respectivamente. Tipos implementar essas interfaces para fornecer a capacidade de
executar tais comparações.
No espaço para nome System.Collections.Generic, ou System.IEquatable interface genérica e

eles fornecem uma maneira para redefinir os relacionamentos de tipos que fazem. e
IEqualityComparer Definir uma comparação ordenação ou igualdade para tipos que não
implementam oferta interfaces genérico uma maneira o IComparer o System.IComparable Essas
interfaces são usados por métodos e construtores de muitas das classes a coleção genérica. Por
exemplo, você pode passar um genérica IComparer para o construtor da classe
SortedDictionary para especificar uma ordem de classificação para um tipo que não implementa
genérico System.IComparable. Existem overloads do System.Array.Sort método estático
genérico e o System.Collections.Generic.List.Sort(System.Collections.Generic.IComparer{ método
da instância para classificação matriz e lista usando implementações genéricas IComparer.
O Comparer e também fornecem comparações ordem e igualdade padrão por seus respectivas
System.Collections.Generic.Comparer.Default e
System.Collections.Generic.EqualityComparer.Default Propriedades. e EqualityComparer Classes
genéricos fornecem classes básicas para implementações de e IEqualityComparer Interfaces
genéricos, o IComparer
Funcionalidade coleção
A ICollection interface genérica é a interface para a coleção genérica tipos básico. Fornece
funcionalidade básica para adicionar, remover, copiar, e enumerar elementos. Herda ICollection
da genérico IEnumerable e nongeneric IEnumerable.
A IList interface genérica estende a ICollection interface genérica com métodos para
recuperação indexado.
A IDictionary interface genérica estende a ICollection interface genérica com métodos para
recuperação com chave. Tipos do Dicionário genérico na biblioteca de classes base do .NET
Framework também implementam a interface nongeneric IDictionary.
A IEnumerable interface genérico oferece uma estrutura de enumerador genérico. A IEnumerator

interface implementada por enumeradores genéricos genérico herda a interface nongeneric
IEnumerator, e MoveNext. e Reset membros, que não faça depender o parâmetro T de tipo,
aparecem apenas em uma interface nongeneric Isso significa que qualquer consumidor sobre a
interface nongeneric também pode consumir a interface genérica.

Limitações de Generics
A seguir estão algumas limitações de generics no .NET Framework versão 2.0:
• Tipos genéricos podem ser derivados da maioria das classes base, como
MarshalByRefObject (e restrições podem ser usadas para exigir que parâmetros tipo genérico
derivar de classes base como MarshalByRefObject),. mas nesta versão não há suporte para
tipos genéricos vinculados contexto- Um tipo genérico pode ser derivado de
ContextBoundObject, mas ao tentar criar uma instância do que digitar causas. um
TypeLoadException
• Enumerações não podem ter parâmetros tipo genérico. Uma enumeração pode ser
genérica somente por acaso, por exemplo porque ele estiver aninhado em um tipo genérico
definido com Visual Basic, C#, ou C++. Para obter mais informações, consulte Enumerações
no CTS (Common Type System).
• Leve métodos dinâmicos não podem ser genéricos. Para obter mais informações sobre
métodos dinâmicos, consulte Reflexo Emit dinâmico cenários método.
• No Visual Basic, C# e C++ um tipo aninhado entre um tipo genérico não pode ser
instanciado a menos que tipos tiverem sido atribuídos aos parâmetros os tipo de todos os tipos
de inclusão. Outra maneira de dizer isso é que no reflexo, um tipo aninhado definido usando
esses idiomas inclui os parâmetros os tipo de todos os seus tipos delimitador. Isso permite que
os parâmetros os Tipo do colocando tipos a ser usado nas definições as membro de um tipo
aninhado. Para obter mais informações, consulte " Tipos Nested " no MakeGenericType.
Observação
Um tipo aninhado que é definido pelo emissor código em um conjunto dinâmico ou usando
parâmetros do seu colocando tipos; entretanto, se não tiver depois os parâmetros tipo são não no
escopo na classe aninhada. Não é necessário para incluir o tipo a Assembler MSIL (Ilasm.exe)
• Para obter mais informações, consulte " Tipos Nested " no MakeGenericType.
Vantagens de Generics
Permitindo que você para especificar os tipos específicos acionados por uma classe genérico ou
método, o recurso generics desloca a sobrecarga de segurança de tipos de você para o
compilador. Não é necessário ao gravar código para teste para o tipo de dados correto, porque ele
é imposto em tempo de compilação. A necessidade de diretores tipo e a possibilidade de erros em
tempo de execução são reduzidas.
Generics fornecem segurança tipo sem a sobrecarga de várias implementações. Por exemplo, crie
uma lista vinculada de seqüências com a seguinte declaração de variável:
C#
LinkedList<string> llist = new LinkedList<string>();
Não é necessário para herdar de um tipo base e substituem membros. A lista vinculada está
pronta para uso imediato. Consulte System.Collections.Generic e System.Collections.ObjectModel
para os tipos a coleção genérica fornecidos pelo .NET Framework.
Além de segurança de tipo, tipos a coleção genérica geralmente executar melhor para armazenar
e manipular tipos valor porque não há há necessidade de caixa os tipos valor.

Representantes genéricos Ativar retornos de chamada Segurança tipo-sem a necessidade para
criar representante várias classes. Por exemplo, o Predicate representante genérico permite que
você a criar um método que implementa seu próprio critérios para um tipo específico e a usar o
método com métodos do tipo Array, como Find, FindLast,. e FindAll
Representantes genéricos também podem ser usados no código gerado dinamicamente sem
exigir a geração de um tipo delegate. Isso aumenta o número de cenários em que você pode usar
Lightweight métodos dinâmicos em vez de gerar conjuntos todos. Para obter mais informações,
consulte Como Definir e Executar Métodos Dinâmicos e DynamicMethod.
Em muitos casos, o Visual Basic, Visual C++ e compiladores C# são capazes de determinação do
contexto os tipos usados por uma chamada de método genérico, bastante simplificando a sintaxe
para usar métodos genéricos. Por exemplo, o código a seguir mostra os formulários de chamar o
BinarySearch método para pesquisar uma matriz de seqüências genérico curto e longo. No
formulário curto, os compiladores inferir o parâmetro tipo correto dos tipos de argumentos do
método.
C#
int index = Array.BinarySearch(myArray, "test string"); int index = Array.BinarySearch<string>(myArray,
"test string");
A palavra-chave default em código fonte "genérico" (Guia de

programação C#)
No genéricos classes e métodos, um problema que surge é como atribuir um valor padrão a um
tipo parametrizado T quando você não faça sabe o seguinte antecedência:
• Se T será um tipo de referência ou um tipo de valor.

• Se T for um tipo de valor, se ele será um valor numérico ou uma estrutura.
Fornecido uma variável t de um tipo parametrizado T, a instrução t =. Se T é um tipo de referência

e t = trabalho somente será 0 para tipos valor numérico mas não para estruturas nulo só é válido
A solução é para usar a default palavra-chave, que retornará nula para tipos de referência e zero
para tipos valor numérico. Para estruturas, ele retornará cada membro da estrutura inicializada
com zero ou nulo dependendo se eles são tipos valor ou referência. O exemplo a partir da
GenericList<T> classe a seguir mostra como usar a default palavra-chave. Para obter mais
informações, consulte Visão geral generics.
C#
public class GenericList<T> { private class Node { //... public Node Next; public T Data; } private Node head;
//... public T GetNext() { T temp = default(T); Node current = head; if (current != null) { temp =
current.Data; current = current.Next; } return temp; } }
Métodos genérico (Guia de programação C#)

Um método genérico é um método que está declarado com parâmetros Tipo, da seguinte maneira:
C#
static void Swap<T>(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }

O exemplo de código a seguir mostra uma maneira de chamar o método, usando Int para o
argumento Tipo:
C#
public static void TestSwap() { int a = 1; int b = 2; Swap<int>(ref a, ref b); System.Console.WriteLine(a + " "
+ b); }
Você também pode omitir o argumento Tipo e o compilador deduzirá-lo. A chamada para permutar
a seguir é equivalente como a chamada anterior:
C#
Swap(ref a, ref b);
As mesmas regras para a inferência tipo se aplicam a métodos estáticos, bem como métodos da
instância. O compilador é capaz de inferir os parâmetros tipo com base em argumentos do método
você passar na; ele não pode inferir os parâmetros tipo somente de uma restrição ou retornar
valor. Portanto, a inferência tipo não funciona com os métodos que possuem sem parâmetros.
Ocorre a inferência tipo em tempo de compilação antes o compilador tenta se resolver nenhuma
assinatura método sobrecarregado. Se o compilador aplica lógica a inferência tipo a todos os
métodos que compartilham o mesmo nome genéricos. Na etapa de resolução de sobrecarga, o
compilador inclui apenas esses métodos genéricos no qual a inferência tipo êxito.
Em uma classe genérico, métodos não-Generic podem acessar os parâmetros tipo nível de
classe, da seguinte maneira:
C#
class SampleClass<T> { void Swap(ref T lhs, ref T rhs) { } }
Se você definir um método genérico que leva os mesmos parâmetros tipo como a classe que
contém o compilador irá gerar aviso CS0693 porque dentro do escopo método, o argumento
fornecido para o T interna ocultará o argumento fornecido para o T. externa Se você exigir a
flexibilidade de chamar um método de classe genérico com argumentos Tipo diferente aquelas
fornecidas quando a classe foi instanciada, considere fornecer outro identificador para do método
Parâmetro tipo, como mostrado GenericList2<T> no exemplo a seguir.
C#
class GenericList<T> { // CS0693 void SampleMethod<T>() { } } class GenericList2<T> { //No warning void
SampleMethod<U>() { } }
Utilizar restrições para ativar operações mais especializadas em parâmetros tipo nos métodos.
Esta versão do Swap<T>, agora chamado SwapIfGreater<T>, somente pode ser usada com
argumentos Tipo que implementam IComparable<T>.
C#
void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T> { T temp; if
(lhs.CompareTo(rhs) > 0) { temp = lhs; lhs = rhs; rhs = temp; } }
Métodos genéricos podem ser sobrecarregados em um número de parâmetros tipo. Por exemplo,
os seguintes métodos podem todos existir na mesma classe:
C#

void DoWork() { } void DoWork<T>() { } void DoWork<T, U>() { }
• A inferência 20.6.4 de argumentos Tipo.

Restrições em parâmetros de tipo (Guia de programação C#)
Quando você define uma classe genérico, você pode aplicar restrições para os tipos de tipos que
código de cliente pode usar para argumentos Tipo quando ele instancia sua classe. Se Código do
cliente tentar criar a classe com um tipo que não é permitido por uma restrição, o resultado é um
erro em tempo de compilação. Essas restrições são chamadas restrições. Restrições são
especificadas usando a where palavra-chave contextual. A tabela a seguir lista os tipos de
restrições seis:
Restrição Descrição
Onde struct T: O argumento Tipo deve ser um tipo de valor. Qualquer tipo de valor exceto
Nullable pode ser especificado. Consulte Usando tipos Nullable (C#
programação guia) Para obter mais informações.
Onde: classe T O argumento Tipo deve ser um tipo de referência, incluindo qualquer classe,
interface, representante, ou tipo de matriz.
Onde: New() T O argumento Tipo deve ter um construtor sem parâmetros público. Quando
usado em conjunto com outras restrições, a new() restrição deve ser
especificada pela última vez.
where T : <base O argumento Tipo deve ser ou derivar de classe base especificada.
class name>
where T : O argumento Tipo deve ser ou implementam a interface especificada. Várias
<interface restrições interface podem ser especificadas. A interface restrições também
name> pode ser genérica.
Onde: U T O argumento Tipo fornecido para T deve ser ou derivar do argumento fornecido
para u. Isso é chamado uma restrição tipo naked.
Por que usar restrições
Se você desejar examinar um item em uma lista genérica para determinar se ele é válido ou para
compará-lo para algum outro item, o compilador deve ter alguns garante que o operador ou
método que ele precisa para chamar terá suporte por qualquer argumento tipo que pode ser
especificado pelo código do cliente. ESTA GARANTIA é obtida ao aplicar uma ou mais restrições
para a definição de classe genérico. Por exemplo, a restrição classe base informa o compilador
que somente objetos desse tipo ou derivado desse tipo será usado como argumentos Tipo.
Quando o compilador tem esta garantia, ela pode permitir que métodos desse tipo a ser chamado
dentro da classe genérico. Restrições são aplicadas usando a palavra-chave where contextual. O
exemplo de código a seguir demonstra a funcionalidade que pode adicionar para a GenericList<T>
classe (in Introdução ao Generics (guia de programação C#)), aplicando uma restrição classe
base.
C#
public class Employee { private string name; private int id; public Employee(string s, int i) { name = s; id = i;
} public string Name { get { return name; } set { name = value; } } public int ID { get { return id; } set { id =
value; } } } public class GenericList<T> where T : Employee { private class Node { private Node next; private

T data; public Node(T t) { next = null; data = t; } public Node Next { get { return next; } set { next = value; } }
public T Data { get { return data; } set { data = value; } } } private Node head; public GenericList()
//constructor { head = null; } public void AddHead(T t) { Node n = new Node(t); n.Next = head; head = n; }
public IEnumerator<T> GetEnumerator() { Node current = head; while (current != null) { yield return
current.Data; current = current.Next; } } public T FindFirstOccurrence(string s) { Node current = head; T t =
null; while (current != null) { //The constraint enables access to the Name property. if (current.Data.Name
== s) { t = current.Data; break; } else { current = current.Next; } } return t; } }
A restrição permite que a classe genérica para utilizar a Employee.Name propriedade desde todos
os itens do tipo T são garantidas como um Employee objeto ou um objeto herdeira de Employee.
Várias restrições podem ser aplicadas para o mesmo parâmetro, tipo e as restrições próprios
podem ser tipos genéricos, da seguinte forma:
C#
class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new() { // ... }
Restringindo o parâmetro de tipo, você aumentar o número de operações permitidas e chamadas

de método aos quais o tipo de restrições e todos os tipos na sua hierarquia de herança. Portanto,
ao criar classes genéricos ou métodos, se você vai ser executando qualquer operação nos
membros genéricos além atribuição simples ou chamar qualquer método não ofereçam suporte
System.Object, você precisará aplicar restrições para o parâmetro tipo.
Ao aplicar a where T : class restrição, é recomendável que você não faça use porque esses
operadores testará para identidade de referência apenas, não para igualdade VALOR. e !=
operadores sobre o parâmetro tipo a == Esse é o caso mesmo se esses operadores são
sobrecarregados em um tipo usado como um argumento. O código a seguir ilustra este ponto; a
saída é false, embora a String classe overloads o == operador.
C#
public static void OpTest<T>(T s, T t) where T : class { System.Console.WriteLine(s == t); } static void
Main() { string s1 = "foo"; System.Text.StringBuilder sb = new System.Text.StringBuilder("foo"); string s2 =
sb.ToString(); OpTest<string>(s1, s2); }
A razão para esse comportamento é que, ao tempo de compilação, o compilador somente sabe
que T é um tipo de referência, e portanto deve utilizar os operadores padrão que são válidos para
todos os tipos de referência. Se você precisar testar a igualdade valor, a maneira recomendada é
para também aplicar a where T : IComparable<T> restrição e implementar a interface em qualquer
classe que será usado para construir a classe genérica.
Unbounded parâmetros tipo
Parâmetros tipo que têm sem restrições, como T na classe SampleClass<T>{} pública, são
chamados parâmetros tipo unbounded. Parâmetros tipo unbounded ter as seguintes regras:
• O != e == operadores não podem ser usados porque não há nenhuma garantia que o
argumento Tipo concreto oferecerá suporte esses operadores.
• Eles podem ser convertidos de e para System.Object ou explicitamente convertido em
qualquer tipo de interface.
• Você pode comparar para Nulo. Se um parâmetro unbounded é comparado com null, a
comparação sempre retornará FALSE se o argumento Tipo é um tipo de valor.

Naked restrições tipo
Quando um parâmetro tipo genérico é usado como uma restrição, ela é chamada uma restrição
tipo naked. Restrições tipo naked são úteis quando uma função membro com seu próprio
Parâmetro tipo precisa restringir que parâmetro para o parâmetro tipo do tipo recipiente, como
mostrado no exemplo a seguir:
C#
class List<T> { void Add<U>(List<U> items) where U : T {/*...*/} }
No exemplo anterior, T é uma restrição naked tipo em um contexto do Add método, e um

parâmetro tipo unbounded em um contexto de classe List.
Restrições naked tipo podem ser usadas em definições de classe genérico. Observe que a
restrição tipo naked deve também ter sido declarada dentro de colchetes angulares juntamente
com outros parâmetros tipo:
C#
//naked type constraint public class SampleClass<T, U, V> where T : V { }
A utilidade de restrições tipo naked com classes genéricos é muito limitada porque o compilador
pode assumir nada sobre uma restrição tipo naked exceto que ela deriva de System.Object.
Utilizar restrições tipo naked em classes genéricos em situações em que você deseja aplicar uma
relação de herança entre dois parâmetros tipo.
Representantes genéricos (Guia de programação C#)

A Delegar pode definir seus próprios parâmetros tipo. Código que o representante genérico pode
especificar o argumento Tipo para criar um tipo construído fechado, assim como quando
referências instanciar uma classe genérico ou chamar um método genérico, conforme mostrado
no exemplo o seguir:
C#
public delegate void Del<T>(T item); public static void Notify(int i) { } Del<int> m1 = new Del<int>(Notify);
C# 2.0 tem um novo recurso chamado método conversão de grupo, que se aplica aos tipos de
representante concreto, bem como genérico, e permite que você para gravar a linha anterior
usando esta sintaxe simplificada:
C#
Del<int> m2 = Notify;
Representantes definidos em uma classe genérico podem usar os parâmetros tipo de classe
genérico em da mesma maneira que faça métodos de classe.
C#
class Stack<T> { T[] items; int index; public delegate void StackDelegate(T[] items); }
Código que referencia o representante deve especificar o argumento Tipo da classe que contém,
da seguinte maneira:
C#
private static void DoWork(float[] items) { } public static void TestStack() { Stack<float> s = new
Stack<float>(); Stack<float>.StackDelegate d = DoWork; }
Representantes genéricos são especialmente úteis para definir eventos com base no padrão
design típica porque o argumento do remetente podem ser digitados altamente e não tem mais
para ser convertido de e para Object.
C#
delegate void StackEventHandler<T, U>(T sender, U eventArgs); class Stack<T> { public class
StackEventArgs : System.EventArgs { } public event StackEventHandler<Stack<T>, StackEventArgs>
stackEvent; protected virtual void OnStackChanged(StackEventArgs a) { stackEvent(this, a); } } class
SampleClass { public void HandleStackChange<T>(Stack<T> stack, Stack<T>.StackEventArgs args) { } }
public static void Test() { Stack<double> s = new Stack<double>(); SampleClass o = new SampleClass();
s.stackEvent += o.HandleStackChange; }
Neste exemplo a genérica Classe Stack<T> implementa o Interface IEnumerator<T> Genérico.

Uma matriz de tipo T é declarada e atribuído valores usando o método Push. No método
GetEnumerator, os valores da matriz são retornados usando a yield return instrução.
O não-genéricos GetEnumerator também é implementado, porque IEnumerable<T> herdado

IEnumerable. Este exemplo mostra a implementação típica, que é para o método não-generic para
simplesmente encaminhar a chamada para o método genérico.
Exemplo
C#
using System.Collections; using System.Collections.Generic; namespace GenericIteratorExample { public
class Stack<T> : IEnumerable<T> { private T[] values = new T[100]; private int top = 0; public void Push(T
t) { values[top++] = t; } public T Pop() { return values[--top]; } // These make Stack<T> implement
IEnumerable<T> allowing // a stack to be used in a foreach statement. public IEnumerator<T>
GetEnumerator() { for (int i = top; --i >= 0; ) { yield return values[i]; } } IEnumerator
IEnumerable.GetEnumerator() { return GetEnumerator(); } // Iterate from top to bottom. public
IEnumerable<T> TopToBottom { get { // Since we implement IEnumerable<T> // and the default iteration
is top to bottom, // just return the object. return this; } } // Iterate from bottom to top. public
IEnumerable<T> BottomToTop { get { for (int i = 0; i < top; i++) { yield return values[i]; } } } //A
parameterized iterator that return n items from the top public IEnumerable<T> TopN(int n) { // in this
example we return less than N if necessary int j = n >= top ? 0 : top - n; for (int i = top; --i >= j; ) { yield
return values[i]; } } } //This code uses a stack and the TopToBottom and BottomToTop properties //to
enumerate the elements of the stack. class Test { static void Main() { Stack<int> s = new Stack<int>(); for
(int i = 0; i < 10; i++) { s.Push(i); } // Prints: 9 8 7 6 5 4 3 2 1 0 // Foreach legal since s implements
IEnumerable<int> foreach (int n in s) { System.Console.Write("{0} ", n); } System.Console.WriteLine(); //
Prints: 9 8 7 6 5 4 3 2 1 0 // Foreach legal since s.TopToBottom returns IEnumerable<int> foreach (int n in
s.TopToBottom) { System.Console.Write("{0} ", n); } System.Console.WriteLine(); // Prints: 0 1 2 3 4 5 6 7 8
9 // Foreach legal since s.BottomToTop returns IEnumerable<int> foreach (int n in s.BottomToTop) {
System.Console.Write("{0} ", n); } System.Console.WriteLine(); // Prints: 9 8 7 6 5 4 3 // Foreach legal since
s.TopN returns IEnumerable<int> foreach (int n in s.TopN(7)) { System.Console.Write("{0} ", n); }
System.Console.WriteLine(); } } }

Saída
9876543210987654321001234567899876543
COMO: Combinar representantes (Representantes Multicast) (Guia de programação C#)
Este exemplo demonstra como compor representantes de difusão seletiva. Uma propriedade de
Delegar objetos útil é que eles podem ser atribuídos a instância um de representante para ser
difusão seletiva usando o + operador. Um representante composto chama os representantes ele
foi composto de dois. Somente representantes do mesmo tipo podem ser compostos.
O - operador pode ser usado para remover um representante componente de um representante

composto.
Exemplo
C#
delegate void Del(string s); class TestClass { static void Hello(string s) { System.Console.WriteLine(" Hello,
{0}!", s); } static void Goodbye(string s) { System.Console.WriteLine(" Goodbye, {0}!", s); } static void Main()
{ Del a, b, c, d; // Create the delegate object a that references // the method Hello: a = Hello; // Create the
delegate object b that references // the method Goodbye: b = Goodbye; // The two delegates, a and b, are
composed to form c: c = a + b; // Remove a from the composed delegate, leaving d, // which calls only the
method Goodbye: d = c - a; System.Console.WriteLine("Invoking delegate a:"); a("A");
System.Console.WriteLine("Invoking delegate b:"); b("B"); System.Console.WriteLine("Invoking delegate
c:"); c("C"); System.Console.WriteLine("Invoking delegate d:"); d("D"); } }
Saída
Invoking delegate a: Hello, A! Invoking delegate b: Goodbye, B! Invoking delegate c: Hello, C! Goodbye, C!
Invoking delegate d: Goodbye, D!
COMO: Declarar, instanciar e usar um representante (Guia de programação C#)
Representantes são declarados como mostrado aqui:
C#
public delegate void Del<T>(T item); public void Notify(int i) { }
C#
Del<int> d1 = new Del<int>(Notify);
Em C# 2.0, também é possível para declarar uma Delegar essa sintaxe simplificada usando:
C#
Del<int> d2 = Notify;
O exemplo a seguir ilustra declarar, instanciar, e usando um representante. A BookDB classe

encapsula um banco de dados livraria que mantém um banco de dados de livros. Ela expõe um
método, ProcessPaperbackBooks,. que localiza todos os paperback livros no banco de dados e
chama um representante para cada um O delegate tipo usado é chamado ProcessBookDelegate. A
Test classe usa esta classe para imprimi-los a títulos e os livros paperback preço médio.

O uso de representantes promove boa separação de funcionalidade entre o banco de dados
livraria e o código do cliente. O código do cliente não tem conhecimento de como os livros são
armazenados ou como o código livraria localiza livros paperback. O código livraria não tem
conhecimento de qual processamento é feito nos livros paperback após ele encontra-los.
Exemplo
C#
// A set of classes for handling a bookstore: namespace Bookstore { using System.Collections; // Describes a
book in the book list: public struct Book { public string Title; // Title of the book. public string Author; //
Author of the book. public decimal Price; // Price of the book. public bool Paperback; // Is it paperback?
public Book(string title, string author, decimal price, bool paperBack) { Title = title; Author = author; Price =
price; Paperback = paperBack; } } // Declare a delegate type for processing a book: public delegate void
ProcessBookDelegate(Book book); // Maintains a book database. public class BookDB { // List of all books in
the database: ArrayList list = new ArrayList(); // Add a book to the database: public void AddBook(string
title, string author, decimal price, bool paperBack) { list.Add(new Book(title, author, price, paperBack)); } //
Call a passed-in delegate on each paperback book to process it: public void
ProcessPaperbackBooks(ProcessBookDelegate processBook) { foreach (Book b in list) { if (b.Paperback) //
Calling the delegate: processBook(b); } } } } // Using the Bookstore classes: namespace BookTestClient {
using Bookstore; // Class to total and average prices of books: class PriceTotaller { int countBooks = 0;
decimal priceBooks = 0.0m; internal void AddBookToTotal(Book book) { countBooks += 1; priceBooks +=
book.Price; } internal decimal AveragePrice() { return priceBooks / countBooks; } } // Class to test the book
database: class TestBookDB { // Print the title of the book. static void PrintTitle(Book b) {
System.Console.WriteLine(" {0}", b.Title); } // Execution starts here. static void Main() { BookDB bookDB =
new BookDB(); // Initialize the database with some books: AddBooks(bookDB); // Print all the titles of
paperbacks: System.Console.WriteLine("Paperback Book Titles:"); // Create a new delegate object associated
with the static // method Test.PrintTitle: bookDB.ProcessPaperbackBooks(PrintTitle); // Get the average
price of a paperback by using // a PriceTotaller object: PriceTotaller totaller = new PriceTotaller(); // Create
a new delegate object associated with the nonstatic // method AddBookToTotal on the object totaller:
bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal); System.Console.WriteLine("Average Paperback
Book Price: ${0:#.##}", totaller.AveragePrice()); } // Initialize the book database with some test books: static
void AddBooks(BookDB bookDB) { bookDB.AddBook("The C Programming Language", "Brian W. Kernighan
and Dennis M. Ritchie", 19.95m, true); bookDB.AddBook("The Unicode Standard 2.0", "The Unicode
Consortium", 39.95m, true); bookDB.AddBook("The MS-DOS Encyclopedia", "Ray Duncan", 129.95m, false);
bookDB.AddBook("Dogbert's Clues for the Clueless", "Scott Adams", 12.00m, true); } } }
Saída
Paperback Book Titles: The C Programming Language The Unicode Standard 2.0 Dogbert's Clues for the
Clueless Average Paperback Book Price: $23.97
• Declarar um representante.
A instrução a seguir:
C#
public delegate void ProcessBookDelegate(Book book);
declara um novo tipo delegate. Cada tipo delegate descreve o número e tipos dos argumentos,
e o tipo do valor de retorno dos métodos que ele pode encapsular. Sempre que um novo

conjunto de tipos de argumento ou tipo de valor de retorno for necessário, um novo tipo
delegate deve ser declarado.
• Instanciar um representante.
Depois que um tipo delegate tiver sido declarado, um objeto de representante deve ser criado
e associado com um método específico. No exemplo acima, isso é feito, passando o PrintTitle
método para o ProcessPaperbackBooks método, como este:
C#
bookDB.ProcessPaperbackBooks(PrintTitle);
Isso cria um novo objeto de representante associado o Estático método Test.PrintTitle. Da

mesma forma, é passado como este: o método AddBookToTotal não-estático no objeto totaller
C#
bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);
Em ambos os casos um novo objeto de representante é passado para o ProcessPaperbackBooks

método.
Depois que um representante for criada, o método é associado a alterações nunca; objetos de
representante são imutáveis.
• Chamar um representante.
Depois que um objeto de representante for criado, o objeto de representante normalmente é
passado para outros códigos que chamará o representante. Um objeto de representante é
chamado pelo usando o nome do objeto de representante, seguido pelos argumentos
parenthesized a serem passados ao representante. Um exemplo de uma chamada de
representante é:
C#
processBook(b);
Um representante ou pode ser chamado de forma síncrona, como, neste exemplo, ou

assincronamente por usando BeginInvoke e EndInvoke métodos.
COMO: Usar sobrecarga de operador para criar uma classe para números complexos (Guia de
programação C#)
Este exemplo mostra como você pode usar operador sobrecarga para criar uma classe Complex
número complexo que define adição complexa. O programa exibirá o IMAGINARY e as partes dos
números e o resultado disso usando uma substituição do método ToString reais.
Exemplo
C#
public struct Complex { public int real; public int imaginary; public Complex(int real, int imaginary)
//constructor { this.real = real; this.imaginary = imaginary; } // Declare which operator to overload (+), //
the types that can be added (two Complex objects), // and the return type (Complex): public static Complex
operator +(Complex c1, Complex c2) { return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary); }
// Override the ToString() method to display a complex number in the traditional format: public override
string ToString() { return (System.String.Format("{0} + {1}i", real, imaginary)); } } class TestComplex { static
void Main() { Complex num1 = new Complex(2, 3); Complex num2 = new Complex(3, 4); // Add two
Complex objects through the overloaded plus operator: Complex sum = num1 + num2; // Print the numbers
and the sum using the overriden ToString method: System.Console.WriteLine("First complex number: {0}",

num1); System.Console.WriteLine("Second complex number: {0}", num2); System.Console.WriteLine("The
sum of the two numbers: {0}", sum); } }
Saída
First complex number: 2 + 3i Second complex number: 3 + 4i The sum of the two numbers: 5 + 7i
COMO: Usar interoperabilidade COM para verificar ortografia usando o Word (Guia de
programação C#)
O exemplo de código a seguir ilustra como usar interoperabilidade COM para usar recursos Spell-
verificação do Word em seu aplicativo Visual C#. Para obter mais informações, consulte
ProofreadingErrors e Objetos Microsoft Word.
Exemplo
Este exemplo ilustra como usar Verificador ortográfico do Word a partir de um aplicativo C#. Cria
um novo Word.application objeto usando interoperabilidade COM. Em seguida, utiliza a
ProofreadingErrors coleção em um Range objeto e localiza as palavras incorretas no intervalo.
C#
using System.Reflection; using Word = Microsoft.Office.Interop.Word; namespace WordSpell { public partial
class Form1 : System.Windows.Forms.Form { private System.Windows.Forms.TextBox textBox1; private
System.Windows.Forms.Button button1; private System.Windows.Forms.Label label1; public Form1()
//constructor { InitializeComponent(); } private void button1_Click(object sender, System.EventArgs e) {
Word.Application app = new Word.Application(); int errors = 0; if (textBox1.Text.Length > 0) { app.Visible =
false; // Setting these variables is comparable to passing null to the function. // This is necessary because the
C# null cannot be passed by reference. object template = Missing.Value; object newTemplate =
Missing.Value; object documentType = Missing.Value; object visible = true; Word._Document doc1 =
app.Documents.Add(ref template, ref newTemplate, ref documentType, ref visible);
doc1.Words.First.InsertBefore(textBox1.Text); Word.ProofreadingErrors spellErrorsColl =
doc1.SpellingErrors; errors = spellErrorsColl.Count; object optional = Missing.Value; doc1.CheckSpelling( ref
optional, ref optional, ref optional, ref optional, ref optional, ref optional, ref optional, ref optional, ref
optional, ref optional, ref optional, ref optional); label1.Text = errors + " errors corrected "; object first = 0;
object last = doc1.Characters.Count - 1; textBox1.Text = doc1.Range(ref first, ref last).Text; } object
saveChanges = false; object originalFormat = Missing.Value; object routeDocument = Missing.Value;
app.Quit(ref saveChanges, ref originalFormat, ref routeDocument); } } }
Este exemplo requer Word para ser instalado em seu sistema e dependendo da versão do Office
você tiver instalado, o Word conjunto pode ser chamado Microsoft Office 10 Biblioteca de objetos
ou biblioteca de objetos 11 Word.
Observação

Para compilar o código
1. Criar um novo projeto aplicativo Windows C# no Visual Studio, e chamá-lo WordSpell.

2. Copie o código acima, e colá-lo sobre o conteúdo do arquivo Form1.cs.
3. Copie o código a seguir, e colá-lo no Form1.Designer.cs arquivo, o InitializeComponent()
método, após qualquer código existente.
C#
this.textBox1 = new System.Windows.Forms.TextBox(); this.button1 = new
System.Windows.Forms.Button(); this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout(); // // textBox1 // this.textBox1.Location = new System.Drawing.Point(40, 40);
this.textBox1.Multiline = true; this.textBox1.Name = "textBox1"; this.textBox1.ScrollBars =
System.Windows.Forms.ScrollBars.Vertical; this.textBox1.Size = new System.Drawing.Size(344, 136);
this.textBox1.TabIndex = 0; this.textBox1.Text = ""; // // button1 // this.button1.Location = new
System.Drawing.Point(392, 40); this.button1.Name = "button1"; this.button1.Size = new
System.Drawing.Size(96, 23); this.button1.TabIndex = 1; this.button1.Text = "Check Spelling";
this.button1.Click += new System.EventHandler(this.button1_Click); // // label1 //
this.label1.Location = new System.Drawing.Point(40, 24); this.label1.Name = "label1"; this.label1.Size
= new System.Drawing.Size(336, 16); this.label1.TabIndex = 2; // // Form1 //
this.AutoScaleDimensions = new System.Drawing.SizeF(5, 13); this.ClientSize = new
System.Drawing.Size(496, 205); this.Controls.Add(this.label1); this.Controls.Add(this.button1);
this.Controls.Add(this.textBox1); this.Name = "Form1"; this.Text = "SpellCheckDemo";
this.ResumeLayout(false);
4. Incluir o Word conjunto como uma referência para o projeto. Clique com o botão direito do
mouse no projeto, clique em Add Reference, clique na COM guia da caixa Add Reference
de diálogo. Clique duas vezes Microsoft Office 11 Object Library, e pressione OK.
Observe que as caixas de diálogo e comandos de menu você ver podem diferir dos
descritos na Ajuda dependendo do seu ativos configurações ou edição. Para alterar as
configurações, escolha Import and Export Settings (Importar e Exportar Configurações) no
menu Tools (Ferramentas). Para mais informações, consulte Configurações do Visual
Studio.
Segurança
Para usar interoperabilidade COM, você deve ter permissões de segurança de usuário energia ou
administrador. Para obter mais informações, consulte Segurança do .NET Framework.
COMO: Usar interoperabilidade COM para criar uma planilha do Excel (Guia de programação
C#)
O exemplo de código a seguir ilustra como usar COM interop para criar uma Excel planilha. Para
obter mais informações sobre Excel, consulte Objetos do Microsoft Excel, e Método Open
Este exemplo ilustra como abrir uma planilha existente Excel no C# using Capacidade .NET
Framework COM interop. O Excel conjunto é usado para abrir e inserir dados em um intervalo de
células na planilha Excel.
Observação

Você deve ter Excel instalado em seu sistema para este código seja executado corretamente.
Observação
Para criar uma planilha do Excel com interoperabilidade com

1. Criar um novo aplicativo Console C# no Visual Studio e chamá-la CreateExcelWorksheet.
2. Incluir o conjunto Excel como uma referência para o projeto Right-Click no projeto,
selecione Add Reference.:
3. Clique na COM guia da caixa Add Reference de diálogo, e Localizar Microsoft Excel 11
Object Library.
4. Clique duas vezes em Microsoft Excel 11 Object Library, e pressione OK.
Observação
Dependendo da versão do Office instalada o conjunto Excel pode ser chamado Excel 10 Object
Library ou Excel 11 Object Library.. ou Excel 11 Object Library
5. Copie o código a seguir e cole sobre o conteúdo do arquivo Program.cs.

C#
using System; using System.Reflection; using Microsoft.Office.Interop.Excel; public class
CreateExcelWorksheet { static void Main() { Microsoft.Office.Interop.Excel.Application xlApp = new
Microsoft.Office.Interop.Excel.Application(); if (xlApp == null) { Console.WriteLine("EXCEL could
not be started. Check that your office installation and project references are correct."); return; }
xlApp.Visible = true; Workbook wb = xlApp.Workbooks.Add(XlWBATemplate.xlWBATWorksheet);
Worksheet ws = (Worksheet)wb.Worksheets[1]; if (ws == null) { Console.WriteLine("Worksheet
could not be created. Check that your office installation and project references are correct."); } //
Select the Excel cells, in the range c1 to c7 in the worksheet. Range aRange = ws.get_Range("C1",
"C7"); if (aRange == null) { Console.WriteLine("Could not get a range. Check to be sure you have the
correct versions of the office DLLs."); } // Fill the cells in the C1 to C7 range of the worksheet with the
number 6. Object[] args = new Object[1]; args[0] = 6; aRange.GetType().InvokeMember("Value",
BindingFlags.SetProperty, null, aRange, args); // Change the cells in the C1 to C7 range of the
worksheet to the number 8. aRange.Value2 = 8; } }
Segurança
Para usar COM interop, você deve ter administrator ou Power User permissões de segurança.
Para obter mais informações sobre segurança, consulte Segurança do .NET Framework.
COMO: Usar código gerenciado como um suplemento de automação para o Excel (Guia de
programação C#)
Com os suplementos de automação para o Excel, você pode usar uma função pública de sua
biblioteca COM para ser chamado como uma fórmula de célula. O exemplo a seguir ilustra como
criar um suplemento do C# para cálculo de imposto de renda TAXA em uma célula em uma
planilha do Excel. Automaticamente ComRegisterFunctionAttribute registra as ferramentas add-in,
e não adicionais são necessárias para registrar o código gerenciado como um conjunto com. Para
obter informações adicionais, consulte Visão geral sobre de interoperabilidade (guia de
programação C#).
Observação
Calcular imposto de renda
Uma tabela de imposto típica permite para calcular o imposto fornecido receita anual de uma
pessoa. Por exemplo, a seguir mostra uma tabela de imposto hipotético para indivíduos.
Uma tabela imposto exemplo

1. Se renda é em zero dólares e em $7,000, o imposto é 10 por cento da quantidade.
2. Se renda é mais de r$ 100,00 7.000 e em $28,400, o imposto é 15 por cento da quantidade
sobre $7,000 mais $700.00.
3. Se renda é mais de r$ 100,00 28,400 e em $68,800, o imposto é 25 por cento da
quantidade sobre $28,400 mais 3,910.00.
quantidade sobre $68,800 mais $14,010.00.
quantidade sobre $143,500 mais $34,926.00.
6. Se renda for sobre $311,950, o imposto será 35 por cento da quantidade sobre $311,950
mais $90,514.50.
Criar um suplemento de automação para Excel usando o Visual Studio e código gerenciado
1. Criar um novo projeto Visual C# Class Library chamado ExcelAddIn.
2. Na janela Propriedades do projeto, abaixo Configuration Properties, Build, na caixa
suspensa rotuladas Register for COM Interop selecione True. Configuração do projeto do
Visual Studio da compilação dessa propriedade registra automaticamente seu conjunto para
interoperabilidade COM.
3. Cole o código a seguir para o arquivo de classe.
C#
using System.Runtime.InteropServices; namespace TaxTables {
[ClassInterface(ClassInterfaceType.AutoDual)] public class TaxTables { public static double
Tax(double income) { if (income > 0 && income <= 7000) {return (.10 * income);} if (income > 7000
&& income <= 28400) {return 700.00 + (.15 * (income - 7000));} if (income > 28400 && income <=
68800) {return 3910.00 + (.25 * (income - 28400));} if (income > 68800 && income <= 143500)
{return 14010.00 + (.28 * (income - 68800));} if (income > 143500 && income <= 311950) {return
34926.00 + (.33 * (income - 143500));} if (income > 311950) {return 90514.50 + (.35 * (income -
311950));} return 0; } [ComRegisterFunctionAttribute] public static void
RegisterFunction(System.Type t) { Microsoft.Win32.Registry.ClassesRoot.CreateSubKey ("CLSID\\{"

+ t.GUID.ToString().ToUpper() + "}\\Programmable"); } [ComUnregisterFunctionAttribute] public
static void UnregisterFunction(System.Type t) { Microsoft.Win32.Registry.ClassesRoot.DeleteSubKey
("CLSID\\{" + t.GUID.ToString().ToUpper() + "}\\Programmable"); } } }
Executando o código
Executar o suplemento do Excel
• Criar o ExcelAddIn projeto, e pressione F5 para compilá-lo.

• Abra uma nova pasta de trabalho no Excel.
• No menu Tools, clique em Add-Ins, e clique em Automation
• Na caixa de diálogo Servidores de automação, selecione ExcelAddIn na lista de
suplementos, e clique em OK
• Em uma célula pasta de trabalho, digite =Tax(23500). A célula exibirá 3175.
• Para registrar depois de mover o ExcelAddIn.dll para um diretório diferente, execute
regasm com /codebase. Você pode receber um aviso indicando que o conjunto é não
assinado.
• Observe que as caixas de diálogo e comandos de menu você ver podem diferir dos
descritos na Ajuda dependendo do seu ativos configurações ou edição. Para alterar as
configurações, escolha Import and Export Settings (Importar e Exportar Configurações) no
menu Tools (Ferramentas). Para mais informações, consulte Configurações do Visual Studio.
Segurança
Para usar a interoperabilidade COM, você deve ter permissões de segurança de usuário energia
ou administrador. Para obter mais informações, consulte Segurança do .NET Framework.
COMO: Usar serviços de chamada da plataforma para reproduzir um arquivo WAVE (Guia de
programação C#)
O exemplo de código C# a seguir ilustra como usar plataforma invocar serviços para reproduzir
um arquivo de som wave na plataforma Windows.
Exemplo
Este código de exemplo usa DllImport para ponto de entrada método de importação winmm.dll
na PlaySound como Form1 PlaySound(). O exemplo tem um Windows Form simples com um
botão. Clicar no botão abre uma caixa de diálogo padrão janelas OpenFileDialog para que você
possa abri um arquivo para executar. Quando um arquivo wave é selecionado, ela é disputada
usando o PlaySound() método do método do conjunto winmm.DLL. Para obter mais informações
no método winmm.DLL na PlaySound, consulte Usando. Procurar e selecione um arquivo com
uma extensão.wav, e, em seguida clique em Open Para executar o arquivo wave usando
plataforma chamar. Uma caixa de texto mostra o caminho completo do arquivo selecionado.
Caixa Open Files de diálogo é filtrada para mostrar somente arquivos com uma extensão.wav
através das configurações de filtro:
C#
dialog1.Filter = "Wav Files (*.wav)|*.wav";
C#
using System.Windows.Forms; namespace WinSound { public partial class Form1 : Form { private TextBox
textBox1; private Button button1; public Form1() //constructor { InitializeComponent(); }

[System.Runtime.InteropServices.DllImport("winmm.DLL", EntryPoint = "PlaySound", SetLastError =
true)] private static extern bool PlaySound(string szSound, System.IntPtr hMod, PlaySoundFlags flags);
[System.Flags] public enum PlaySoundFlags : int { SND_SYNC = 0x0000, SND_ASYNC = 0x0001,
SND_NODEFAULT = 0x0002, SND_LOOP = 0x0008, SND_NOSTOP = 0x0010, SND_NOWAIT =
0x00002000, SND_FILENAME = 0x00020000, SND_RESOURCE = 0x00040004 } private void
button1_Click (object sender, System.EventArgs e) { OpenFileDialog dialog1 = new OpenFileDialog();
dialog1.Title = "Browse to find sound file to play"; dialog1.InitialDirectory = @"c:\"; dialog1.Filter = "Wav
Files (*.wav)|*.wav"; dialog1.FilterIndex = 2; dialog1.RestoreDirectory = true; if(dialog1.ShowDialog() ==
DialogResult.OK) { textBox1.Text = dialog1.FileName; PlaySound (dialog1.FileName, new System.IntPtr(),
PlaySoundFlags.SND_SYNC); } } } }
Para compilar o código
1. Criar um novo projeto aplicativo Windows C# no Visual Studio e denomine-WinSound.

2. Copie o código acima, e colá-lo sobre o conteúdo do arquivo Form1.cs.
3. Copie o código a seguir, e colá-lo no Form1.Designer.cs arquivo, o InitializeComponent()
método, após qualquer código existente.
C#
this.button1 = new System.Windows.Forms.Button(); this.textBox1 = new

System.Windows.Forms.TextBox(); this.SuspendLayout(); // // button1 // this.button1.Location =
new System.Drawing.Point(192, 40); this.button1.Name = "button1"; this.button1.Size = new
System.Drawing.Size(88, 24); this.button1.TabIndex = 0; this.button1.Text = "Browse";
this.button1.Click += new System.EventHandler(this.button1_Click); // // textBox1 //
this.textBox1.Location = new System.Drawing.Point(8, 40); this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(168, 20); this.textBox1.TabIndex = 1;
this.textBox1.Text = "FIle path"; // // Form1 // this.AutoScaleDimensions = new
System.Drawing.SizeF(5, 13); this.ClientSize = new System.Drawing.Size(292, 266);
this.Controls.Add(this.textBox1); this.Controls.Add(this.button1); this.Name = "Form1"; this.Text =
"Platform Invoke WinSound C#"; this.ResumeLayout(false); this.PerformLayout();
4. Compile e executar o código.
HOW TO: Use ponteiros para copiar uma matriz de bytes (guia de programação C#)
O exemplo a seguir utiliza ponteiros para copiar bytes de uma matriz para outro usando ponteiros.
Este exemplo usa a Não seguro palavra-chave, que permite ponteiros a ser usado no método
Copy. A Fixo instrução é usada para declarar ponteiros para as matrizes origem e destino. Isso
Pinos o local da origem e destino matriz na memória para que eles não serão movidos por coleta
de lixo. Esses blocos de memória será unpinneds quando conclui o fixed Bloco. Porque a função
Copiar neste exemplo usa a unsafe palavra-chave, ele deve ser compilado com /unsafe Opção
de compilador.
Exemplo
C#

C#
class TestCopy { // The unsafe keyword allows pointers to be used within the following method: static unsafe
void Copy(byte[] src, int srcIndex, byte[] dst, int dstIndex, int count) { if (src == null || srcIndex < 0 || dst ==
null || dstIndex < 0 || count < 0) { throw new System.ArgumentException(); } int srcLen = src.Length; int
dstLen = dst.Length; if (srcLen - srcIndex < count || dstLen - dstIndex < count) { throw new
System.ArgumentException(); } // The following fixed statement pins the location of the src and dst objects
// in memory so that they will not be moved by garbage collection. fixed (byte* pSrc = src, pDst = dst) { byte*
ps = pSrc; byte* pd = pDst; // Loop over the count in blocks of 4 bytes, copying an integer (4 bytes) at a time:
for (int i = 0 ; i < count / 4 ; i++) { *((int*)pd) = *((int*)ps); pd += 4; ps += 4; } // Complete the copy by
moving any bytes that weren't moved in blocks of 4: for (int i = 0; i < count % 4 ; i++) { *pd = *ps; pd++;
ps++; } } } static void Main() { byte[] a = new byte[100]; byte[] b = new byte[100]; for (int i = 0; i < 100; ++i)
{ a[i] = (byte)i; } Copy(a, 0, b, 0, 100); System.Console.WriteLine("The first 10 elements are:"); for (int i = 0;
i < 10; ++i) { System.Console.Write(b[i] + " "); } System.Console.WriteLine("\n"); } }
Saída
The first 10 elements are: 0 1 2 3 4 5 6 7 8 9
COMO: Usar a função ReadFile do Windows (Guia de programação C#)
Este exemplo demonstra a função do Windows ReadFile, ler e exibir um arquivo de texto. A
ReadFile função requer o uso de unsafe CÓDIGO porque ele requer um ponteiro como um
parâmetro.
A matriz de bytes passada para a Read função é um tipo gerenciado. Isso significa que comuns o
coletor de lixo Runtime (CLR) de idioma pode realocar a memória usada pela matriz em será.
Para evitar isso, Fixo é usado para obter um apontador para a memória e marcá-la assim ele não
será movido o coletor de lixo. No final do bloco fixed, a memória retorna automaticamente para
sendo sujeitos a percorrendo coleta de lixo.
Esse recurso é conhecido como declarativa pinning. A parte boa sobre pinning é que não há
sobrecarga muito pouco a menos que uma coleta de lixo ocorre em bloco fixed, que é pouco
provável.
Exemplo
C#
class FileReader { const uint GENERIC_READ = 0x80000000; const uint OPEN_EXISTING = 3;
System.IntPtr handle; [System.Runtime.InteropServices.DllImport("kernel32", SetLastError = true)] static
extern unsafe System.IntPtr CreateFile ( string FileName, // file name uint DesiredAccess, // access mode
uint ShareMode, // share mode uint SecurityAttributes, // Security Attributes uint CreationDisposition, //
how to create uint FlagsAndAttributes, // file attributes int hTemplateFile // handle to template file );
[System.Runtime.InteropServices.DllImport("kernel32", SetLastError = true)] static extern unsafe bool
ReadFile ( System.IntPtr hFile, // handle to file void* pBuffer, // data buffer int NumberOfBytesToRead, //
number of bytes to read int* pNumberOfBytesRead, // number of bytes read int Overlapped // overlapped
buffer ); [System.Runtime.InteropServices.DllImport("kernel32", SetLastError = true)] static extern unsafe
bool CloseHandle ( System.IntPtr hObject // handle to object ); public bool Open(string FileName) { // open
the existing file for reading handle = CreateFile ( FileName, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0
); if (handle != System.IntPtr.Zero) { return true; } else { return false; } } public unsafe int Read(byte[] buffer,
int index, int count) { int n = 0; fixed (byte* p = buffer) { if (!ReadFile(handle, p + index, count, &n, 0)) {
return 0; } } return n; } public bool Close() { return CloseHandle(handle); } } class Test { static int

Main(string[] args) { if (args.Length != 1) { System.Console.WriteLine("Usage : ReadFile <FileName>");
return 1; } if (!System.IO.File.Exists(args[0])) { System.Console.WriteLine("File " + args[0] + " not found.");
return 1; } byte[] buffer = new byte[128]; FileReader fr = new FileReader(); if (fr.Open(args[0])) { // Assume
that an ASCII file is being read. System.Text.ASCIIEncoding Encoding = new System.Text.ASCIIEncoding();
int bytesRead; do { bytesRead = fr.Read(buffer, 0, buffer.Length); string content =
Encoding.GetString(buffer, 0, bytesRead); System.Console.Write("{0}", content); } while (bytesRead > 0);
fr.Close(); return 0; } else { System.Console.WriteLine("Failed to open requested file"); return 1; } } }
COMO: Criar e terminar threads (Guia de programação C#)
Este exemplo demonstra como um segmento auxiliar ou operador pode ser criados e usado para
realizar processamento em paralelo com o segmento primário. Tornando um segmento esperar
por outro e normalmente Finalizando um segmento também são demonstrou. Para obter
informações detalhadas e Usando Threading (C# programação guia). em consulte Segmentação
gerenciada Multi-Threading,
O exemplo cria uma classe denominada Worker que contém o método que o segmento de
trabalho será executado chamado DoWork. Isso é basicamente a Main função para o segmento de
trabalho. O segmento de trabalho chamar esse método, comece a execução e finalizar
automaticamente quando esse método retorna. O DoWork método tem a seguinte aparência:
C#
public void DoWork() { while (!_shouldStop) { Console.WriteLine("worker thread: working..."); }
Console.WriteLine("worker thread: terminating gracefully."); }
A Worker classe contém um método adicional que é usado para indicar aos DoWork que ela deve
retornar. Esse método for chamado RequestStop, e tem a seguinte aparência:
C#
public void RequestStop() { _shouldStop = true; }
O RequestStop método simplesmente atribui o _shouldStop membro dados para true. Porque esse
membro de dados fica marcado como o DoWork método, isso tem o efeito de causar DoWork para
retornar, INDIRETO assim encerrando o segmento de trabalho. No entanto, é importante observar
que DoWork e RequestStop será executado por diferentes segmentos. é DoWork executado pelo
segmento de trabalho, e RequestStop é executado pelo segmento primário, para o _shouldStop
membro dos dados é declarado volatile, como isso:
C#
private volatile bool _shouldStop;
Palavra-chave volatile alerta o compilador vários segmentos acessará o _shouldStop membro dos
dados, e portanto ele não deve fazer suposições de otimização sobre o estado deste membro.
Para obter mais informações, consulte volátil (referência C#).
O uso volatile com o _shouldStop Membro de dados permite que nós para com segurança acessar
este membro de vários segmentos sem o uso de segmento formal técnicas de sincronização, mas
apenas porque _shouldStop é. um bool Isso significa que operações somente único e atômicas
são necessárias para modificar _shouldStop. Se, contudo, esse membro de dados eram uma
classe, estrutura, ou matriz, acessando-de vários segmentos, provavelmente resultam em
corrupção de dados intermitentes. Considere um segmento que altera os valores em uma matriz.
Windows regularmente interrompe segmentos para permitir que outros segmentos para executar,

para este segmento pode ser interrompido após atribuir alguns elementos da matriz, mas antes de
atribuir outros. Isso significa a matriz agora tem um estado que o programador nunca pretendido,
e outro segmento ler essa matriz pode falhar como resultado.
Antes de realmente criar o segmento de trabalho, a Main função cria uma instância de Thread um
Worker objeto e. O objeto do segmento está configurado para usar o Worker.DoWork método como
uma entrada ponto, passando uma referência a esse método para o Thread Construtor, como
este:
C#
Worker workerObject = new Worker(); Thread workerThread = new Thread(workerObject.DoWork);
Nesse ponto, embora o objeto do segmento de trabalho existir e estiver configurada, o segmento
de trabalho real foi ainda criado. Isso não acontecer até Main Chamadas o Start método:
C#
workerThread.Start();
Neste ponto, o sistema inicia a execução do segmento de trabalho, mas não tão assincronamente
para o segmento primário. Isso significa que a Main função continua a executar código
imediatamente enquanto o segmento de trabalho simultaneamente undergoes inicialização. Para
garantir que a Main função não tentará encerrar o segmento de trabalho antes ele tem a
oportunidade de executar, a Main função entrará em loop até o operador segmento definido obtém
propriedade do objeto IsAlive como true:
C#
while (!workerThread.IsAlive);
Em seguida, o segmento primário é interrompido brevemente com uma chamada para Sleep. Isso
insures função do segmento DoWork de trabalho que será executado o loop dentro o DoWork
Método de iterações de alguns antes a Main função executa os comandos mais:
C#
Thread.Sleep(1);
Após o milissegundo 1 expirar, Main sinais para o objeto do segmento de trabalho que ele deve
terminar usando o Worker.RequestStop método apresentado anteriormente:
C#
workerObject.RequestStop();
Também é possível para finalizar um segmento de outro segmento com uma chamada para Abort,
mas isso força termina o segmento afetado sem preocupação para se ele concluiu a tarefa e
oferece nenhum Oportunidade para a limpeza de recursos. A técnica mostrada nesse exemplo é
preferível.
Finalmente, a Main função chama o Join método para o objeto do segmento de trabalho. Este
método faz o segmento atual para bloquear, ou espera, até que o segmento que representa o
objeto termina. Portanto, Join não retornará até o operador segmento retorna, assim encerrando
próprio:
C#

workerThread.Join();
Neste ponto apenas o segmento primário executando Main existe. Ele exibe uma mensagem final,
e depois retorna, encerrando o segmento primário, bem.
O exemplo completo aparece abaixo.
Exemplo
C#
using System; using System.Threading; public class Worker { // This method will be called when the thread
is started. public void DoWork() { while (!_shouldStop) { Console.WriteLine("worker thread: working..."); }
Console.WriteLine("worker thread: terminating gracefully."); } public void RequestStop() { _shouldStop =
true; } // Volatile is used as hint to the compiler that this data // member will be accessed by multiple
threads. private volatile bool _shouldStop; } public class WorkerThreadExample { static void Main() { //
Create the thread object. This does not start the thread. Worker workerObject = new Worker(); Thread
workerThread = new Thread(workerObject.DoWork); // Start the worker thread. workerThread.Start();
Console.WriteLine("main thread: Starting worker thread..."); // Loop until worker thread activates. while
(!workerThread.IsAlive); // Put the main thread to sleep for 1 millisecond to // allow the worker thread to do
some work: Thread.Sleep(1); // Request that the worker thread stop itself: workerObject.RequestStop(); //
Use the Join method to block the current thread // until the object's thread terminates. workerThread.Join();
Console.WriteLine("main thread: Worker thread has terminated."); } }
Saída de exemplo
main thread: starting worker thread... worker thread: working... worker thread: working... worker thread:
working... worker thread: working... worker thread: working... worker thread: working... worker thread:
working... worker thread: working... worker thread: working... worker thread: working... worker thread:
working... worker thread: terminating gracefully... main thread: worker thread has terminated
Como sincronizar um Producer e um segmento do consumidor (guia de programação C#):
Segmento sincronização entre o segmento primário e dois segmentos de trabalho usando a lock
palavra-chave, o exemplo a seguir demonstra e AutoResetEvent. e ManualResetEvent Classes
Para obter mais informações, consulte Declaração lock (Referência do C#).
O exemplo cria duas auxiliares, ou segmentos de trabalho. Um segmento produz elementos e as

armazena em uma fila genérica que é Não isenta de segmentos. Para obter mais informações,
consulte Queue.O outro segmento consome itens nessa fila. Além disso, o segmento primário
periodicamente exibe o conteúdo da fila, para a fila é acessada por três segmentos. Palavra-chave
lock é usado para sincronizar o acesso para a fila para garantir que o estado da fila não está
corrompido.
Além de simplesmente impedindo acesso simultâneo com a lock palavra-chave, mais

sincronização é fornecida por dois objetos de evento. Um é usado para sinalizar a segmentos de
trabalho para encerrar, e o outro é usado pelo segmento Producer para sinalizar ao segmento do
consumidor quando um novo item foi adicionado à fila. Esses objetos dois de eventos são
encapsulados em uma classe chamada SyncEvents. Isso permite que os eventos devem ser
passados para os objetos que representam os segmentos consumidor e o Producer facilmente. A
SyncEvents classe é definida como este:
C#

public class SyncEvents { public SyncEvents() { _newItemEvent = new AutoResetEvent(false);
_exitThreadEvent = new ManualResetEvent(false); _eventArray = new WaitHandle[2]; _eventArray[0] =
_newItemEvent; _eventArray[1] = _exitThreadEvent; } public EventWaitHandle ExitThreadEvent { get {
return _exitThreadEvent; } } public EventWaitHandle NewItemEvent { get { return _newItemEvent; } }
public WaitHandle[] EventArray { get { return _eventArray; } } private EventWaitHandle _newItemEvent;
private EventWaitHandle _exitThreadEvent; private WaitHandle[] _eventArray; }
A AutoResetEvent classe é usada para o novo item " " evento porque você deseja esse evento
para redefinir automaticamente cada vez o responde do segmento do consumidor para este
evento. Como alternativa, a ManualResetEvent classe é usada para o evento " Sair " porque
você deseja vários segmentos a responder quando esse evento é sinalizado. O evento se você
usou AutoResetEvent Em vez disso, seria reverter para um estado não-signaled depois apenas
um segmento respondeu ao evento. O outro segmento não pode responder, e, nesse caso,
falhará encerrar.
A SyncEvents classe cria os dois eventos e armazena-los de duas formas diferentes e

ManualResetEvent,.: como EventWaitHandle, que é a classe base para ambos AutoResetEvent
e em uma matriz com base em WaitHandle Como você verá na discussão do segmento do
consumidor, essa matriz é necessário para que o segmento do consumidor pode responder a
qualquer evento.
Os segmentos consumidor e o Producer são representados pelas classes chamados Consumer e

Producer, ambos os quais definir um método chamado ThreadRun. Esses métodos são usados
como os pontos de entrada para a segmentos de trabalho que cria o Main método.
O ThreadRun método definido pela classe Producer tem a seguinte aparência:
C#
// Producer.ThreadRun public void ThreadRun() { int count = 0; Random r = new Random(); while
(!_syncEvents.ExitThreadEvent.WaitOne(0, false)) { lock (((ICollection)_queue).SyncRoot) { while
(_queue.Count < 20) { _queue.Enqueue(r.Next(0,100)); _syncEvents.NewItemEvent.Set(); count++; } } }
Console.WriteLine("Producer thread: produced {0} items", count); }
Esse método entrará em loop até o evento " Sair segmento " torna-se sinalizado. O estado deste
evento é testado com o WaitOne método, usando a ExitThreadEvent propriedade definida pela
classe SyncEvents. Nesse caso o estado do evento é verificado sem bloquear o segmento atual
porque o primeiro argumento usado com WaitOne é zero, indicando que o método deve retornar
imediatamente. Se WaitOne retorna true, e o evento em questão é atualmente sinalizado. Se o
ThreadRun método retorna, então, que tem o efeito de encerrando o segmento de trabalho
executando esse método.
Até que o evento " Sair segmento " é indicado, o Producer.ThreadStart método tenta manter itens
20 na fila. Um item é simplesmente um inteiro entre 0 e 100. A coleção deve estar bloqueada
antes de adicionar novos itens para impedir que o consumidor e segmentos primário acessem a
coleção simultaneamente. Isso é feito com a lock palavra-chave. O argumento passado para lock
é o SyncRoot campo exposto por meio da interface ICollection. Este campo é fornecido
especificamente para sincronizam acesso do segmento. Exclusivo acesso para a coleção é
concedido para as instruções contidas no bloco de código seguinte lock. Para cada novo item que
adiciona o Producer para a fila, uma chamada evento é feito para o Set método no novo item " ".
Isso informa o segmento do consumidor a surgir de seu estado suspenso para processar o novo
item.

O Consumer objeto também define um método chamado ThreadRun. Como o Producer na versão
do ThreadRun, esse método é executado por um segmento de trabalho criado pelo método Main.
No entanto, a versão do ThreadStart consumidor deve responder a dois eventos. O
Consumer.ThreadRun método tem a seguinte aparência:
C#
// Consumer.ThreadRun public void ThreadRun() { int count = 0; while
(WaitHandle.WaitAny(_syncEvents.EventArray) != 1) { lock (((ICollection)_queue).SyncRoot) { int item =
_queue.Dequeue(); } count++; } Console.WriteLine("Consumer Thread: consumed {0} items", count); }
Esse método usa WaitAny para bloquear o segmento do consumidor até qualquer uma das alças
de espera na matriz fornecido ficar sinalizada. Nesse caso, há duas alças em matriz, um para
encerrando a segmentos de trabalho, e um para indicar que um novo item foi adicionado à
coleção. Retorna WaitAny o índice do evento que se tornou sinalizado. O novo item " " evento é o
primeiro na matriz, para um índice de zero indica um novo item. Nesse caso verificar um índice de
1, que indica o evento " Sair segmento ", e isso é usado para determinar se esse método continua
a consumir itens. Se evento foi sinalizado, obter acesso exclusivo para a coleção com lock e
consumir o novo item. o novo item " " Porque este exemplo produz e consome milhares de itens,
você não exibir cada item consumida. Em vez disso use Main para periodicamente exibir o
conteúdo da fila, conforme irá ser demonstrado.
O Main método começa com a criação a fila cujo conteúdo será produzido e consumidos e uma
instância do SyncEvents, que você pesquisado no anteriormente:
C#
Queue<int> queue = new Queue<int>(); SyncEvents syncEvents = new SyncEvents();
Do Producer em seguida, Main configura e Consumer objetos para uso com segmentos de trabalho.
Essa etapa não não, entretanto, criar ou iniciar a segmentos de trabalho real:
C#
Producer producer = new Producer(queue, syncEvents); Consumer consumer = new Consumer(queue,
syncEvents); Thread producerThread = new Thread(producer.ThreadRun); Thread consumerThread = new
Thread(consumer.ThreadRun);
Observe que a fila e o objeto de evento de sincronização são passados para dois e Producer
segmentos como argumentos de construtor. o Consumer Isso fornece os dois objetos com os
recursos compartilhados necessários para executar suas tarefas respectivas. Dois objetos novos
Thread depois são criados, usando o ThreadRun método para cada objeto como um argumento.
Cada segmento de trabalho, quando iniciado, utilizará esse argumento como o ponto de entrada
para o segmento.
Em seguida Main inicia a segmentos dois trabalho com uma chamada para o Start método, como
este:
C#
producerThread.Start(); consumerThread.Start();
Nesse ponto, os dois segmentos de trabalho novo são criados e Iniciar Execução assíncrona,
independente do segmento primário que está em execução o Main método. Na verdade, a
próxima coisa Main não é suspender o segmento principal com uma chamada para o Sleep
método. O método suspende o segmento atualmente em execução para um determinado número

de milissegundos. Depois que esse intervalo expirar, Main é reativado, em que ponto ele exibe o
conteúdo da fila. Repete Main esta para quatro iterações, como este:
C#
for (int i=0; i<4; i++) { Thread.Sleep(2500); ShowQueueContents(queue); }
Finalmente, Main sinaliza a segmentos de trabalho para encerrar, chamar o Set método do evento
" do segmento de saída ", e chama o Join método em cada segmento de trabalho para bloquear o
segmento primário até que cada segmento do operador responder ao evento e termina.
Não é um exemplo final da sincronização do segmento: o ShowQueueContents método. Esse

método, como os segmentos consumidor e o Producer, usa lock para obter acesso exclusivo para
a fila. Nesse caso, entretanto, acesso exclusivo é particularmente importante, porque
ShowQueueContents. enumera em toda a coleção Enumerando sobre uma coleção é uma operação
que está especialmente propensa a corrupção de dados por operações assíncronas porque ela
envolve atravessando o conteúdo de toda a coleção. O ShowQueueContents método tem a seguinte
aparência:
C#
syncEvents.ExitThreadEvent.Set(); producerThread.Join(); consumerThread.Join();
Finalmente, observe que ShowQueueContents, porque ela é chamada por Main, é executado pelo
segmento primário. Isso significa que esse método, quando ele obtém acesso exclusivo à fila item,
na verdade está bloqueando os dois segmentos Producer e pelo consumidor de acessar a fila.
Bloqueia ShowQueueContents a fila e enumera o conteúdo:
C#
private static void ShowQueueContents(Queue<int> q) { lock (((ICollection)q).SyncRoot) { foreach (int item
in q) { Console.Write("{0} ", item); } } Console.WriteLine(); }
O exemplo completo segue.
Exemplo
C#
using System; using System.Threading; using System.Collections; using System.Collections.Generic; public
class SyncEvents { public SyncEvents() { _newItemEvent = new AutoResetEvent(false); _exitThreadEvent =
new ManualResetEvent(false); _eventArray = new WaitHandle[2]; _eventArray[0] = _newItemEvent;
_eventArray[1] = _exitThreadEvent; } public EventWaitHandle ExitThreadEvent { get { return
_exitThreadEvent; } } public EventWaitHandle NewItemEvent { get { return _newItemEvent; } } public
WaitHandle[] EventArray { get { return _eventArray; } } private EventWaitHandle _newItemEvent; private
EventWaitHandle _exitThreadEvent; private WaitHandle[] _eventArray; } public class Producer { public
Producer(Queue<int> q, SyncEvents e) { _queue = q; _syncEvents = e; } // Producer.ThreadRun public void
ThreadRun() { int count = 0; Random r = new Random(); while (!_syncEvents.ExitThreadEvent.WaitOne(0,
false)) { lock (((ICollection)_queue).SyncRoot) { while (_queue.Count < 20) {
_queue.Enqueue(r.Next(0,100)); _syncEvents.NewItemEvent.Set(); count++; } } }
Console.WriteLine("Producer thread: produced {0} items", count); } private Queue<int> _queue; private
SyncEvents _syncEvents; } public class Consumer { public Consumer(Queue<int> q, SyncEvents e) { _queue
= q; _syncEvents = e; } // Consumer.ThreadRun public void ThreadRun() { int count = 0; while
(WaitHandle.WaitAny(_syncEvents.EventArray) != 1) { lock (((ICollection)_queue).SyncRoot) { int item =

_queue.Dequeue(); } count++; } Console.WriteLine("Consumer Thread: consumed {0} items", count); }
private Queue<int> _queue; private SyncEvents _syncEvents; } public class ThreadSyncSample { private
static void ShowQueueContents(Queue<int> q) { lock (((ICollection)q).SyncRoot) { foreach (int item in q) {
Console.Write("{0} ", item); } } Console.WriteLine(); } static void Main() { Queue<int> queue = new
Queue<int>(); SyncEvents syncEvents = new SyncEvents(); Console.WriteLine("Configuring worker
threads..."); Producer producer = new Producer(queue, syncEvents); Consumer consumer = new
Consumer(queue, syncEvents); Thread producerThread = new Thread(producer.ThreadRun); Thread
consumerThread = new Thread(consumer.ThreadRun); Console.WriteLine("Launching producer and
consumer threads..."); producerThread.Start(); consumerThread.Start(); for (int i=0; i<4; i++) {
Thread.Sleep(2500); ShowQueueContents(queue); } Console.WriteLine("Signaling threads to terminate...");
syncEvents.ExitThreadEvent.Set(); producerThread.Join(); consumerThread.Join(); } }
Saída de exemplo
Configuring worker threads... Launching producer and consumer threads... 22 92 64 70 13 59 9 2 43 52 91
98 50 96 46 22 40 94 24 87 79 54 5 39 21 29 77 77 1 68 69 81 4 75 43 70 87 72 59 0 69 98 54 92 16 84 61
30 45 50 17 86 16 59 20 73 43 21 38 46 84 59 11 87 77 5 53 65 7 16 66 26 79 74 26 37 56 92 Signalling
threads to terminate... Consumer Thread: consumed 1053771 items Producer thread: produced 1053791
items
COMO: Usar um pool de threads (Guia de programação C#)
A pool de segmentos é uma coleção de segmentos que podem ser usados para executar um
número de tarefas em segundo plano. (Consulte Usando Threading Para obter informações
detalhadas.) Isso deixa o segmento primário livre para executar outras tarefas de forma
assíncrona.
Pools segmento geralmente são empregados em aplicativos de servidor. Cada solicitação de

entrada é atribuída a um segmento do pool do segmento, para a solicitação pode ser processada
de forma assíncrona, sem atrasar o processamento de solicitações subseqüentes amarrando
backup o segmento primário ou.
Depois que um segmento no pool conclui a tarefa, ele é retornado para uma fila de segmentos de
espera, onde ele pode ser reutilizado. Essa reutilização permite que aplicativos para evitar o custo
de criar um novo segmento para cada tarefa.
Pools segmento normalmente ter um número máximo de segmentos. Se estiver ocupados, todos
os segmentos tarefas adicionais são colocadas na fila até que eles podem ser atendidos medida
segmentos se tornam disponíveis.
Você pode implementar seu próprio pool do segmento, mas ele é mais fácil de usar o pool de
segmentos fornecido pelo .NET Framework por meio da ThreadPool classe.
O exemplo a seguir usa o pool de segmentos do .NET Framework para calcular o Fibonacci
resultado de dez números entre 20 e 40. Cada Fibonacci resultado é representado pela classe
Fibonacci, que fornece um método chamado ThreadPoolCallback que executa o cálculo. Um objeto
que representa cada valor Fibonacci é criado e é passado para QueueUserWorkItem o
ThreadPoolCallback método que atribui um segmento disponível no pool para executar o método.
Como cada Fibonacci objeto é dado um valor semi-Random para calcular, e como será cada um
dos segmentos dez ser competindo de Tempo processador, não há um meio para ser instruídos
com antecedência quanto tempo levará para todos os resultados dez deve ser calculado. É por
isso que cada Fibonacci objeto é passado uma instância da classe ManualResetEvent durante a

construção. Cada objeto sinaliza o objeto de evento fornecido quando seu cálculo estiver
concluído, que permite o segmento primário para execução de bloco com WaitAll até que todos os
objetos dez Fibonacci ter calculado um resultado. O Main método exibirá cada Fibonacci resultado.
Exemplo
C#
using System; using System.Threading; public class Fibonacci { public Fibonacci(int n, ManualResetEvent
doneEvent) { _n = n; _doneEvent = doneEvent; } // Wrapper method for use with thread pool. public void
ThreadPoolCallback(Object threadContext) { int threadIndex = (int)threadContext;
Console.WriteLine("thread {0} started...", threadIndex); _fibOfN = Calculate(_n);
Console.WriteLine("thread {0} result calculated...", threadIndex); _doneEvent.Set(); } // Recursive method
that calculates the Nth Fibonacci number. public int Calculate(int n) { if (n <= 1) { return n; } return
Calculate(n - 1) + Calculate(n - 2); } public int N { get { return _n; } } private int _n; public int FibOfN { get {
return _fibOfN; } } private int _fibOfN; private ManualResetEvent _doneEvent; } public class
ThreadPoolExample { static void Main() { const int FibonacciCalculations = 10; // One event is used for each
Fibonacci object ManualResetEvent[] doneEvents = new ManualResetEvent[FibonacciCalculations];
Fibonacci[] fibArray = new Fibonacci[FibonacciCalculations]; Random r = new Random(); // Configure and
launch threads using ThreadPool: Console.WriteLine("launching {0} tasks...", FibonacciCalculations); for
(int i = 0; i < FibonacciCalculations; i++) { doneEvents[i] = new ManualResetEvent(false); Fibonacci f = new
Fibonacci(r.Next(20,40), doneEvents[i]); fibArray[i] = f;
ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i); } // Wait for all threads in pool to calculation...
WaitHandle.WaitAll(doneEvents); Console.WriteLine("All calculations are complete."); // Display the
results... for (int i= 0; i<FibonacciCalculations; i++) { Fibonacci f = fibArray[i];
Console.WriteLine("Fibonacci({0}) = {1}", f.N, f.FibOfN); } } }
Saída de exemplo
launching 10 tasks... result calculated... result calculated... result calculated... result calculated... result
calculated... result calculated... result calculated... result calculated... result calculated... result calculated...
all calculations complete Fibonacci(22) = 17711 Fibonacci(25) = 75025 Fibonacci(32) = 2178309
Fibonacci(36) = 14930352 Fibonacci(32) = 2178309 Fibonacci(26) = 121393 Fibonacci(35) = 9227465
Fibonacci(23) = 28657 Fibonacci(39) = 63245986 Fibonacci(22) = 17711
COMO: Pesquisar em seqüências de caracteres utilizando expressões regulares (Guia de

programação C#)
A System.Text.RegularExpressions.Regex classe pode ser usada para procurar seqüências.

Essas pesquisas podem variar em complexidade de muito simples a fazer uso total de expressões
regulares. A seguir são dois exemplos de seqüência pesquisar usando a Regex classe. Para obter
mais informações, consulte Expressões regulares .NET Framework.
Exemplo
O código a seguir é um aplicativo de console que realiza uma pesquisa simples maiúsculas de
minúsculas das seqüências de caracteres em uma matriz. O método
System.Text.RegularExpressions.Regex.IsMatch(System.String,System.String,System.Text.Regul
arExpressions.RegexOptions) estático executa a pesquisa fornecida seqüência para pesquisar e
uma seqüência contendo o padrão de pesquisa. Nesse caso, um argumento terceiro é usado para
indicar que caso deve ser ignorado. Para obter mais informações, consulte
System.Text.RegularExpressions.RegexOptions.

C#
class TestRegularExpressions { static void Main() { string[] sentences = { "cow over the moon", "Betsy the
Cow", "cowering in the corner", "no match here" }; string sPattern = "cow"; foreach (string s in sentences) {
System.Console.Write("{0,24}", s); if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern,
System.Text.RegularExpressions.RegexOptions.IgnoreCase)) { System.Console.WriteLine(" (match for '{0}'
found)", sPattern); } else { System.Console.WriteLine(); } } } }
Saída
cow over the moon (match for 'cow' found) Betsy the Cow (match for 'cow' found) cowering in the corner
(match for 'cow' found) no match here
O código a seguir é um aplicativo de console que usa expressões regulares para validar o formato
da cada seqüência em uma matriz. A validação requer que cada seqüência assumem a forma de
um número de telefone no qual três grupos de dígitos são separados por hífen, os primeiros dois
grupos conter três dígitos, e o terceiro grupo contém quatro dígitos. Isso é feito com a expressão
^\\d{3}-\\d{3}-\\d{4}$ regular. Para obter mais informações, consulte Elementos de idioma de
expressões regulares.
C#
class TestRegularExpressionValidation { static void Main() { string[] numbers = { "123-456-7890", "444-
234-22450", "690-203-6578", "146-893-232", "146-839-2322", "4007-295-1111", "407-295-1111", "407-2-
5555", }; string sPattern = "^\\d{3}-\\d{3}-\\d{4}$"; foreach (string s in numbers) {
System.Console.Write("{0,14}", s); if (System.Text.RegularExpressions.Regex.IsMatch(s, sPattern)) {
System.Console.WriteLine(" - valid"); } else { System.Console.WriteLine(" - invalid"); } } } }
Saída
123-456-7890 - valid 444-234-22450 - invalid 690-203-6578 - valid 146-893-232 - invalid 146-839-2322 -
valid 4007-295-1111 - invalid 407-295-1111 - valid 407-2-5555 - invalid
COMO: Unir várias seqüências de caracteres (Guia de programação C#)
Há duas maneiras para ingressar em várias seqüências: usando o + operador que a String classe
overloads, e usando a StringBuilder classe. O + operador é fácil de usar e torna para intuitivo
código, mas ele funciona em seqüência; uma nova seqüência é criada para cada uso do operador,
portanto encadeamento vários operadores juntos é ineficiente. Por exemplo:
C#
string two = "two"; string str = "one " + two + " three"; System.Console.WriteLine(str);
Embora quatro seqüências aparecem no código, a três seqüências sendo associados e a

seqüência de caracteres que contém todos os três, final cinco seqüências são criadas no total
porque as primeiras duas seqüências estão associadas primeiro, criar uma seqüência contendo "
Um dois ". O terceiro é acrescentado separadamente, formando a seqüência de caracteres
armazenada no str final.
Como alternativa, a StringBuilder classe pode ser usada para adicionar cada seqüência a um
objeto que cria a seqüência final em uma etapa. Essa estratégia é demonstrada no exemplo a
seguir.
Exemplo

O código a seguir usa o método acréscimo da classe StringBuilder Para ingressar em três
seqüências sem o efeito do + operador Chaining.
C#
class StringBuilderTest { static void Main() { string two = "two"; System.Text.StringBuilder sb = new
System.Text.StringBuilder(); sb.Append("one "); sb.Append(two); sb.Append(" three");
System.Console.WriteLine(sb.ToString()); string str = sb.ToString(); System.Console.WriteLine(str); } }
COMO: Pesquisar em seqüências de caracteres utilizando métodos de String (Guia de

programação C#)
O Seqüência Tipo, que é um alias para a System.String classe, fornece um número de métodos
útil para pesquisar o conteúdo de uma seqüência. O exemplo a seguir utiliza e EndsWith
Métodos., StartsWith a IndexOf, LastIndexOf
Exemplo
C#
class StringSearch { static void Main() { string str = "A silly sentence used for silly purposes.";
System.Console.WriteLine("'{0}'",str); bool test1 = str.StartsWith("a silly");
System.Console.WriteLine("starts with 'a silly'? {0}", test1); bool test2 = str.StartsWith("a silly",
System.StringComparison.OrdinalIgnoreCase); System.Console.WriteLine("starts with 'a silly'? {0} (ignoring
case)", test2); bool test3 = str.EndsWith("."); System.Console.WriteLine("ends with '.'? {0}", test3); int first =
str.IndexOf("silly"); int last = str.LastIndexOf("silly"); string str2 = str.Substring(first, last - first);
System.Console.WriteLine("between two 'silly' words: '{0}'", str2); } }
Saída
'A silly sentence used for silly purposes.' starts with 'a silly'? False starts with 'a silly'? True (ignore case)
ends with '.'? True between two 'silly' words: 'silly sentence used for '
COMO: Analisar seqüências usando o método Split (Guia de programação C#)
O exemplo de código a seguir demonstra como uma seqüência pode ser analisado usando o
System.String.Split método. Esse método funciona, retornando uma matriz de seqüências, onde
cada elemento é uma palavra. Como entrada, Split leva uma matriz de caracteres que indicam
quais caracteres são a ser usado como delimitadores. Neste exemplo, espaços, vírgulas, pontos,
dois-pontos, e guias são usados. Uma matriz contendo esses delimitadores é passado para Split,
e cada palavra na frase será exibida separadamente usando a matriz de seqüências de caracteres
resultante.
Exemplo
C#
class TestStringSplit { static void Main() { char[] delimiterChars = { ' ', ',', '.', ':', '\t' }; string text = "one\ttwo
three:four,five six seven"; System.Console.WriteLine("Original text: '{0}'", text); string[] words =
text.Split(delimiterChars); System.Console.WriteLine("{0} words in text:", words.Length); foreach (string s
in words) { System.Console.WriteLine(s); } } }
Saída
Original text: 'one two three:four,five six seven' 7 words in text: one two three four five six seven
COMO: Criar uma união C/C++ usando atributos (Guia de programação C#)

Usando atributos Você pode personalizar como estruturas são dispostas na memória. Por
exemplo, você pode criar o que é conhecido como uma união em C/C usando e FieldOffset
Atributos. o StructLayout(LayoutKind.Explicit)
Exemplo
Nesse segmento de código, todos os campos de TestUnion início no mesmo local na memória.
C#
[System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)] struct TestUnion {
[System.Runtime.InteropServices.FieldOffset(0)] public int i;
[System.Runtime.InteropServices.FieldOffset(0)] public double d;
[System.Runtime.InteropServices.FieldOffset(0)] public char c;
[System.Runtime.InteropServices.FieldOffset(0)] public byte b; }
A seguir é outro exemplo onde início campos em diferente explicitamente configurar locais.
C#
[System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)] struct TestExplicit {
[System.Runtime.InteropServices.FieldOffset(0)] public long lg;
[System.Runtime.InteropServices.FieldOffset(0)] public int i1;
[System.Runtime.InteropServices.FieldOffset(4)] public int i2;
[System.Runtime.InteropServices.FieldOffset(8)] public double d;
[System.Runtime.InteropServices.FieldOffset(12)] public char c;
[System.Runtime.InteropServices.FieldOffset(14)] public byte b; }
Os dois int campos, i1 e i2, compartilhar os mesmos locais como lg de memória. Esse tipo de
controle sobre layout struct é útil quando usando invocação de plataforma.
COMO: Criar e usar DLLs em C# (Guia de programação C#)
Uma biblioteca de vínculo dinâmica (DLL) está vinculada ao seu programa em tempo de
execução. Para demonstrar Criando e usando uma DLL, considere o seguinte cenário:
• MathLibrary.DLL o arquivo de biblioteca que contém os métodos para ser chamado em

tempo de execução. Neste exemplo, a DLL contém dois métodos, Add e Multiply.
• Add.cs o arquivo de origem que contém o método Add(long i, long j). Ela retorna a soma de
seus parâmetros. A classe AddClass que contém o método Add é um membro do espaço para
nome UtilityMethods.
• Mult.cs o código fonte que contém o método Multiply(long x, long y). Ele retorna o produto
de seus parâmetros. A classe MultiplyClass que contém o método Multiply é também um
membro do espaço para nome UtilityMethods.
• TestCode.cs o arquivo que contém o Main método. Ele usa os métodos no arquivo DLL para
calcular a soma e o produto dos argumentos em tempo de execução.
Exemplo
C#
// File: Add.cs namespace UtilityMethods { public class AddClass { public static long Add(long i, long j) {
return (i + j); } } }

C#
// File: Mult.cs namespace UtilityMethods { public class MultiplyClass { public static long Multiply(long x,
long y) { return (x * y); } } }
C#
// File: TestCode.cs using UtilityMethods; class TestCode { static void Main(string[] args) {
System.Console.WriteLine("Calling methods from MathLibrary.DLL:"); if (args.Length != 2) {
System.Console.WriteLine("Usage: TestCode <num1> <num2>"); return; } long num1 = long.Parse(args[0]);
long num2 = long.Parse(args[1]); long sum = AddClass.Add(num1, num2); long product =
MultiplyClass.Multiply(num1, num2); System.Console.WriteLine("{0} + {1} = {2}", num1, num2, sum);
System.Console.WriteLine("{0} * {1} = {2}", num1, num2, product); } }
Este arquivo contém o algoritmo que usa os métodos DLL, Add e Multiply. Começar com analisar
os argumentos inseridos da linha de comando, num1 e num2. Ele calcula a soma, usando o Add
método na classe AddClass, e o produto usando o Multiply método na classe MultiplyClass.
Observe que a using diretiva no início do arquivo permite-lhe usar a classe não qualificado nomes
para consultar os métodos DLL ao tempo de compilação, da seguinte maneira:
C#
MultiplyClass.Multiply(num1, num2);
Caso contrário, você terá para usar os nomes totalmente qualificados, da seguinte maneira:
C#
UtilityMethods.MultiplyClass.Multiply(num1, num2);
Execução
Para executar o programa, digite o nome do arquivo exe, seguido por dois números, da seguinte
maneira:
TestCode 1234 5678
Saída
Calling methods from MathLibrary.DLL: 1234 + 5678 = 6912 1234 * 5678 = 7006652
Para criar o arquivo MathLibrary.DLL, compilar os dois arquivos Add.cs e Mult.cs Usando a linha de
comando a seguir:
csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
A /Target:Library opção de compilador informa o compilador para dar saída uma DLL em vez de
um arquivo EXE. A / Fora opção de compilador seguida por um nome de arquivo é utilizada para
especificar o nome do arquivo DLL Caso contrário, o compilador usa o primeiro arquivo (Add.cs.)
como o nome da DLL
Para criar o arquivo executável, TestCode.exe, use a seguinte linha de comando:
csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs

A /out opção de compilador informa o compilador para produzir saída de um arquivo EXE e
especifica o nome do arquivo de saída). (TestCode.exe Esta opção de compilador é opcional. A
/Reference opção de compilador Especifica o arquivo DLL ou arquivos que usa este programa.
COMO: Determinar se um arquivo é um módulo (assembly) (Guia de programação C#)
Um arquivo é um conjunto se e somente se ele é gerenciada, e contém uma entrada do conjunto

nos seus metadados. Para obter mais informações sobre conjuntos e metadados, consulte o
tópico Manifesto do Assembly.
Como determinar se um arquivo é um conjunto manualmente

1. Iniciar o Disassembler MSIL (Ildasm.exe).
2. Carregar o arquivo que deseja testar.
3. Se ILDASM, arquivo relatórios não que o arquivo é um executável portátil (PE), ele é um
conjunto não. Para obter mais informações, consulte o tópico Como Visualizar o Conteúdo
de um Assembly.
Como determinar se um arquivo é um conjunto programaticamente
1. Chame o GetAssemblyName método, passando o caminho de arquivo completo e nome
do arquivo que você está testando.
2. Se uma BadImageFormatException exceção é acionada, o arquivo é um conjunto não.
Exemplo
Este exemplo testa uma DLL para verificar se ele é um conjunto.
C#
class TestAssembly { static void Main() { try { System.Reflection.AssemblyName testAssembly =
System.Reflection.AssemblyName.GetAssemblyName(@"C:\WINDOWS\system\avicap.dll");
System.Console.WriteLine("Yes, the file is an Assembly."); } catch (System.IO.FileNotFoundException e) {
System.Console.WriteLine("The file cannot be found."); } catch (System.BadImageFormatException e) {
System.Console.WriteLine("The file is not an Assembly."); } catch (System.IO.FileLoadException e) {
System.Console.WriteLine("The Assembly has already been loaded."); } } }
O GetAssemblyName método carrega o arquivo de teste, e depois libera ele depois que as
informações é leitura.
Saída
The file is not an Assembly.
COMO: Carregar e descarregar módulos (assemblies) (Guia de programação C#)
As montagens referenciadas por seu programa automaticamente será carregadas ao tempo de

criação, mas também é possível carregar conjuntos específicos para o domínio do aplicativo atual
em tempo de execução. Para obter mais informações, consulte Domínios de aplicativo.
Não há um meio para descarregar um conjunto individual sem descarregar todos os domínios de
aplicativos que contêm ele. Mesmo se o conjunto sai do escopo, o arquivo de montagem real
permanecerá carregado até que todos os domínios de aplicativos que contêm ele sejam
descarregados.

Se você desejar descarregar alguns conjuntos mas não outros, considere criar um novo domínio
do aplicativo executar o código dentro desse domínio, e então descarregar desse domínio do
aplicativo. Para obter mais informações, consulte Como executar código em outro domínio de
aplicativo:.
Para carregar um conjunto em um domínio de aplicativo

• Use uma das várias a carregar métodos contidos nas classes AppDomain e
System.Reflection. Para obter mais informações, consulte Carregar conjuntos em um domínio
de aplicativo.
Para descarregar um domínio de aplicativo
• Não há um meio para descarregar um conjunto individual sem descarregar todos os
domínios de aplicativos que contêm ele. Use o Unload método do AppDomain para
descarregar os domínios de aplicativo. Para obter mais informações, consulte Descarregar um
domínio de aplicativo.
COMO: Compartilhar um módulo (assembly) com outros aplicativos (Guia de programação

C#)
Conjuntos podem ser privado nem compartilhada: Por padrão, simples maioria dos programas C#
consistir de um conjunto particular porque eles não se destinam a ser usado por outros aplicativos.
Para compartilhar um conjunto com outros aplicativos, ele deve ser colocado no (GAC Cache
global de assembly ).
Compartilhar um conjunto
1. Criar seu conjunto. Para obter mais informações, consulte Criando conjuntos.
2. Atribuir um nome de alta segurança a seu conjunto. Para obter mais informações, consulte
COMO: Assinar uma Assembly com Nome Forte.
3. Atribuir informações de versão a seu conjunto. Para obter mais informações, consulte
Versionamento de assembly.
4. Incluir seu conjunto para o cache assembly global. Para obter mais informações, consulte
Como Instalar um Assembly na Cache Global de Assemblies.
5. Acessar os tipos contidos no conjunto dos outros aplicativos. Para obter mais informações,
consulte Como Referenciar um Assembly de Nome Forte.
Executar código em outro domínio de aplicação (Guia de programação
C#)
Depois que um conjunto tenha sido carregado em um domínio de aplicativo, ele contém o código
pode ser executado. A maneira mais simples para fazer isso é para usar AssemblyLoad qual irá
carregar o conjunto para o domínio de aplicativos atual, e começar a execução do código em
ponto de entrada padrão do conjunto.
Se você desejar carregar o conjunto em outro domínio de aplicativo, use ExecuteAssembly ou

ExecuteAssemblyByName. ou uma da outra o sobrecarregado versões um desses métodos
Se você deseja executar o outro conjunto começando no ponto de entrada padrão, além de definir
um novo tipo no conjunto remoto, derivar de MarshalByRefObject. Usar CreateInstance para criar
uma instância do tipo do seu aplicativo.

Considere arquivo a seguir, que cria um conjunto que consiste em um espaço para nome único e
duas classes. Suponha que este conjunto de módulos (assembly) tenha sido criado, e é
armazenada no disco C com o nome HelloWorldRemote.exe.
C#
// This namespace contains code to be called. namespace HelloWorldRemote { public class RemoteObject :
System.MarshalByRefObject { public RemoteObject() { System.Console.WriteLine("Hello, World!
(RemoteObject Constructor)"); } } class Program { static void Main() { System.Console.WriteLine("Hello,
World! (Main method)"); } } }
Para acessar o código de outro aplicativo, você pode tanto carregar o conjunto para o domínio de
aplicativo atual ou criar um novo domínio de aplicativo e carregar o conjunto para ela Se você
carregar o conjunto no domínio de aplicativo atual com Assembly.LoadFrom, você pode usar
Assembly.CreateInstance para criar uma instância da classe RemoteObject, que faz o
Construtor de objeto a ser executado
C#
static void Main() { // Load the assembly into the current appdomain: System.Reflection.Assembly
newAssembly = System.Reflection.Assembly.LoadFrom(@"c:\HelloWorldRemote.exe"); // Instantiate
RemoteObject: newAssembly.CreateInstance("HelloWorldRemote.RemoteObject"); }
Ao carregar o conjunto em um domínio de aplicativos separados, usar

AppDomain.ExecuteAssembly para acessar o ponto de entrada padrão ou
AppDomain.CreateInstance Para criar uma instância da classe RemoteObject. Criar a instância
faz o construtor para ser executado.
C#
static void Main() { System.AppDomain NewAppDomain =
System.AppDomain.CreateDomain("NewApplicationDomain"); // Load the assembly and call the default
entry point: NewAppDomain.ExecuteAssembly(@"c:\HelloWorldRemote.exe"); // Create an instance of
RemoteObject: NewAppDomain.CreateInstanceFrom(@"c:\HelloWorldRemote.exe",
"HelloWorldRemote.RemoteObject"); }
Se você não faça desejar carregar o conjunto programaticamente, use Add Reference de para
especificar o conjunto HelloWorldRemote.exe. o Solution Explorer Em seguida, adicionar uma
using HelloWorldRemote; diretiva para o Usando Bloco de seu aplicativo, e usar o RemoteObject
tipo no seu programa para declarar uma instância do objeto RemoteObject, como este:
C#
static void Main() { // This code creates an instance of RemoteObject, assuming HelloWorldRemote has been
added as a reference: HelloWorldRemote.RemoteObject o = new HelloWorldRemote.RemoteObject(); }
COMO: Criar e usar um domínio de aplicação (Guia de programação C#)
Domínios de aplicativo fornecem um método de isolar o código para fins de segurança e

desempenho. Para obter mais informações, consulte Domínios de aplicativo (guia de programação
C#).
Usando um domínio de aplicativo

1. Criar o domínio de aplicativo. O host Runtime de idioma comum cria um domínio de
aplicativo para automaticamente seu aplicativo. Para informações, consulte o tópico Como:
Criar um domínio de aplicativo.
2. Configure o domínio de aplicativo. Para obter mais informações, consulte Como Configurar
um Domínio de Aplicativo.
3. Carregar um conjunto no domínio de aplicativo. Para obter mais informações, consulte
Como Carregar Assemblies em um Domínio de Aplicativo.
4. Acessar o Conteúdo do outro conjunto. Para obter mais informações, consulte Executar
código em outro domínio de aplicação (Guia de programação C#).
5. Descarregar o domínio do aplicativo. Para obter mais informações, consulte Como:
Descarregar um domínio de aplicativo.
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
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.
Nesta seção
Anônimo exemplo Demonstra o uso de representantes para reduzir a complexidade de

Coleção exemplo Mostra como fazer classes coleção Generic não-que podem ser usados

implementação de
saudação
Indexado exemplo Mostra como a implementar uma classe que usa propriedades
palavras-chave.
coleção.
Interop COM
Interop COM
programas.
exemplo

não seguros
documentação XML

.NET Framework (Como Fazer em C#)
Esta página contém links para a Ajuda sobre tarefas do .NET Framework amplamente usadas.
Para ver outras categorias de tarefas populares abordadas na Ajuda, consulte Como Fazer em
C#.
Gerais
Introdução à Linguagem C# e ao .NET Framework
Descreve o relacionamento entre a linguagem C# e as bibliotecas de classe do .NET

Framework e o mecanismo de execução de tempo de execução.
Visão Geral sobre o .NET Framework
Fornece uma visão geral conceitual dos recursos chave do .NET Framework, incluindo o
Common Language Runtime, a biblioteca de classes do .NET Framework e a
interoperabilidade entre linguagens.
Localizador Rápido de Tecnologia
Fornece uma referência rápida para as principais áreas de tecnologia do .NET Framework.
E/S de Arquivo
Como Criar uma Listagem de Diretório
Cria um novo diretório.
Como Ler de e Escrever em um Arquivo de Dados Recém-criado
Lê de e escreve em um arquivo de dados recém-criado.
Como Abrir e Anexar em um Arquivo de Log
Abre e anexa em um arquivo de log.
Como Escrever Texto em um Arquivo
Escreve texto em um arquivo.
Como Ler Texto de um Arquivo
Lê texto de um arquivo.
Como Ler Caracteres de uma Seqüência de Caracteres
Lê caracteres de uma seqüência de caracteres.
Como Escrever Caracteres em uma Seqüência de Caracteres
Escreve caracteres em uma seqüência de caracteres.

Como Adicionar ou Remover Entradas da Lista de Controle de Acesso
Adiciona ou remove entradas da Lista de Controle de Acesso (ACL) para aumentar a

segurança.
Seqüências de Caracteres
Criando Novas Seqüências de Caracteres
Como criar uma nova seqüência de caracteres.
Aparando e Removendo Caracteres
Como remover caracteres do início ou do final de uma seqüência de caracteres.
Preenchendo Seqüências de Caracteres
Como adicionar tabulações ou espaços ao início ou ao final de seqüências de caracteres.
Comparando Seqüências de Caracteres
Como verificar a igualdade de duas seqüências de caracteres.
Alterando a Caixa
Como alterar letras em maiúsculo para letras em minúsculo e visse-versa.
Usando a Classe StringBuilder
Técnicas eficientes de manipulação de seqüências de caracteres.
Como Executar Manipulações sobre Seqüência de Caracteres Usando Operações Básicas
Como dividir seqüências, acrescentar uma seqüência a outra e mais.
Como Converter Tipos de Dados Usando System.Convert
Contém um exemplo que usa a classe Convert para transformar um valor string em um
valor booleano.
Como Remover Caracteres Inválido de uma Seqüência de Caracteres
Contém um exemplo que usa o método estático Regex.Replace para remover caracteres
inválidos de uma seqüência de caracteres.
Como Verificar se Seqüências de Caracteres Estão em um Formato de Email Válido
Contém um exemplo que usa o método estático Regex.IsMatch para verificar se uma
seqüências de caracteres está em um formato de email válido.
Coleções
Coleções e Estruturas de Dados
Visão geral das classes de coleção do .NET Framework.

Selecionando uma Classe de Coleção
Como escolher que tipo de coleção usar.
Quando Usar Coleções Genéricas
Explica as vantagens de classes de coleção genéricas sobre classes coleção não-

genéricas.
System.Collections.Generic
Página de portal das classes da coleção genéricas.
List
Fornece exemplos de código mostrando como adicionar e remover itens de uma coleção
List<T>.
SortedDictionary
Fornece exemplos de código mostrando como adicionar e remover pares chave/valor de

uma coleção SortedDictionary<K,V>.
Exceções
Como Usar Exceções Específicas em um Bloco Catch
Contém um exemplo que usa um bloco try/catch para captura uma InvalidCastException.
Como Usar o Bloco Try/Catch para Capturar Exceções
Contém um exemplo que usa um bloco try/catch para capturar uma possível exceção.
Como Criar Exceções Definida pelo Usuário
Contém um exemplo onde uma nova classe de exceção,

EmployeeListNotFoundException, é derivada de Exception.
Como Usar Blocos Finally
Contém um exemplo que usa um bloco try/catch para capturar uma exceção
ArgumentOutOfRangeException.
Como Lançar Exceções Explicitamente
Contém um exemplo que usa um bloco try/catch para detectar uma possível exceção
FileNotFoundException.
Eventos
Como Consumir Eventos em um Aplicativo do Windows Forms
Contém exemplos que mostram como tratar um evento de clique botão em um Windows
Form.
Como Conectar Métodos de Manipulação de Eventos a Eventos

Contém exemplos que mostram como adicionar um método que manipula um evento a um
evento.
Como Gerar e Consumir Eventos
Contém um exemplo que usa conceitos descritos em detalhes em Eventos e Delegates e

Gerando um Evento.
Como Manipular Vários Eventos Usando Propriedades de Evento
Contém um exemplo que mostrar como manipular vários eventos usando propriedades de
evento.
Como Implementar Eventos em sua Classe
Contém procedimentos que descrevem como implementar um evento em uma classe.
Depuração
Consulte Depuração (Como Fazer em C#).
Implantação
Consulte Segurança (Como Fazer em C#).
Serviced Components
Como Criar um Gerenciador de Recursos de Compensação (CRM)
Inclui exemplos de código para mostrar como criar um Gerenciador de Recursos de

Compensação
Como Criar um Serviced Component
Contém um procedimento que descreve como criar um novo serviced component.
Como Aplicar o Atributo Description a um Assembly
Mostra como aplicar o atributo DescriptionAttribute para definir a descrição de um

assembly.
Como Usar os Métodos SetAbort e SetComplete
Mostra como usar os métodos estáticos SetComplete e SetAbort da classe ContextUtil.
Como Aplicar o Atributo ApplicationID a um Assembly
Mostra como aplicar o atributo ApplicationID a um assembly.
Como Criar um Objeto de Pool e Definir seus Limites de Tamanho e de Tempo
Mostra como criar um objeto de pool e definir seus limites de tamanho e de tempo.
Como criar um Método de Web Service que Usa Transações Automáticas

Descreve como criar um método de Web Service que usa transações automáticas.
Como Definir a Propriedade SoapRoot Property para um Aplicativo
Mostra como definir a propriedade SoapVRoot como "MyVRoot".
Como Definir o Tempo Limite da Transação
Mostra como configurar o tempo limite da transação para 10 segundos.
Como Definir o Nome do Aplicativo Usando o Atributo ApplicationName
Mostra como fornecer o nome do aplicativo usando o atributo ApplicationName a nível de

assembly.
Como Usar o Recurso BYOT (Bring Your Own Transaction - Traga sua Própria Transação) do
COM+
Contém procedimentos que mostram como uma classe derivada da classe

ServicedComponent pode usar o recurso BYOT do COM+ para acessar um coordenador
de transações distribuídas (DTC).
Como Criar um Componente Privado
Mostra como usar o atributo PrivateComponentAttribute em uma classe.
Como Definir o Tipo de Ativação de um Aplicativo
Mostra como definir o tipo de ativação para "server".
Como Habilitar Sincronização em Instâncias de uma Classe
Mostra como para habilitar sincronização em instâncias da classe TestSync.
Como Usar Transações Automáticas em uma Classe do .NET Framework
Descreve como preparar uma classe para participar de uma transação automática.
Como Habilitar Ativação JIT
Mostra como habilitar ativação e desativação JIT dentro e fora de uma classe.
Como Definir o Atributo AutoComplete em uma Classe Transaction-Aware
Mostra o posicionamento do atributo AutoComplete em uma classe transaction-aware.
Como Implementar um Componente Enfileirado que Exibe uma Mensagem de Forma Assíncrona
Demonstra como implementar um componente enfileirado que exibe uma mensagem de

forma assíncrona.
Como Implementar Eventos Fracamente Acoplados

Contém procedimentos que mostram como implementar uma classe de eventos e um
coletor de eventos que implementam uma interface de eventos comum e mais um
publisher para acionar o evento.
Como Configurar a Construção de Objetos
Contém um procedimento e um exemplo que descrevem como configurar a construção de

objetos e definir a seqüência de inicialização padrão da classe TestObjectConstruct para
a seqüência "Initial Catalog=Northwind;Data
Source=.\\SQLServerInstance;Trusted_Connection=yes".
Assemblies e Domínios de Aplicativos

Como Obter Informações de Tipo e Membros de um Assembly
Contém um exemplo que obtém informações de tipo e membro de um assembly.
Como Criar um Assembly de Arquivo Único
Contém um procedimento que mostra como criar assemblies de arquivo único usando
compiladores de linha de comando.
Como criar um Domínio de Aplicativo
Cria um novo domínio de aplicativo, atribui o nome MyDomain e, em seguida, imprime no

console o nome do domínio do host e do domínio do aplicativo filho recém-criado.
Como Determinar o Nome Totalmente Qualificado de um Assembly
Mostra como exibir o nome totalmente qualificado de um assembly contendo uma classe
especificada para o console.
Como Configurar um Domínio de Aplicativo
Cria uma instância da classe AppDomainSetup, usa essa classe para criar um novo
domínio de aplicativo, escreve as informações no console e descarrega o domínio de
aplicativo.
Como Visualizar o Conteúdo de um Assembly
Contém um exemplo que começa com um programa "Hello, World " básico e mostra como
usar ILDASM.exe para desmontar o assembly Hello.exe e exibir o manifesto do assembly.
Como Referenciar um Assembly de Nome Forte
Cria um assembly chamado myAssembly.dll que referencia um assembly de nome forte

chamado myLibAssembly.dll a partir de um módulo de código chamado myAssembly.CS.
Como Descarregar um Domínio de Aplicativo
Cria um novo domínio de aplicativo chamado MyDomain, imprime algumas informações no

console e, em seguida, descarrega o domínio de aplicativo.
Como Remover um Assembly de Cache Global de Assemblies

Contém um exemplo que remove um assembly chamado Hello.dll da cache global de
assemblies.
Como Instalar um Assembly na Cache Global de Assemblies
Contém um exemplo que instala um assembly chamado Hello.dll na cache global de

assemblies.
Como Criar um Assembly de Múltiplos Arquivos
Descreve o procedimento usado para criar um assembly de múltiplos arquivos e fornece

um exemplo completo que ilustra cada uma das etapas do procedimento.
Como Carregar Assemblies em um Domínio de Aplicativo
Contém um exemplo que carrega um assembly no domínio de aplicativo atual e, em

seguida, executa o assembly.
Como Assinar um Assembly com um Nome Forte
Contém um exemplo que assina o assembly MyAssembly.dll com um nome forte usando o
arquivo chave sgKey.snk.
Como Visualizar o Conteúdo da Cache Global de Assemblies
Mostra como usar a ferramenta Global Assembly Cache (Gacutil.exe) para exibir o
conteúdo da cache global de assemblies.
Como Criar um par de chaves Public/Private
Mostra como assinar um assembly com um nome forte e como criar um par de chaves
usando a ferramenta Strong Name (Sn.exe).
Interoperação
Como Incorporar Bibliotecas de Tipo como Recursos Win32 em Aplicativos Baseados no .NET
Mostra como incorporar uma biblioteca de tipos como um recurso Win32 em um aplicativo
baseado no .NET Framework.
Como Gerar Assemblies de Interoperabilidade Primários Usando Tlbimp.exe
Fornece exemplos que mostram como gerar assemblies de interoperabilidade primários

usando Tlbimp.exe.
Como Criar Assemblies de Interoperabilidade Primários Manualmente
Fornece um exemplo que mostra como criar assemblies de interoperabilidade primários

manualmente.
Como Gerar Assemblies de Interoperabilidade a partir de Bibliotecas de Tipo
Fornece exemplos que mostram como gerar um assemblies de interoperabilidade a partir

de uma biblioteca tipo.

Como Gerar Eventos Manipulados por um Coletor COM
Fornece um exemplo que mostra um servidor gerenciado como a fonte do evento e um

cliente COM como o coletor do evento.
Como Personalizar Wrappers Invocáveis em Tempo de Execução
Mostra como personalizar wrappers invocáveis em tempo de execução modificando a fonte

IDL ou modificando um assembly importado.
Como Configurar Componentes Baseado em .NET para Habilitar Livre Registro
Explica como configurar componentes baseados no .NET Framework para habilitar Livre
Registro
Como Implementar Funções CallBack
Demonstra como um aplicativo gerenciado, usando invocação de plataforma, pode

imprimir o valor de identificador para cada janela do computador local
Como Mapear HRESULTs e Exceções
Contém um exemplo que mostra como criar uma nova classe de exceção chamada
NoAccessException e mapeá-la ao HRESULT E_ACCESSDENIED.
Como Editar Assemblies de Interoperabilidade
Demonstra como especificar alterações de empacotamento na Microsoft Intermediate

Language (MSIL).
Como Adicionar Referências a Bibliotecas de Tipo
Explica as etapas para adicionar uma referência a uma biblioteca de tipos.
Como Manipular Eventos Gerados por uma Fonte COM
Inclui um exemplo que demonstrar como abrir uma janela do Internet Explorer e como
amarrar eventos gerados pelo objeto InternetExplorer a manipuladores de eventos
implementados em código gerenciado.
Como Criar Wrappers Manualmente
Mostra um exemplo da interface ISATest e da classe SATest em IDL e os tipos

correspondentes no código fonte C#.
Como Registrar Assemblies de Interoperabilidade Primários
Inclui um exemplo que mostra como registrar o assembly de interoperabilidade primário

CompanyA.UtilLib.dll.
Como Empacotar Várias Versões de Bibliotecas de Tipos
Explica como empacotar mais de uma versão de uma biblioteca de tipos.
Segurança

Consulte Segurança (Como Fazer em C#).
Serialização
Como Desserializar um Objeto
Fornece um exemplo que desserializa um objeto em um arquivo.
Como Usar Ferramenta de Definição de Esquema XML para Gerar Classes e Documentos de
Esquema XML
Fornece procedimentos para mostrar como usar a ferramenta de definição de esquema

XML para gerar classes e documentos de esquema XML.
Como Especificar um Nome de Elemento Alternativo para um Fluxo XML
Mostra como você pode gerar mais de um fluxo de XML com o mesmo conjunto de
classes.
Como Controlar a Serialização de Classes Derivadas
Fornece um exemplo que mostrar como controlar a serialização de classes derivadas.
Como Serializar um Objeto como um Fluxo XML de Codificação SOAP
Fornece um procedimento e um exemplo para serializar um objeto como um fluxo de XML

de Codificação SOAP.
Como Particionar Dados Serializados
Fornece um procedimento e um exemplo para implementar particionamento do lado do

servidor e
processamento do lado do cliente.
Como Serializar um Objeto
Fornece um procedimento para serializar um objeto.
Como Qualificar um Elemento XML e Nomes Atributos XML
Fornece um procedimento e um exemplo para criar nomes qualificados em um documento

XML.
Como Substituir a Serialização SOAP XML Codificada
Fornece um procedimento e um exemplo para substituir serialização de objetos como

mensagens SOAP.
Codificação e Localização
Como Analisar Dígitos Unicode
Fornece um exemplo que usa o método Decimal.Parse para analisar seqüências de

caracteres de valores Unicode que especificam dígitos em scripts diferentes.

Como Criar Culturas Personalizadas
Fornece um procedimento para definir e criar um cultura personalizada.
Programação Avançada
Como Definir e Executar Métodos Dinâmicos
Mostra como definir e executar um método dinâmico simples e um método dinâmico ligado
a uma instância de uma classe.
Como Examinar e Instanciar Tipos Genéricos com Reflexão
Fornece procedimentos que mostram como descobrir e manipular tipos genéricos.
Como Definir um Método genérico com Emissão de Reflexão
Fornece procedimentos que mostram como definir um método genérico com emissão de
reflexão.
Como Usar Assinatura Completa para Dar a um Assembly Dinâmico um Nome Forte
Demonstra o uso de assinatura completa para dar um assembly dinâmico um nome forte.
Como Carregar Assemblies no Contexto Somente de Reflexão
Fornece um procedimento e um exemplo de código para mostrar como carregar

assemblies no contexto somente de reflexão.
Como Definir um Tipo Genérico com Emissão de Reflexão
Mostra como criar um tipo genérico simples com dois parâmetros de tipo, como aplicar
restrições de classe, restrições de interface e restrições especiais aos parâmetros de tipo e
como criar membros que usam os parâmetros de tipo de uma classe como tipos de
parâmetros e tipos de retorno.
Explicações Passo-a-passo do .NET Framework SDK

Passo-a-passo: Adicionando Marcas Inteligentes a um Componente do Windows Forms
Demonstra como adicionar marcas inteligentes usando código de um controle de exemplo

simples, ColorLabel, que é derivado do controle padrão Windows Forms Label
Passo-a-passo: Alterando a Mensagem SOAP Usando Extensões SOAP
Mostra como criar e executar uma extensão SOAP.
Passo-a-passo: Construindo um XML Web Service Básico Usando ASP.NET
Demonstra como criar um XML Web Services básico usando ASP.NET.
Passo-a-passo: Personalização para Dispositivos Específicos
Demonstra como personalizar dispositivos específicos.
Passo-a-passo: Personalizando a Geração de Descrições de Serviços e Classes Proxy

Demonstra como personalizar a geração de descrições de serviços e classes proxy.
Passo-a-passo: Implantando um Aplicativo ClickOnce Manualmente
Descreve as etapas necessárias para criar uma implantação ClickOnce completa usando a
versão de linha de comando ou gráfica da ferramenta de Geração e Edição de Manifesto
(Manifest Generation and Editing - Mage).
Passo-a-passo: Fazendo o Download de Assemblies por Demanda com a API de Implantação do

ClickOnce
Demonstra como marcar determinados assemblies em seu aplicativo como "optional"

(opcional) e como fazer o download dos mesmos usando classes no namespace
System.Deployment.Application quando a Common Language Runtime (clr) os requer.
Passo-a-passo: Implementando um Editor de Tipos de Interface do Usuário
Explica como criar seu próprio editor de tipos de interface do usuário para um tipo
personalizado e como exibir a interface de edição usando um PropertyGrid.
Recursos adicionais
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 novos conteúdos.
Visual C# Developer Center
Contém vários artigos e recursos sobre o desenvolvimento de aplicativos em C#. Este site
é atualizado regularmente com novos conteúdos.
Microsoft .NET Framework Developer Center
Contém vários artigos e recursos sobre desenvolvimento e a depuração de aplicativos no

.NET Framework. Este site é atualizado regularmente com novos conteúdos.

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.
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.
Estes são recursos adicionais do C#:
• Para uma boa introdução geral da linguagem, consulte o Capítulo 1 da Especificação da

Linguagem C#.
• Para obter informações detalhadas sobre aspectos específicos da linguagem C#, consulte
a Referência C#.
• Para uma comparação da sintaxe C# com a de Java e C++, consulte A linguagem de
programação C# para desenvolvedores Java e Comparação entre C++ e C#.
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.

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".
Para obter mais informações sobre a plataforma .NET Framework, consulte Visão geral sobre o
.NET Framework.
Visão geral sobre o .NET Framework

Esta seção fornece uma visão geral conceitual dos recursos chave do .NET Framework, incluindo
o Common Language Runtime, a biblioteca de classes do .NET Framework, e interoperabilidade
entre linguagens.
Visão Geral Conceitual Sobre o .NET Framework

O .NET Framework é um componente integral do Windows que oferece suporte à criação e
execução da próxima geração de aplicativos e Serviços XML da Web. O .NET Framework foi
criado para atender os seguintes objetivos:

• Para fornecer um ambiente de programação orientada a objetos consistente, se o código
objeto for armazenado e executado localmente, executado localmente mas distribuído pela
Internet ou executado remotamente.
• Para fornecer um ambiente da execução de código que minimiza conflitos de implantação
e versionamento de software.
• Para fornecer um ambiente da execução que promova a execução segura do código,
incluindo o código criado por terceiros: desconhecidos ou semi-confiáveis.
• Para fornecer um ambiente da execução que elimina os problemas de desempenho dos
ambientes interpretados ou com scripts.
• Para tornar a experiência do desenvolvedor consistente, através dos diversos tipos de
aplicativos, como aplicativos baseados no Windows e aplicativos baseados na Web.
• Para criar todas as comunicações nas indústrias padrão, para garantir que códigos
baseados no .NET Framework possam se integrar a qualquer outro código.
O .NET Framework tem dois componentes principais: o Common Language Runtime e a biblioteca
de classes do .NET Framework. O Common Language Runtime é a fundação do .NET
Framework. Você pode pensar no Runtime como um agente que dirige o código no tempo de
execução, fornecendo serviços principais como gerenciamento de memória, gerenciamento de
segmento e arquitetura de comunicação remota, enquanto forçam, também, a segurança de tipos
estritos e outras formas de precisão de código que promovem segurança e robustez. Na verdade,
o conceito de gerenciamento de código é um princípio fundamental do Runtime. O código que visa
o Runtime é conhecido como código gerenciado, enquanto o código que não visa o Runtime é
conhecido como código não gerenciado. A biblioteca de classes, outro componente principal do
.NET Framework, é uma coleção de objetos orientados de tipos reutilizáveis, que você pode usar
para desenvolver aplicativos, variando de linhas de comando tradicionais ou aplicativos gráficos
de interfaces de usuários (GUI), para aplicativos com base nas inovações mais recentes
fornecidas pelo ASP.NET, como Web Forms e Serviços XML da Web.
O .NET Framework pode ser hospedado por componentes não gerenciados que carregam o
Common Language Runtime em seus processos, e inicializam a execução de código gerenciado.
Assim, criam um ambiente de software que pode explorar os recursos gerenciados e não
gerenciados. O .NET Framework não apenas fornece vários Runtime Hosts, como também
suporta o desenvolvimento de Runtime Hosts de terceiros.
Por exemplo, o ASP.NET hospeda o Runtime para fornecer um ambiente escalonável, do lado do
servidor, para código gerenciado. ASP.NET trabalha diretamente com o tempo de execução para
ativar os aplicativos ASP.NET e Serviços XML da Web, ambos serão discutidos posteriormente
neste tópico.
Internet Explorer é um exemplo de um aplicativo não gerenciado que hospeda o Runtime (na
forma de uma extensão tipo MIME). Usar o Internet Explorer para hospedar o Runtime, permite
que você incorpore componentes gerenciados ou controles Windows Forms em documentos
HTML. Hospedar o Runtime dessa maneira, torna possível o gerenciamento do código móvel
(semelhante a controles Microsoft® ActiveX®), mas com melhorias significativas que somente o
código gerenciado pode oferecer, como execução semi-confiável e armazenamento de arquivos
isolados.
A ilustração a seguir mostra o relacionamento do Common Language Runtime e da biblioteca de

classes para seus aplicativos e para o sistema geral. A ilustração também mostra como o código
gerenciado opera dentro uma arquitetura maior.
NET Framework em contexto

As seções a seguir descrevem os recursos e componentes principais do .NET Framework com
mais detalhes.
Recursos do Common Language Runtime
O Common Language Runtime gerencia memória, execução de segmento, execução do código,

verificação de segurança do código, compilação e outros serviços do sistema. Esses recursos são
intrínsecos para o código gerenciado, que executa no Common Language Runtime.
Quanto à segurança, os componentes gerenciados são concedidos variando os graus da

confiança, dependendo do número de fatores que incluem sua origem (como a Internet, rede
corporativa ou computador local). Isso significa que um componente gerenciado pode ou não ser
capaz de executar operações de acesso de arquivo, operações de registro de acesso ou outras
funções confidenciais, mesmo se ele estiver sendo usado no mesmo aplicativo ativo.
O Runtime impõe segurança de acesso a código. Por exemplo, os usuários podem confiar que um
executável, incorporado em uma página da Web, pode reproduzir uma animação na tela ou tocar
uma música, mas não pode acessar seus dados pessoais, arquivos de sistema ou rede. Os
recursos de segurança do Runtime ativam o legítimo Internet-deployed software para ser
caracterizado, excepcionalmente, como rico.
O Runtime também impõe robustez ao código ao implementar uma estrita infra-estrutura Type-
and-Code-Verification chamada Common Type System (CTS). O CTS assegura que todo código
gerenciado é autodescritivo. Os diversos compiladores de linguagem da Microsoft e de terceiros
geram códigos gerenciados que estão em conformidade com o CTS. Isso significa que códigos
gerenciados podem consumir outros tipos gerenciados e instâncias, enquanto forçam estritamente
a fidelidade tipo e segurança.
Além disso, o ambiente gerenciado do Runtime elimina muitos problemas comuns de software.
Por exemplo, o Runtime automaticamente manipula o layout de objetos e gerencia referências a
eles, liberando-os quando não estão sendo usados. Este gerenciamento automático de memória
resolve os dois erros mais comuns de aplicativos: vazamentos e referências inválidas de memória.
O Runtime também acelera a produtividade do desenvolvedor. Por exemplo, os programadores

podem escrever aplicativos em sua linguagem de desenvolvimento de preferência, mas aproveitar
completamente o Runtime, a biblioteca de classes e componentes escritos em outras linguagens,
por outros desenvolvedores. Qualquer fornecedor de compilador que escolher direcionar o
Runtime pode fazê-lo. Compiladores de linguagem que direcionam o .NET Framework tornam os
recursos do .NET Framework disponíveis para códigos existentes, escritos nessa linguagem,
facilitando bastante o processo de migração para os aplicativos existentes.
O Runtime foi criado para o software do futuro, mas também suporta software atuais.
Interoperabilidade entre códigos gerenciados e não gerenciados permite aos desenvolvedores
continuar a usar os componentes COM e DLLs necessários.
O Runtime é projetado para melhorar o desempenho. Embora o Common Language Runtime

forneça vários serviços padrão de Runtime, o código gerenciado nunca é interpretado. Um recurso
chamado compilação Just-In-Time (JIT) ativa todos os códigos gerenciados para executar na
linguagem nativa da máquina do sistema, no qual ele estiver em execução. Enquanto isso, o
gerenciador de memória remove as possibilidades de memória fragmentada e aumenta a
localidade-de-referência da memória, melhorando ainda mais o desempenho.
Finalmente, o Runtime pode ser hospedado por aplicativos de alto desempenho, do lado do
servidor, como o Microsoft ® SQL Server ™ e Serviços de Informações da Internet (IIS). Esta
infra-estrutura permite que você use código gerenciado para escrever sua lógica corporativa,

enquanto aproveita o desempenho superior dos melhores servidores de empresa que suportam
runtime hosting.
Biblioteca de Classes do .NET Framework
A Biblioteca de classes do .NET Framework é uma coleção de tipos reutilizáveis que se integram
rigidamente com o Common Language Runtime. A biblioteca de classes é orientada a objetos,
fornecendo tipos que seu próprio código gerenciado pode derivar. Isso não só torna os tipos do
.NET Framework fáceis de usar, como também reduz o tempo associado ao aprendizado de
novos recursos do .NET Framework. Além disso, componentes de terceiros podem se integrar
totalmente com classes do .NET Framework.
Por exemplo, as classes da coleção .NET Framework implementam um conjunto de interfaces que
você pode usar para desenvolver suas próprias coleções de classes. Sua coleção de classes será
perfeitamente combinada com as classes do .NET Framework.
Como você espera de uma biblioteca de classe orientada a objetos, os tipos do .NET Framework
permitem que você realize uma gama de tarefas comuns de programação, incluindo tarefas como
gerenciamento de seqüência de caracteres, coleta de dados, conectividade do banco de dados e
acesso a arquivos. Além dessas tarefas comuns, a biblioteca de classes inclui tipos que oferecem
suporte a uma variedade de cenários especializados de desenvolvimento. Por exemplo, você
pode usar o .NET Framework para desenvolver os seguintes tipos de aplicativos e serviços:
• Aplicativos de console.
• Aplicativos Windows GUI (Windows Forms).
• Aplicativos ASP.NET.
• Serviços XML da Web.
• Serviços do Windows.
Por exemplo, as classes Windows Forms são um conjunto abrangente de tipos reutilizáveis que
simplificam vastamente o desenvolvimento do Windows GUI. Se você criar um aplicativo de Web
Form ASP.NET, você pode usar as classes Web Forms.
Desenvolvimento de Aplicativos Cliente
Aplicativos cliente são os mais próximos de um estilo tradicional de um aplicativo baseado em

programação Windows. Esses são os tipos de aplicativos que exibem janelas ou formulários na
área de trabalho, permitindo a um usuário executar uma tarefa. Aplicativos cliente incluem
aplicativos como processadores de texto e planilhas, bem como aplicativos de negócios
personalizados, como ferramentas de entrada de dados, ferramentas de relatórios e assim por
diante. Aplicativos cliente geralmente empregam janelas, menus, botões e outros elementos GUI.
Eles acessam, provavelmente, recursos locais como o sistema de arquivos e periféricos, como
impressoras.
Outro tipo de aplicativo cliente é o tradicional controle ActiveX (agora, substituído pelo o controle
gerenciado do Windows Forms) implantado através da Internet como página da Web. Este
aplicativo se parece muito com outros aplicativos clientes: ele é executado de forma nativa, tem
acesso a recursos locais e inclui elementos gráficos.
No passado, os desenvolvedores criavam esses aplicativos utilizando C/C++ em conjunto com o

Microsoft Foundation Classes (MFC) ou com um ambiente de desenvolvimento de aplicativos
rápidos (RAD) como o Microsoft ® Visual Basic ®. O .NET Framework incorpora aspectos desses
produtos existentes em um ambiente de desenvolvimento simples e consistente, que
drasticamente simplifica o desenvolvimento de aplicativos cliente.

As classes do Windows Forms contidas no .NET Framework são projetadas para serem usadas
para o desenvolvimento do GUI. Facilmente, você pode criar janelas de comando, botões, menus,
barras de ferramentas e outros elementos de tela, com a flexibilidade necessária para acomodar
mudanças de necessidades comerciais
Por exemplo, o .NET Framework fornece propriedades simples para ajustar atributos visuais
associados a formulários. Em alguns casos o sistema operacional base não dá suporte para
alteração direta desses atributos, e nesse caso o .NET Framework automaticamente recria os
formulários. Essa é uma das várias maneiras na qual o .NET Framework integra a interface do
desenvolvedor, tornando a codificação simples e mais consistente.
Diferentemente de controle ActiveX, controles Windows Forms têm acesso semi-confiável ao

computador do usuário. Isso significa que execução binária ou nativa de código pode acessar
alguns dos recursos do sistema do usuário (como elementos GUI e acesso limitado ao arquivo)
sem poder acessar ou comprometer outros recursos. Devido à segurança de acesso ao código,
muitos aplicativos que antes necessitavam ser instalados no sistema de um usuário, agora podem
ser implantados através da Web. Seus aplicativos podem implementar os recursos de um
aplicativo local, enquanto são implantadas como uma página da Web.
Desenvolvimento de aplicativos servidores
Aplicativos do servidor no mundo gerenciado são implementados através de Runtime Hosts.

Aplicativos não gerenciados hospedam o Common Language Runtime, que permite que seu
código gerenciado personalizado controle o comportamento do servidor. Esse modelo fornece a
você todos os recursos do Common Language Runtime e biblioteca de classes, enquanto ganha o
desempenho e escalabilidade do servidor host.
A ilustração a seguir mostra um esquema de rede básica com código gerenciado em execução,
em ambientes de servidores diferentes. Servidores como o IIS e SQL Server podem executar
operações padrão, enquanto a lógica do seu aplicativo executa através do código gerenciado.
Código gerenciado do lado do servidor
ASP.NET é o ambiente de hospedagem que permite aos desenvolvedores usar o.NET Framework
para direcionar aplicativos baseados na Web. Entretanto, o ASP.NET é mais do que apenas um
Runtime Host; ele é uma arquitetura completa para desenvolver sites e objetos Internet-
Distributed, usando código gerenciado. Web Forms e serviços XML da Web usam IIS e ASP.NET
como mecanismos de publicação de aplicativos, e ambos têm uma coleção de classes que são
suportadas pelo .NET Framework.
Serviços XML da Web, uma evolução importante na tecnologia baseada na Web, são
componentes de aplicativos distribuídos, do lado do servidor, semelhante a sites comuns da Web.
Entretanto, diferentemente dos aplicativos baseados na Web, componentes de serviços XML da
Web não têm interface de usuário, e não são direcionados para navegadores como o Internet
Explorer e Netscape Navigator. Em vez disso, serviços XML da Web consistem em componentes
de software reutilizáveis, projetados para serem consumidos por outros aplicativos, como
aplicativos cliente tradicionais, aplicativos baseados na Web ou mesmo outros serviços XML da
Web. Como resultado, a tecnologia dos serviços XML da Web está movendo, rapidamente, o
desenvolvimento e implantação de aplicativos para o ambiente altamente distribuído da Internet.
Se você utilizou versões anteriores da tecnologia ASP, você imediatamente notará os

aperfeiçoamentos que ASP.NET e Web Forms oferecem. Por exemplo, você pode desenvolver
páginas Web Forms em qualquer linguagem que suporte o .NET Framework. Além disso, seu
código não precisa mais compartilhar o mesmo arquivo com o texto HTTP (embora ele possa

continuar fazendo isso, se você preferir). Páginas Web Forms executam na linguagem de máquina
nativa porque, como qualquer outro aplicativo gerenciado, elas aproveitam completamente o
Runtime. Por outro lado, páginas ASP não gerenciadas são sempre colocadas em script e
interpretadas. Páginas ASP.NET são mais rápidas, mais funcionais e mais fáceis para
desenvolver do que as páginas ASP não gerenciadas, porque elas interagem com o Runtime
como qualquer aplicativo gerenciado.
O .NET Framework também fornece um conjunto de classes e ferramentas para ajudar no

desenvolvimento e consumo de aplicativos de serviços XML da Web. Serviços XML da Web são
criados em padrões como SOAP (um protocolo remoto de chamada de procedimento), XML (um
formato de dados extensível) e WSDL (Web Services Description Language). O .NET Framework
foi construído sobre esses padrões para promover a interoperabilidade com soluções não-
Microsoft.
Por exemplo, a ferramenta WSDL, incluída com o SDK do .NET Framework, pode consultar um
serviço XML da Web publicado na Web, analisar sua descrição WSDL e produzir código fonte C#
ou Visual Basic, que o aplicativo pode usar para se tornar um cliente do serviço XML da Web. O
código fonte pode criar classes derivadas de classes, na biblioteca de classes que trata toda a
comunicação base, usando análise SOAP e XML. Embora você possa usar a biblioteca de classes
para consumir diretamente serviços XML da Web, a ferramenta WSDL e as outras ferramentas
contidas no SDK facilitam os esforços de desenvolvimento com o .NET Framework.
Se você desenvolver e publicar seus próprios serviços XML da Web, o .NET Framework fornecerá
um conjunto de classes compatíveis com todos os padrões de comunicação como SOAP, WSDL,
e XML. Usar as classes permite que você enfoque na lógica do seu serviço, sem se preocupar
com com a infra-estrutura de comunicação exigida pelo desenvolvimento de software distribuídos.
Finalmente, como páginas Web Forms no ambiente gerenciado, seu serviço XML da Web será
executado com a velocidade de linguagem de máquina nativa, usando a comunicação
escalonável do IIS.

Common Language Runtime
O .NET Framework fornece um ambiente de tempo de execução chamado Common Language
Runtime, que executa o código e fornece serviços que facilitam o processo de desenvolvimento.
Visão geral do Common Language Runtime

Compiladores e ferramentas expõem as funcionalidades do runtime e permitem que você escreva
código que se beneficia desse ambiente de execução gerenciado. Código que você desenvolve
com um compilador de linguagem que visa o runtime é chamado código gerenciado; ele se
beneficia de recursos como integração entre linguagens, tratamento de exceção entre linguagens,
segurança aprimorada, suporte a versionamento e implantação, um modelo simplificado para
interação entre componentes, depuração e serviços de perfil.
Para ativar o runtime para fornecer serviços de código gerenciado, compiladores de linguagens
devem emitir metadados que descrevem os tipos, membros, e referências em seu código. Os
metadados são armazenados com o código; todo arquivo executável portável (PE) carregável do
common language runtime contém metadados. O runtime usa metadados para localizar e carregar
classes, organizar instâncias na memória, resolver invocações método, gerar código nativo,
reforçar a segurança, e definir limites de contexto em tempo de execução.
O runtime automaticamente trata de objetos de layout e gerencia referências a objetos, liberando-

os quando eles não estão sendo usados. Objetos cujos tempos de vida são gerenciados dessa
forma são chamados de dados gerenciados. A coleta de lixo elimina vazamentos de memória e
alguns outros erros comuns de programação. Se seu código é gerenciado, você pode usar dados
gerenciados, dados não gerenciados ou ambos no seu aplicativo .NET Framework. Devido ao fato
de compiladores de linguagens fornecerem seus próprios tipos, como tipos primitivos, você não
pode sempre saber (ou precisa saber) se seus dados estão sendo gerenciados.
O Common Language Runtime torna fácil a criação de componentes e aplicativos cujos objetos
interagem entre linguagens. Objetos escritos em diferentes linguagens podem se comunicar entre
si, e seus comportamentos podem ser totalmente integrados. Por exemplo, você pode definir uma
classe e, em seguida, usar uma linguagem diferente para derivar uma classe de sua classe
original ou chamar um método na classe original. Você também pode passar uma instância de
uma classe para um método de uma classe escrito em uma linguagem diferente. Essa integração
entre linguagens é possível porque os compiladores de linguagens e ferramentas que miram o
runtime usam um CTS (Common Type System) definido pelo runtime, e eles seguem as regras do
runtime para definir novos tipos, como também para criação, uso, persistência e ligação de tipos.
Como parte de seus metadados, todos os componentes gerenciados transportam informações

sobre os componentes e recursos dos quais eles foram construídos. O runtime usa essas
informações para garantir que o componente ou aplicativo tenha as versões especificadas de tudo
o que precisa, o que torna seu código menos suscetível a quebra devido a alguma dependência
não encontrada. Informações de registro e dados do estado não são mais armazenadas no
registro onde eles podem ser difíceis para estabelecer e manter. Em vez disso, as informações
sobre os tipos que você definir (e suas dependências) são armazenados com o código como
metadados, fazendo com que as tarefas de replicação de componentes e remoção sejam muito
menos complicadas.
Compiladores de linguagens e ferramentas expõem as funcionalidades do runtime de maneira a

serem úteis e intuitivas para desenvolvedores. Isso significa que alguns recursos do runtime
devem ser mais notáveis em um ambiente que em outro. Como você experimenta o runtime
depende de qual compiladores de linguagem ou ferramentas você usa. Por exemplo, se você for
um desenvolvedor Visual Basic, você pode notar que com o Common Language Runtime, a

linguagem Visual Basic tem mais recursos orientados a objetos do que antes. A seguir estão
alguns benefícios do runtime:
• Melhorias de desempenho.
• Capacidade de facilmente usar componentes desenvolvidos em outras linguagens.
• Tipos extensíveis fornecidos por uma biblioteca de classes.
• Novos recursos da linguagem como herança, interfaces e sobrecarga para programação
orientada a objetos; suporte a segmentação livre explícita que permite criação de aplicativos de
vários segmentos, escalonáveis; suporte a tratamento de exceção estruturada e atributos
personalizados.
Se você usar o Microsoft® Visual C++® .NET, você pode escrever código gerenciado usando o
Managed Extensions for C++, que fornece os benefícios de um ambiente de execução gerenciado
como também o acesso a recursos poderosos e tipos de dados expressivos que você está
familiarizado. Recursos de runtime adicionais incluem:
• Integração entre linguagens, especialmente herança entre linguagens.

• Coleta de lixo que gerencia o tempo de vida de objeto sendo a contagem de referência
desnecessária.
• Objetos autodescritivos, que fazem uso da Interface Definition Language (IDL)
desnecessariamente.
• A capacidade de compilar uma vez e executar em qualquer CPU e sistema operacional
que dê suporte ao runtime.
Você também pode escrever código gerenciado usando a linguagem C#, que fornece os
seguintes benefícios:
• Design completamente orientado a objetos.

• Segurança de tipos muito forte.
• Boa combinação da simplicidade do Visual Basic e poder do C++.
• Coleta de lixo.
• Sintaxe e palavras-chave semelhante as do C e C++.
• Uso do delegates em vez de ponteiros de função para aumento da segurança de tipos e
segurança. Ponteiros de função estão disponíveis através do uso da palavra-chave unsafe do
C# e a opção /unsafe do compilador C# (CSC.exe) para código não gerenciado e dados.
Gerenciamento automático de memória

Gerenciamento automático de memória é um dos serviços que o Common Language Runtime
fornece durante a Execução Gerenciada. O coletor de lixo do Common Language Runtime
gerencia a alocação e liberação de memória para um aplicativo. Para desenvolvedores, isso
significa que você não tem que escrever código para executar tarefas de gerenciamento de
memória quando você desenvolver aplicativos gerenciados. Gerenciamento automático de
memória pode eliminar problemas comuns, como esquecer de liberar um objeto e causar um
vazamento de memória, ou tentar acessar a memória de um objeto que já tinha sido liberado. Esta
seção descreve como o coletor de lixo aloca e libera memória.
Alocando memória

Quando você inicializa um novo processo, o tempo de execução reserva uma região contígua de
espaço de endereço para o processo. Este espaço de endereço reservado é chamado de heap
gerenciada. A heap gerenciada mantém um ponteiro para o endereço onde o próximo objeto da
heap será alocado. Inicialmente, esse ponteiro é definido como Endereço básico da heap
gerenciada. Todos os tipos de referência são alocados na heap gerenciada. Quando um aplicativo
cria o primeiro tipo de referência, é alocada memória para o tipo no Endereço básico da heap
gerenciada. Quando o aplicativo cria o próximo objeto, o coletor de lixo aloca memória para ele no
espaço de endereço imediatamente após o primeiro objeto. Desde que exista espaço de endereço
disponível, o coletor de lixo continua a alocar espaço para novos objetos dessa maneira.
Alocar memória de heap gerenciada é mais rápido que a alocação de memória não gerenciada.
Pelo fato de que o Runtime aloca memória para um objeto adicionando um valor a um ponteiro,
ele é quase tão rápido quanto a alocação de memória da pilha (stack). Além disso, porque novos
objetos que são alocados consecutivamente são armazenados contiguamente na heap
gerenciada, um aplicativo pode acessar os objetos muito rapidamente.
Liberando memória
O mecanismo otimizado do coletor de lixo determina o melhor momento para executar uma coleta
com base nas alocações sendo feitas. Quando o coletor de lixo executa uma coleta, ele libera a
memória dos objetos que não estão sendo usados pelo aplicativo. Ele determina quais objetos
não estão mais sendo usados pelo exame das raízes do aplicativo. Cada aplicativo tem um
conjunto de raízes. Cada raiz refere-se a um objeto na heap gerenciada ou é definida como nula.
Raízes do aplicativo incluem ponteiros para objetos globais e estáticos, variáveis locais e
parâmetros de objetos de referência na pilha de um segmento, e registro da CPU. O coletor de
lixo tem acesso à lista de raízes ativas mantidas pelo runtime e pelo Compilador Just-In-Time
(JIT). Usando essa lista, ele examina as raízes do aplicativo, e no processo cria um gráfico que
contém todos os objetos que possam ser alcançados a partir as raízes.
Objetos que não estão no gráfico são inacessíveis a partir das raízes do aplicativo. O coletor de
lixo considera como lixo os objetos inacessíveis e irá liberar a memória alocada para eles. Durante
uma coleta, o coletor de lixo examina a heap gerenciada, procurando pelos blocos de espaço de
endereço ocupados por objetos inacessíveis. Na medida em que ele descobre cada objeto
inacessível, ele usa uma função de cópia de memória para compactar os objetos acessíveis na
memória, liberando os blocos de espaços endereço alocados para objetos inacessíveis. Uma vez
que a memória para dos objetos acessíveis tiver sido compactada, o coletor de lixo faz as
correções de ponteiros necessárias raízes de forma que as raízes do aplicativo apontem para os
objetos em seus novos locais. Ele também posiciona o ponteiro da heap gerenciadas após o
último objeto acessível. Observe que memória é compactada somente se uma coleta descobre um
número significativo de objetos inacessíveis. Se todos os objetos na heap gerenciada sobrevivem
a uma coleta, não há necessidade de compactação de memória.
Para melhorar o desempenho, o tempo de execução aloca memória para objetos grandes em uma
heap separada. O coletor de lixo libera automaticamente. a memória para objetos grandes
Entretanto, para evitar mover objetos grandes na memória, essa memória não é compactada.
Gerações e Desempenho
Para otimizar o desempenho do coletor de lixo, a heap gerenciada está dividida em três gerações:
0, 1, e 2. O algoritmo de coleta de lixo do tempo de execução é baseado em várias generalizações
que indústria de software de computador tem descoberto serem verdadeiras por experiências com
esquemas de coleta de lixo Primeiro, é mais rápido compactar a memória para uma parte da heap
gerenciada do que para toda a memória gerenciada. Em segundo lugar, objetos mais recentes
terão vidas úteis menores e objetos mais antigos terão vidas úteis mais longas. Por fim, objetos
mais recentes tendem a ser relacionados entre si e acessados pelo aplicativo ao redor do mesmo
tempo.

O coletor de lixo do Runtime armazena novos objetos na geração 0. Objetos criados com
antecedência no tempo de vida do aplicativo que sobrevivem a coletas são promovidos e
armazenados em gerações 1 e 2. O processo de promoção do objeto é descrito posteriormente
neste tópico. Porque é mais rápido compactar uma parte da heap gerenciada que a heap inteira,
este esquema permite que o coletor de lixo libere a memória em uma geração específica em vez
liberar a memória para toda a memória gerenciada a cada vez que ele executa uma coleta.
Na verdade, o coletor de lixo executa uma coleta quando a geração 0 está cheia. Se um aplicativo
tentar criar um novo objeto quando a geração 0 está cheia, o coletor de lixo descobre que não
existe nenhum espaço de endereço restante na geração 0 para alocar para o objeto. O coletor de
lixo executa uma coleta em uma tentativa de liberar espaço de endereço na geração 0 para o
objeto. O coletor de lixo inicia examinando os objetos na geração 0 em vez de todos os objetos na
heap gerenciada. Isso é a abordagem mais eficiente, porque novos objetos costumam ter tempos
de vida curtos, e é esperado que muitos dos objetos na geração 0 não estejam mais em uso mais
pelo aplicativo quando uma coleta é executada. Além disso, uma única coleta de geração 0
freqüentemente recupera memória suficiente para permitir ao aplicativo continuar criando novos
objetos.
Após o coletor de lixo executar uma coleta de geração 0, ele compacta a memória para os objetos
acessíveis conforme explicado anteriormente neste tópico em Liberando memória. O coletor de
lixo então promove esses objetos e considera esta parte da heap gerenciada como geração 1.
Pelo fato de que objetos que sobrevivem a coletas costumam ter vidas úteis mais longas, faz
sentido promovê-los para uma geração superior. Como resultado, o coletor de lixo não tem que
reexaminar os objetos em gerações 1 e 2 sempre que ele executa uma coleta de geração 0.
Após o coletor de lixo executar sua primeira coleta de geração 0 e promover os objetos acessíveis
na geração 1, ele considera o resto da heap gerenciada como geração 0. Ele continua a alocar
memória para novos objetos na geração 0 até que a geração 0 esteja cheia e que seja necessário
executar outra coleta. Nesse ponto, o mecanismo de otimização do coletor de lixo determina se
ele é necessário examinar os objetos em gerações mais antigas. Por exemplo, se uma coleta de
geração 0 não recupera memória suficiente para o aplicativo concluir sua tentativa de criar um
novo objeto de forma bem sucedida, o coletor de lixo pode executar uma coleta de geração 1, e
depois de geração 0. Se isso não recuperar memória suficiente, o coletor de lixo pode executar
uma coleta de gerações 2, 1, e 0. Após cada coleta, o coletor de lixo compacta os objetos
acessíveis na geração 0 e promove-os para geração 1. Objetos na geração 1 que sobrevivem a
coletas são elevados para geração 2. Como o coletor de lixo oferece suporte somente a três
gerações, objetos na geração 2 que sobrevivem a uma coleta permanecem na geração 2 até que
eles sejam determinados como inalcançáveis em uma coleta futura.
Liberando Memória para Recursos não Gerenciados
Para a maioria dos objetos que seu aplicativo cria, você pode confiar no coletor de lixo para
executar automaticamente as tarefas de gerenciamento de memória necessárias. Entretanto,
recursos não gerenciados requerem limpeza explícita. O tipo mais comum de recurso não
gerenciado é um objeto que envolve um recurso do sistema operacional, como um identificador de
arquivo, identificador de janela, ou conexão de rede. Embora o coletor de lixo seja capaz de
controlar o tempo de vida de um objeto gerenciado que encapsula um recurso não gerenciado, ele
não tem conhecimento específico sobre como limpar o recurso. Quando você criar um objeto que
encapsula um recurso não gerenciado, é recomendado que você forneça o código necessário
para limpar o recurso não gerenciado em um método Dispose público. Ao fornecer um método
Dispose, você permite que usuários do seu objeto explicitamente liberem sua memória quando
eles tiverem concluído com o objeto. Quando você usa um objeto que encapsula um recurso não
gerenciado, você deve estar ciente do Dispose e chamá-lo conforme necessário. Para obter mais
informações sobre limpeza de recursos não gerenciados e um exemplo de um padrão de design
para implementar Dispose, consulte Coleta Lixo.

CTS (Common Type System)
O CTS (Common Type System) define como tipos são declarados, usados, e gerenciados no
ambiente de tempo de execução, e também é uma parte importante do suporte do ambiente de
tempo de execução para integração entre linguagens. O CTS executa as seguintes funções:
• Estabelece uma estrutura que ajuda a habilitar integração entre linguagens, segurança de
tipos, e execução de código de alto desempenho.
• Fornece um modelo orientado a objetos que oferece suporte à implementação completa de
muitas linguagens de programação.
• Define regras que as linguagens devem seguir, que ajudam a assegurar que objetos
escritos em linguagens diferentes podem interagir entre si.
Visão Geral do CTS (Common Type System)
Esta seção descreve conceitos e define termos que ajudarão a compreender e trabalhar com a
implementação do CTS da sua linguagem.
Classificação de Tipos
O CTS fornece suporte a duas categorias gerais de tipos, cada um delas é posteriormente dividida
em subcategorias:
• Tipos de valor
Tipos de valor contêm diretamente seus dados. Instâncias de tipos de valor ou são alocadas na
pilha ou são alocadas internamente em uma estrutura. Tipos de valor podem ser internos
(implementados pelo ambiente de execução), definidos pelo usuário ou enumerações. Para
obter uma lista dos tipos valor internos, consulte a Biblioteca de Classes do .NET Framework.
• Tipos de referência
Tipos de referência armazenam uma referência para o endereço de memória do valor e são
alocados no heap. Tipos referência podem ser tipos autodescritivos, tipos ponteiro ou tipos de
interface. O tipo de um tipo de referência pode ser determinado a partir dos valores de tipos
autodescritivos. Tipos autodescritivos são posteriormente divididos em matrizes e tipos de
classe. Os tipos de classe são classes definidas pelo usuário, tipos de valor convertidos e
delegates.
Variáveis que são tipos de valor possuem sua própria cópia dos dados e, portanto, operações em
uma variável não afetam outras variáveis. Variáveis que são tipos de referência podem referenciar
o mesmo objeto e, portanto, operações em uma variável podem afetar o mesmo objeto
referenciado por outra variável.
Todos os tipos derivam do tipo base System.Object.
O exemplo a seguir mostra a diferença entre tipos de referência e tipos de valor.
C#
using System; class Class1 { public int Value = 0; } class Test { static void Main() { int val1 = 0; int val2 = val1;
val2 = 123; Class1 ref1 = new Class1(); Class1 ref2 = ref1; ref2.Value = 123; Console.WriteLine("Values: {0},
{1}", val1, val2); Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value); } }
A saída do programa é a seguinte.

Values: 0, 123 Refs: 123, 123
O diagrama a seguir ilustra como esses tipos estão relacionados. Observe que instâncias de tipos
podem ser simplesmente tipos de valor ou tipos autodescritivos, mesmo que haja subcategorias
desses tipos.
Classificação de tipos
Valores e objetos
Valores são representações binárias de dados. Os tipos fornecem uma maneira de interpretar
esses dados. Um tipo de valor é armazenado como uma representação binária dos dados do tipo.
O valor de um tipo de referência é a localidade da seqüência de bits que representam os dados do
tipo.
Cada valor possui um tipo exato que define por completo a representação do valor e as operações
que são definidas no valor. Valores de tipos autodescritivos são chamados objetos. Enquanto é
sempre possível determinar o tipo exato de um objeto examinando seu valor, não é possível fazer
o mesmo com o um tipo de valor ou tipo ponteiro. Um valor pode ter mais de um tipo. Um valor
cujo tipo implementa uma interface é também um valor do tipo da interface. Da mesma forma, um
valor cujo tipo deriva de um tipo base é também um valor desse tipo base.
Tipos e Assemblys
O ambiente de execução usa assemblys para localizar e carregar tipos. O manifesto do assembly
contém as informações que o ambiente de execução usa para resolver todas as referências de
tipo feitas dentro do escopo do assembly.
Um nome de tipo no ambiente de execução possui duas partes lógicas: o nome do assembly e o
nome do tipo dentro do assembly. Dois tipos com o mesmo nome, mas em assemblys diferentes,
são definidos como dois tipos distintos.

Assemblys fornecem consistência entre o escopo de nomes vistos pelo desenvolvedor e o escopo
de nomes vistos pelo sistema em tempo de execução. Os desenvolvedores criam tipos no
contexto de um assembly. O conteúdo do assembly que está sendo criando por um desenvolvedor
estabelece o escopo de nomes que estará disponível em tempo de execução.
Tipos e Namespaces
No ponto de vista do ambiente de execução, um namespace é apenas um conjunto de nomes de

tipo. Determinadas linguagens podem ter construções que ajudam os desenvolvedores a formar
grupos lógicos de tipos, mas essas construções não são usadas pelo ambiente de execução ao
vincular tipos. Assim, ambas as classes Object e String são parte do namespace System, mas o
ambiente de execução reconhece apenas os nomes completos de cada tipo que são
System.Object e System.String, respectivamente
Você pode criar um único assembly que expõe tipos que parecem ter vindo de dois namespaces
hierárquicos diferentes, como System.Collections e System.Windows.Forms. Você também pode
criar dois assemblys que exportam tipos cujos nomes contenham MyDll.MyClass.
Se você criar uma ferramenta para representar tipos em um assembly como pertencentes a um
namespace hierárquico, a ferramenta deve enumerar os tipos em um assembly, ou em um grupo
de assemblys, e analisar os nomes dos tipos a fim de derivar um relacionamento hierárquico.
Definições de Tipo
Você define novos tipos a partir de tipos existentes. Tipos de valor interno, ponteiros, matrizes e
delegados são definidos quando eles são usados e são referidos como tipos implícitos. Tipos
podem ser aninhados; ou seja, um tipo pode ser um membro de outro tipo.
Uma definição de tipo inclui:
• Qualquer atributo definido no tipo.

• A visibilidade do tipo.
• O nome do tipo.
• O tipo base do tipo.
• Qualquer interface implementada pelo tipo.
• Definições para cada um dos membros do tipo.
Atributos
Atributos fornecem metadados adicionais definidos pelo usuário. Atributos podem ser aplicados a
praticamente qualquer elemento de linguagem — tipos, propriedades, métodos e assim por diante.
Tipo de acessibilidade
Todos os tipos têm um modificador de acessibilidade que rege sua acessibilidade a outros tipos. A
tabela a seguir descreve a acessibilidade de tipo suportada pelo runtime.
Acessibilidade Descrição
Público O tipo é acessível por todos os assemblies.

Assembly O tipo é acessível somente dentro do assembly.
A acessibilidade de um tipo aninhado depende do seu domínio de acessibilidade, que é

determinado pelas acessibilidade declarada do membro e pelo domínio de acessibilidade do tipo
imediatamente contido. Entretanto, o domínio de acessibilidade de um tipo aninhado não pode
exceder o do tipo contido.
O domínio de acessibilidade de um membro aninhado M declarado em um tipo T de um programa

P é definido como segue (observando que M, por si só, pode ser um tipo):
• Se a acessibilidade declarada de M for public, o domínio de acessibilidade de M é o

domínio de acessibilidade de T.
• Se a acessibilidade declarada de M for protected internal, o domínio de acessibilidade de
M é a interseção do domínio de acessibilidade de T com o do texto do programa de P, e o texto
do programa de qualquer tipo derivado de T, declarado fora de P.
• Se a acessibilidade declarada de M for protected, o domínio de acessibilidade de M é a
interseção do domínio de acessibilidade de T com o texto do programa de T, e qualquer tipo
derivado de T.
• Se a acessibilidade declarada de M for internal, o domínio de acessibilidade de M é a
interseção do domínio de acessibilidade de T com o texto de programa de P.
• Se a acessibilidade declarada de M for private, o domínio de acessibilidade de M é o texto
de programa de T.
Nomes de Tipos
O CTS impõe apenas duas restrições de nomes:
1. Todos os nomes são codificados como seqüências de caracteres Unicode (16 bits).
2. Não são permitidos nomes que tenham um valor (16 bits) incorporado de 0x0000.
Todas as comparações são feitas em uma base byte-by-byte, e possuem, portanto, diferenciação
de maiúsculas e minúsculas e são independentes de local
Embora um tipo possa fazer referência a tipos de outros módulos e assemblies, um tipo é
totalmente definido dentro de um módulo. Nomes de tipo precisam somente ser exclusivos em um
assembly. Para identificar totalmente um tipo, o nome do tipo deve ser qualificado pelo assembly
que contém a implementação do tipo. Para mais informações, consulte Especificando Nomes de
Tipos Totalmente Qualificados.
Tipos Base e Interfaces
Um tipo pode herdar valores e comportamentos de outro tipo. O CTS não permite que tipos sejam
herdados de mais de um tipo base.
Um tipo pode implementar qualquer número de interfaces. Para implementar uma interface, um
tipo deve implementar todos os membros virtuais da interface. Um método virtual pode ser
implementado por um tipo derivado e pode ser chamado estática ou dinamicamente. Para obter
mais informações sobre membros virtuais, consulte Membros de Tipos. Para obter mais
informações sobre herança e interfaces, consulte Classes e Interfaces.
Membros de Tipos

O comportamento e estado de um tipo são definidos pelos membros do tipo: eventos, campos,
tipos aninhados, métodos e propriedades. Para mais informações, consulte Membros de Tipos.
Membros de Tipos
O ambiente de execução permite que você defina os membros do tipo: eventos, campos, tipos
aninhados, métodos e propriedades. Cada membro tem uma assinatura. A tabela a seguir
descreve os membros usados no .NET Framework.
Membro Descrição
Evento Define um incidente ao qual pode-se responder e define métodos para inscrever
em, cancelar a inscrição em e levantar um evento. Eventos são freqüentemente
usados para informar outros tipos de alterações de estado.
Campo Descreve e contém parte do estado do tipo. Campos podem ser de qualquer tipo
suportado pelo ambiente de execução.
Tipo Define um tipo dentro do escopo do tipo delimitador.
aninhado
Método Descreve as operações disponíveis no tipo. A assinatura do método especifica os
tipos dos argumentos e o valor de retorno do método.
O construtor é um tipo especial de método que cria novas instâncias de um tipo.
Propriedade Nomeia um valor ou um estado do tipo e define métodos para obter ou definir o
valor da propriedade. Propriedades podem ser tipos primitivos, coleções de tipos
primitivos, tipos definidos pelo usuário ou coleções de tipos definidos pelo usuário.
Propriedades são freqüentemente usadas para manter a interface pública de um
tipo, independente da representação real do tipo.
Características de um Membro
O CTS (Common Type System) permite que os membros possuam uma variedade de
características, mas as linguagens não necessariamente suportam todas elas. A tabela a seguir
descreve as características de um membro.
Pode ser
Característica aplicada a Descrição
abstract Métodos, O tipo não fornece a implementação do método. Tipos
propriedades e que herdam métodos abstratos e tipos que
eventos implementam interfaces com métodos abstratos devem
fornecer uma implementação para o método. A única
exceção é quando o tipo derivado é um tipo abstrato.
Todos os métodos abstratos são virtuais.
private, family, Todos Define a acessibilidade de um membro:
assembly, family e private
assembly, family ou Acessível somente dentro do tipo do membro ou
assembly, ou public dentro de um tipo aninhado.
family
Acessível dentro do tipo do membro e dentro de
um tipo derivado que herda do tipo do membro.
assembly
Acessível somente no assembly no qual o tipo é
definido.
family e assembly

Acessíveis somente dentro de tipos que se
cumprem tanto as restrições de acesso da
característica family quanto da característica
assembly.
family ou assembly
Acessíveis somente dentro de tipos que se
cumprem as restrições de acesso da
característica family ou as restrições da
característica assembly.
public
Acessíveis dentro de qualquer tipo.
final Métodos, Um método virtual não pode ser substituído em um tipo
propriedades e derivado.
eventos
initialize-only Campos O valor pode apenas ser inicializado, não pode ser
gravado outro valor após a inicialização.
instance Campos, Se um membro não estiver marcada como static (C# e
métodos, C++), Shared (Visual Basic), virtual. (C# e C++) ou
propriedades e Overridable (Visual Basic), ele é um membro da
eventos instância (não existe a palavra-chave instance). Haverá
o mesmo número de cópias desses membros na
memória e de objetos que os usam.
literal Campos O valor atribuído ao campo é um valor fixo, conhecido
em tempo de compilação, de um tipo de valor interno.
Às vezes, campos marcados como literal são
chamados de constantes.
newslot ou override Todos Define como o membro interage com os membros
herdados que possuem a mesma assinatura:
newslot
Oculta membros herdados que possuem a
mesma assinatura.
override
Substitui a definição de um método virtual
herdado.
O padrão é newslot.
static Campos, O membro pertence ao tipo no qual está definido e não
métodos, a uma instância particular do tipo. O membro existe
propriedades e mesmo que uma instância de tipo não tenha sido
eventos criada. Ele é compartilhado entre todas as instâncias do
tipo.
virtual Métodos, O método pode ser implementado por um tipo derivado
propriedades e e pode ser chamado estaticamente ou dinamicamente.
eventos Se foi usada uma chamada dinâmica, o tipo da
instância que fez a chamada em tempo de execução
determina qual implementação do método deve ser
chamada, e não o tipo conhecido em tempo de
compilação. Para chamar um método virtual
estaticamente, pode ser necessário converter a variável
(usando o operador cast) para um tipo que usa a versão
desejada do método.
Sobrecarga

Cada membro de tipo tem uma assinatura única. A assinatura de um método consistem do nome
do método e da lista de parâmetros (a ordem e tipos dos argumentos do método). Mais de um
método com o mesmo nome pode ser definido em um tipo desde que as assinaturas sejam
diferentes. Quando dois ou mais métodos com o mesmo nome são definidos, diz-se que o método
está sobrecarregado. Listas de parâmetros podem ser qualificadas por restrições varargs,
indicando que o método suporta uma lista de argumentos variável. Por exemplo, em
System.Char, o método IsDigit está sobrecarregado. Um método recebe um Char e retorna um
Boolean, outro método recebe um Int32 e uma String e retorna um Boolean
Herança, Substituição e Membros Ocultos
Um tipo derivado herda todos os membros do seu tipo base, ou seja, esses membros estão
definidos no tipo derivado e disponíveis para o mesmo. O comportamento, ou qualidades, de
membros herdados pode ser modificado de duas maneiras:
• Um tipo derivado pode ocultar um membro herdado definindo um novo membro com a
mesma assinatura. Isso pode ser feito quando deseja-se tornar um membro público em privado
ou para definir um novo comportamento para um método herdado que está marcado como
final.
• Um tipo derivado pode substituir um método virtual herdado. O novo método fornece uma
nova definição do método original. Essa nova definição será chamada baseando-se no tipo do
valor em tempo de execução, em vez de no tipo conhecido em tempo de compilação. Um
método só pode substituir um método virtual se o método virtual não está marcado como final.
O novo método está pelo menos tão acessível quanto o método virtual.
Tipos de valor no Common Type System
A maioria das linguagens de programação fornecem tipos de dados internos, como inteiros e
números de ponto flutuante que são copiados quando eles são passados como argumentos (ou
seja, eles são passados pelo valor). No .NET Framework, esses são os chamados tipos de valor.
O Runtime oferece suporte a dois tipos de tipos de valor:
• Tipos de valor interno

O .NET Framework define Tipos de valor interno, como System.Int32 e System.Boolean, que
correspondem e são idênticos aos tipos de dados primitivos usados por linguagens de
programação.
• Tipos de valor definidos pelo usuário
A sua linguagem fornecerá maneiras para definir seus próprios tipos de valor, que derivam de
System.ValueType ou System.Enum. Se você desejar definir um tipo representando um valor
que seja pequeno, como um número complexo (usando dois números de ponto flutuante), você
pode optar por defini-lo como um tipo de valor porque você pode passar por valor o tipo de
valor com eficiência. Se você estiver definindo um tipo que seria mais eficientemente passado
por referência, em vez disso, você deve defini-lo como uma classe .
Para obter informações específicas sobre enumarações, consulte Enumerações no Common Type
System (CTS).
Tipos de valor são armazenados tão eficientemente quanto tipos primitivos, mas você pode
chamar métodos neles, incluindo os métodos virtuais definidos nas classes System.ValueType e
System.Object, assim como quaisquer métodos definidos no próprio tipo de valor. Você pode criar
instâncias de tipos de valor, passá-los como parâmetros, armazená-los como variáveis locais, ou
armazená-los em um campo de outro tipo de valor ou objeto. Tipos valor não têm a sobrecarga
associada com o armazenamento de uma instância de uma classe e eles não exigem
construtores.

Para cada tipo de valor, o tempo de execução fornece um tipo convertido (boxed) correspondente,
que é uma classe que tem o mesmo estado e comportamento que o tipo de valor. Algumas
linguagens exigem que você utilize sintaxe especial quando o tipo convertido (boxed) é
necessário; outras usam automaticamente o tipo convertido (boxed) quando for necessário.
Quando você define um tipo de valor, você está definindo o tipo convertido (boxed) e o tipo não-
convertido (unboxed).
Tipos de valor podem ter campos, propriedades e eventos. Eles também podem ter métodos
estáticos e não-estáticos. Quando eles são convertidos (boxed), eles herdam os métodos virtuais
de System.ValueType, e eles podem implementar zero ou mais interfaces.
Tipos de valor são autenticados (sealed), o que significa que nenhum outro tipo pode ser derivado
a partir deles. Entretanto, você pode definir métodos virtuais diretamente sobre o tipo de valor, e
esses métodos podem ser chamados tanto no na forma convertida (boxed) quanto na não-
convertida (unboxed) do tipo. Embora você não possa derivar outro tipo de um tipo de valor, você
pode definir métodos virtuais em um tipo de valor quando você estiver usando uma linguagem em
que for mais conveniente trabalhar com métodos virtuais do que com métodos não-virtuais ou
estáticos.
O exemplo a seguir mostra como construir um tipo de valor para números complexos.
C#
using System; // Value type definition for a complex number representation. public struct Complex { public
double r, i; // Constructor. public Complex(double r, double i) { this.r = r; this.i = i; } // Returns one divided
by the current value. public Complex Reciprocal { get { if (r == 0d && i == 0d) throw new
DivideByZeroException(); double div = r*r + i*i; return new Complex(r/div, -i/div); } } // Conversion
operators. public static explicit operator double(Complex a) { return a.r; } public static implicit operator
Complex(double r) { return new Complex(r,0d); } // Basic unary operators. public static Complex operator +
(Complex a) { return a; } public static Complex operator - (Complex a) { return new Complex(-a.r, -a.i); } //
Basic binary operators for addition, subtraction, multiplication, and division. public static Complex operator
+ (Complex a, Complex b) { return new Complex(a.r + b.r, a.i + b.i); } public static Complex operator -
(Complex a, Complex b) { return new Complex(a.r - b.r, a.i - b.i); } public static Complex operator * (Complex
a, Complex b) { return new Complex(a.r*b.r - a.i*b.i, a.r*b.i + a.i*b.r); } public static Complex operator /
(Complex a, Complex b) { return a * b.Reciprocal; } // Override the ToString method so the value appears in
write statements. public override string ToString() { return String.Format("({0}+{1}i)", r, i); } } // Entry
point. public class ValueTypeSample { public static void Main() { Complex a = new Complex(0, 1); Complex b
= new Complex(0, -2); Console.WriteLine(); Console.WriteLine("a = " + a); Console.WriteLine("b = " + b);
Console.WriteLine(); Console.WriteLine("a + b = " + (a+b)); Console.WriteLine("a - b = " + (a-b));
Console.WriteLine("a * b = " + (a*b)); Console.WriteLine("a / b = " + (a/b)); Console.WriteLine();
Console.WriteLine("(double)a = " + (double)a); Console.WriteLine("(Complex)5 = " + (Complex)5); } }
A saída deste programa é como se segue.
a = (0+1i) b = (0+-2i) a + b = (0+-1i) a - b = (0+3i) a * b = (2+0i) a / b = (-0.5+0i) (double)a = 0 (Complex)5

= (5+0i)
Classes no Common Type System

Se você estiver familiarizado com programação orientada a objetos, você sabe que uma classe
define as operações que um objeto pode executar (métodos, eventos, ou propriedades) e define
um valor que contém o estado do objeto (campos). Embora uma classe geralmente inclua tanto a

definição quanto a implementação, ela pode ter um ou mais membros que não possuem
implementação.
Uma instância de uma classe é um objeto. Você acessa as funcionalidades de um objeto

chamando seus métodos e acessando suas propriedades, eventos, e campos.
A tabela a seguir fornece uma descrição de algumas das características que o tempo de execução
permite para uma classe. (Características adicionais que estão disponíveis através de classes de
Atributos não são incluídas nesta lista.) Sua linguagem pode não tornar todas essas
características disponíveis.
Característica Descrição
autenticada Especifica que outro tipo não pode ser derivado desse tipo.
implementa Indica que a classe usa uma ou mais interfaces, fornecendo implementações
de membros da interface.
Abstrata Especifica que você não pode criar uma instância da classe. Para usá-la, você
deve derivar outra classe a partir dela.
Herda Indica que as instâncias da classe podem ser usadas em qualquer lugar em
que a classe base for especificada. Uma classe derivada que herda de uma
classe base pode usar a implementação de qualquer método virtual fornecido
pela classe base, ou a classe derivada pode substituí-los com sua própria
implementação.
exportada ou não Indica se uma classe está visível fora do Assembly em que ela está definida.
exportada Só se aplica a classes de alto nível.
Classes aninhadas também têm características membros. Para mais informações, consulte Tipos
membros.
Membros da classe que não têm implementação são membros abstratos. Uma classe que tenha
um ou mais membros abstratos é ela própria abstrata; não é possível criar novas instâncias dessa
classe. Algumas linguagens que direcionam o tempo de execução permitem que você marque
uma classe como abstrata mesmo que nenhum de seus membros seja abstrato. Você pode usar
uma classe abstrata quando você precisar encapsular um conjunto básico de funcionalidades que
as classes derivadas podem herdar ou substituir quando for apropriado. Classes que não são
abstratas são chamadas de classes concretas.
Uma classe pode implementar qualquer número de interfaces, mas ela pode herdar apenas da
uma classe base. Todas as classes devem ter pelo menos um construtor, que inicializa novas
ocorrências da classe.
Cada linguagem com suporte ao tempo de execução fornece uma maneira para indicar que uma
classe ou membros da classe tem características específicas. Quando você usa a sintaxe exigida
pela sua linguagem, a linguagem garante que as características da classe e seus membros são
armazenados (como Metadados) junto com a implementação da classe.
Delegados no Common Type System

O Runtime oferece suporte a tipos de referência, chamados delegados, que servem a um
propósito semelhante ao de ponteiros de função em C++. Diferentemente de ponteiros de função,
delegados são seguros, verificáveis e do tipo seguro. Um tipo delegado pode representar qualquer
método com uma assinatura compatível. Enquanto ponteiros de função podem representar

somente funções estáticas, um delegado pode representar métodos estáticos e de instâncias.
Delegados são usados para manipular eventos e funções callback no .NET Framework.
Todos os delegados são herdados do MulticastDelegate, que são herdados do Delegate. As

linguagens C#, Visual Basic e C++ não permitem a herança desses tipos, ao invés de fornecerem
palavras-chave para declarar delegados.
Como representantes são herdados do MulticastDelegate, um delegado tem uma lista de

invocação, que é uma lista dos métodos que o delegado representa, e que são executados
quando o delegado é chamado. Todos os métodos da lista recebem os argumentos fornecidos
quando o delegado é chamado.
Observação
O valor de retorno não está definido para um delegado que tenha mais de um método na sua lista
de invocação, mesmo que o delegado tenha um tipo de retorno.
Criando e usando representantes
Em muitos casos, como em métodos callback, um delegado representa apenas um método, e as

únicas ações você precisa fazer são criar e invocar o delegado.
Para delegados que representam vários métodos, o .NET Framework fornece métodos de classes
de delegação Delegate. e MulticastDelegate para dar suporte a operações como adicionar um
método para a lista de invocação do um delegado (método
System.Delegate.Combine(System.Delegate[])), remover um método (método
System.Delegate.Remove(System.Delegate,System.Delegate)) e obter a lista de invocação
(método System.Delegate.GetInvocationList)
Observação
Não é necessário usar esses métodos para delegados manipuladores de eventos no C#, C++ e
Visual Basic, já que essas linguagens fornecem sintaxe para adicionar e remover manipuladores
de eventos.
Delegados Estáticos Fechados e Instâncias de Abertura de Delegados
Delegados podem representar static (Shared no Visual Basic) ou métodos de instância.

Normalmente quando um delegado representa um método de instância, a instância é acoplada ao
delegado juntamente com o método. Por exemplo, um delegado manipulador de eventos pode ter
três métodos de instância em sua lista de invocação, cada um com uma referência ao objeto ao
qual o método pertence.
Na versão 2.0 do .NET Framework, também é possível criar e abrir um delegado para um método
de instância. Um método de instância tem um parâmetro da instância implícito (representado por
this no C# ou Me no Visual Basic), e ele também pode ser representado por um tipo delegado que
expõe este parâmetro oculto. Ou seja, o tipo delegado deve ter um parâmetro extra no início da
sua lista formal de parâmetros, do mesmo tipo da classe a qual o método pertence. É oferecido
suporte para o inverso desse cenário, para que seja possível vincular o primeiro argumento de um
método estático.

Observação
A criação de instância aberta e delegados estáticos fechados não possui suporte diretamente pelo Visual
Basic, C++ ou C#, para construtores de delegados. Em vez disso, use um dos métodos de sobrecarga
System.Delegate.CreateDelegate que especifica objetos MethodInfo, como
System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boole
Regras relaxadas para vinculação de delegados
Na versão 2.0 do .NET Framework, os tipos de parâmetro e retorno de um delegado devem ser
compatíveis com os tipos de parâmetro e retorno do método que o delegado representa; os tipos
não precisam coincidir exatamente.
Observação
Nas versões 1.0 e 1.1 do .NET Framework, os tipos devem coincidir exatamente.
Um parâmetro de um delegado é compatível com o parâmetro correspondente de um método se o

tipo do parâmetro do delegado for mais restritivo do que o tipo de parâmetro do método, porque
isso garante que um argumento passado para o delegado possa ser passado com segurança para
o método.
Da mesma forma, o tipo de retorno de um delegado é compatível com o tipo de retorno de um

método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado,
porque isso garante que o valor de retorno do método possa ser difundido com segurança para o
tipo retorno do delegado.
Por exemplo, um delegado com um parâmetro do tipo Hashtable e um tipo de retorno de Object
pode representar um método com um parâmetro de tipo Object e um valor de retorno do tipo
Hashtable.
Para obter mais informações e códigos de exemplo, consulte

System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo).
Representantes e chamadas assíncrona a método
Cada delegado tem um método BeginInvoke que permite a você chamar o delegado
assincronamente, e um método EndInvoke que limpa, posteriormente, os recursos. Esses
métodos são gerados automaticamente para cada tipo delegado. Quando um delegado é
chamado usando o método BeginInvoke, o método que o delegado representa é executado em
um segmento pertencente ao do ThreadPool.
Para obter mais informações e códigos de exemplo, consulte Programação assíncrona usando
delegados.
Matrizes em Common Type System

Um tipo matriz é definido especificando o tipo da matriz, a ordem (número de dimensões) da
matriz e os limites superiores e inferiores de cada dimensão da matriz. Todos esses estão
incluídos em qualquer assinatura de um tipo matriz, embora eles possam ser marcados como
fornecidos dinamicamente (ao invés de estáticos). Tipos exatos de matriz são criados
automaticamente pelo Runtime conforme eles são necessários, e nenhuma definição separada do

tipo matriz é necessária. Matrizes de um determinado tipo só podem ter elementos desse tipo.
Para obter mais informações sobre o tipo de um valor, consulte Valores e Objetos.
Valores de um tipo matriz são objetos. Objetos de matrizes são definidos como uma série de
locais onde valores do tipo elemento de matriz são armazenados. O número de valores repetidos
é determinado pelo posto e limites da matriz.
Tipos matriz são herdados do tipo System.Array. Esta classe representa todas as matrizes
independentemente do tipo de seus elementos ou sua posição. As operações definidas em
matrizes são: alocação de matriz baseada no tamanho e na informação de limite inferior;
indexação de uma matriz para ler e escrever um valor; computação do endereço de um elemento
da matriz (ponteiro gerenciado) e consulta da ordem, limites e número total de valores
armazenados na matriz.
Matrizes com uma dimensão de limite inferior para seus elementos (às vezes chamado vetores)
igual a zero possui um tipo com base no tipo dos elementos da matriz, independentemente do
limite superior. Matrizes com mais de uma dimensão, ou com uma dimensão porém com limite
inferior diferente de zero, possuem o mesmo tipo se eles possuem o mesmo tipo de elemento e
ordem, independentemente do limite inferior da matriz. Não há suporte para matrizes com
dimensões zero.
Interfaces no Common Type System

Interfaces podem ter membros estáticos, tipos aninhados, membros virtuais, propriedades e
eventos. Qualquer classe que implementar uma interface deve fornecer definições para os
membros abstratos declarados na interface. Uma interface pode exigir que qualquer classe de
implementação também deve implementar uma ou mais interfaces.
As restrições a seguir se aplicam a interfaces:
• Uma interface pode ser declarada com qualquer acessibilidade, mas todos membros de
interface devem ter acessibilidade pública.
• Nenhuma permissão de segurança pode ser anexada a membros ou à própria interface.
• Interfaces não podem definir construtores.
Cada linguagem deve fornecer regras para mapear uma implementação para a interface que
requer o membro, de maneira que mais de uma interface possa declarar um membro com a
mesma assinatura e esses membros possam ter implementações separadas.
Ponteiros no Common Type System (CTS)

Ponteiros são tipos especiais de variáveis. Há três tipos de ponteiros para os quais o ambiente de
tempo de execução oferece suporte: ponteiros gerenciados, ponteiros não gerenciados e
ponteiros de funções não gerenciados.
Um ponteiro gerenciado, também conhecido como um identificador para um objeto no heap

gerenciado, é um novo tipo de ponteiro disponível para aplicativos gerenciados. Ponteiros
gerenciados são referências a um bloco gerenciado de memória no heap do Common Language
Runtime. Coleta de lixo automática é executada neste heap. Ponteiros gerenciados são gerados
para argumentos de métodos que são passados por referência. Algumas linguagens fornecem
outras maneiras de gerar ponteiros gerenciados. Apenas os ponteiros gerenciados são
compatíveis com CLS.

Observação
No Visual C++ 2002 e no Visual C++ 2003, __gc * foi usado para declarar um ponteiro
gerenciado. Este será substituído por um ^ no Visual C++ 2005, por exemplo ArrayList^ al = gcnew
ArrayList();.
Um ponteiro não gerenciado é o tradicional ponteiro C++ para um bloco de memória não
gerenciado do heap C++ padrão. Como ponteiros não gerenciados não fazem parte do CLS
(Common Language Specification), sua linguagem pode não fornecer sintaxe para definir ou
acessar estes tipos. Consulte a documentação da sua linguagem para informações sobre suporte
a ponteiros não gerenciados.
Um ponteiro de função não gerenciado é também um ponteiro C++ tradicional referente ao

endereço de uma função. O CLS fornece os delegados como uma alternativa gerenciada para
ponteiros de funções não gerenciados.
Uma definição explícita de um tipo ponteiro não é necessária. Todas as informações necessárias
para determinar o tipo de um ponteiro estão presentes quando o ponteiro é declarado.
Enquanto tipos ponteiro são tipos de referência, o valor de um tipo ponteiro não é um objeto e
você não pode determinar o tipo exato de tal valor.
O CTS fornece duas operações com segurança de tipos em tipos ponteiro: carregar um valor e
gravar um valor para o local referenciado pelo ponteiro. Estas operações com segurança de tipos
são compatíveis com CLS.
O CTS (Common Type System) também fornece três operações aritméticas de endereços
baseadas em bytes para tipos ponteiro: adição e subtração de inteiros a ponteiros, e subtrair um
ponteiro de outro. Os resultados das duas primeiras operações aritméticas retornam um valor do
mesmo tipo que o ponteiro original. Estas operações baseadas em bytes não são compatíveis
com CLS.

Os metadados e os componentes autodescritivos
No passado, um componente de software (.exe ou .dll) escrito em uma linguagem não podia
facilmente usar um componente de software escrito em outra linguagem. COM foi um passo para
a solução desse problema. O .NET Framework facilita a interoperação entre componentes
permitindo que compiladores emitam informações declarativas adicionais em todos os módulos e
assemblies. Essa informação, chamada de metadados, ajuda os componentes a interagir
perfeitamente.
Visão Geral Sobre Metadados

Metadados são informações binárias que descrevem o seu programa, o qual é fornecido em um
arquivo PE do Common Language Runtime ou na memória. Quando você compila seu código em
um arquivo PE, os metadados são inseridos em uma parte do arquivo, enquanto o código é
convertido para a Microsoft Intermediate Language (MSIL) e inserido em outra parte do arquivo.
Cada tipo e membro definido e referenciado em um módulo ou assembly é descrito em
metadados. Quando o código é executado, o Runtime carrega os metadados na memória e os
referencia para descobrir informações sobre suas classes de código, membros, herança e assim
por diante.
Os metadados descrevem cada tipo e membro definido no seu código de uma maneira neutra de
linguagem. Os metadados armazenam as seguintes informações:
• Descrição do Assembly.
o Identidade (nome, versão, cultura, chave pública).
o Os tipos que são exportados.
o Outros conjuntos de que este assembly depende.
o Permissões de segurança necessárias para executar.
• Descrição dos tipos.
o Nome, visibilidade, classe base e interfaces implementadas.
o Membros (métodos, campos, propriedades, eventos, tipos aninhados).
• Atributos.
o Elementos descritivos adicionais que modificam tipos e membros.
Benefícios de Metadados
Os metadados são a chave para um modelo de programação simples, eliminando a necessidade

de arquivos de Interface Definition Language (IDL), arquivos de cabeçalho ou qualquer método
externo de referência a componente. Os metadados permitem que linguagens .NET se descrevam
automaticamente de uma maneira neutra com relação a linguagem, sem que o desenvolvedor e o
usuário vejam. Além disso, metadados são extensíveis pelo uso de atributos. Os metadados
oferecem os seguintes benefícios principais:
• Arquivos autodescritivos.
Módulos Common Language Runtime e assemblies são autodescritivos. Os metadados de um
módulo contêm tudo o que ele precisa para interagir com outro módulo. Os metadados
fornecem automaticamente a funcionalidade de IDL no COM, permitindo que você use um
arquivo para definição e implementação. Módulos Runtime e assemblies não exigem registro
com o sistema operacional. Como resultado, as descrições usadas pelo Runtime sempre
refletem o código real no arquivo compilado, o que aumenta a confiabilidade do aplicativo.
• Interoperabilidade de linguagem e facilidade de design baseado em componentes.
Os metadados fornecem todas as informações necessárias sobre código compilado, para você
herdar uma classe de um arquivo de escrita PE em uma linguagem diferente. Você pode criar
uma instância de qualquer classe escrita em qualquer linguagem gerenciada (qualquer
linguagem que atinge o Common Language Runtime), sem se preocupar com o
empacotamento explícito ou com o uso de código de interoperabilidade personalizados.
• Atributos.
O .NET Framework permite que você declare tipos específicos de metadados, chamados
atributos, no seu arquivo compilado. Os atributos podem ser encontradas em toda a .NET
Framework, e são usados para controlar mais detalhadamente como o seu programa se
comporta em tempo de execução. Além disso, você pode emitir seus próprios metadados
personalizados em arquivos do .NET Framework, através de atributos definidos pelo usuário.
Para mais informações, consulte Estendendo Metadados Usando Atributos.
Estrutura e uso de metadados

Embora a maioria dos desenvolvedores não necessitem saber os detalhes da implementação de
metadados, alguns podem querer uma compreensão mais profunda. Esta seção fornece uma
visão geral sobre como metadados são armazenados em um arquivo executável portátil (pe) do
.NET Framework e uma explicação sobre a função dos metadados em execução gerenciadas.
Você não precisa para ler esta seção para entender a programação .NET ou como usar atributos.
Metadados e Estrutura do Arquivos PE

Os metadados são armazenadas em uma seção de um arquivo executável portável (PE) do .NET
Framework, enquanto que a Microsoft Intermediate Language (MSIL) é armazenada em outra
seção do arquivo PE. A parte de metadados do arquivo contém uma série de tabelas e estruturas
de dados heap. A parte MSIL contém símbolos MSIL e de metadados que fazem referência a
parte de metadados do arquivo PE. Você pode encontrar símbolos de metadados ao usar
ferramentas como o Desassemblador do MSIL (Ildasm.exe) para exibir o MSIL do seu código ou o
Depurador do Ambiente de Execução (Cordbg.exe) para executar um despejo de memória.
Tabelas e Heaps de Metadados
Cada tabela de metadados contém informações sobre os elementos do seu programa. Por
exemplo, uma tabela de metadados descreve as classes em seu código, outra descreve os
campos, e assim por diante. Se existirem dez classes em seu código, a tabela de classes terá dez
linhas, uma para cada classe. Tabelas de metadados referenciam outras tabelas e heaps. Por
exemplo, a tabela de metadados de classes faz referência a tabela de métodos.
Metadados também armazenam informações em quatro estruturas de heap: string, BLOB, string
de usuário e GUID. Todas as strings usadas para nomear tipos e membros são armazenadas no
heap de strings. Por exemplo, uma tabela de métodos não armazena diretamente o nome de um
método específico, mas aponta para nome do método armazenado no heap de strings.
Símbolos de Metadados
Cada linha de cada tabela de metadados é unicamente identificada na parte MSIL do arquivo PE
por um símbolo de metadados. Símbolos de metadados são conceitualmente semelhantes a
ponteiros, persistentes na MSIL, e referenciam uma tabela de metadados específica.
Um símbolo de metadados é um número de quatro bytes. O byte superior denota a tabela de

metadados, a qual se refere um token específico (método, tipo, e assim por diante). Os três bytes
restantes especificam a linha na tabela de metadados que corresponde ao elemento de

programação sendo descrito. Se você definir um método em C# e compilá-lo em um arquivo PE, o
seguinte símbolo de metadados pode ser gerado na parte MSIL do arquivo PE:
0x06000004
O byte superior (0x06) indica que esse é um token MethodDef. Os três bytes inferiores (000004)
informam ao Common Language Runtime para procurar na quarta linha da tabela MethodDef
pelas informações que descrevem essa definição de método.
Metadados em um arquivo PE
Quando um programa é compilado para o Common Language Runtime, ele é convertido em um

arquivo PE que consiste de três partes. A tabela a seguir descreve o conteúdo de cada parte.
Seção do
arquivo PE Conteúdo da seção
Cabeçalho O índice das seções principais do arquivo PE e o endereço do ponto de entrada.
O ambiente de execução usa essas informações para identificar o arquivo como
um arquivo PE e para determinar onde se iniciada a execução ao carregar o
programa na memória.
Instruções da As instruções da Microsoft Intermediate Language (MSIL) que compõem o seu
MSIL código. Muitas instruções da MSIL são acompanhadas de símbolos de
metadados.
Metadados Tabelas e heaps de metadados. O ambiente de execução usa essa seção para
registrar as informações sobre cada tipo e cada membro em seu código. Essa
seção também inclui atributos personalizados e informações de segurança.
Uso de metadados em tempo de execução

Para compreender melhor os metadados e sua função no Common Language Runtime, pode ser
útil criar um programa simples e ilustrar como os metadados afetam sua própria vida em tempo de
execução. O exemplo de código a seguir mostra dois métodos dentro uma classe chamada
MyApp. O método Main é o ponto de entrada do programa, enquanto o método Add simplesmente
retorna a soma dos dois argumentos inteiros.
C#
using System; public class MyApp { public static int Main() { int ValueOne = 10; int ValueTwo = 20;
Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo)); return 0; } public static int Add(int One,
int Two) { return (One + Two); } }
Quando o código é executado, o ambiente de execução carrega o módulo na memória e consulta

os metadados para esta classe. Após carregado, o ambiente de execução executa uma ampla
análise do fluxo Microsoft Intermediate Language (MSIL) do método para convertê-lo em
instruções de máquina nativas rápidas. ambiente de tempo de execução usa um compilador Just-
In-Time (JIT) para converter as instruções MSIL para código de máquina nativo para um método
ao mesmo tempo conforme o necessário.
O exemplo a seguir mostra parte do MSIL produzido a partir da função Main do código anterior.
Você pode visualizar o MSIL e os metadados de qualquer aplicativo .NET Framework usando o
Desassemblador do MSIL (ILDASM.exe).

.entrypoint .maxstack 3 .locals ([0] int32 ValueOne, [1] int32 ValueTwo, [2] int32 V_2, [3] int32 V_3)
IL_0000: ldc.i4.s 10 IL_0002: stloc.0 IL_0003: ldc.i4.s 20 IL_0005: stloc.1 IL_0006: ldstr "The Value is:
{0}" IL_000b: ldloc.0 IL_000c: ldloc.1 IL_000d: call int32 ConsoleApplication.MyApp::Add(int32,int32) /*
06000003 */
O compilador JIT lê o MSIL para o método inteiro, analisa-o completamente, e gera instruções
nativas eficientes para o método. Em IL_000d, um token de metadados para o método Add
(/* 06000003 */) é encontrado e o ambiente de tempo de execução usa o token para consultar a
terceira linha da tabela MethodDef.
A tabela a seguir mostra parte da tabela MethodDef referenciada pelo token de metadados que
descreve o método Add. Enquanto outras tabelas de metadados existirem neste assembly e
tiverem seus próprios valores exclusivos, somente esta tabela é examinada.
Endereço Nome (Aponta para Assinatura

virtual relativo o heap de seqüência (Aponta para o
Linha (RVA) ImplFlags Sinalizadores de caracteres.) heap de blob.)
1 0x00002050 IL Public .ctor (construtor)
Managed ReuseSlot
SpecialName
RTSpecialName
.ctor
2 0x00002058 IL Public Main String
Managed Static
ReuseSlot
3 0x0000208c IL Public Add int, int, int
Managed Static
ReuseSlot
Cada coluna da tabela contém informações importantes sobre seu código. A coluna RVA permite
que o ambiente de tempo de execução calcule o endereço de memória inicial do MSIL que define
este método. As colunas ImplFlags e Sinalizadores contêm máscaras de bits que descrevem o
método (por exemplo, se o método é público ou privado). A coluna Nome indexa o nome do
método a partir do heap de seqüência de caracteres. A coluna Assinatura indexa a definição da
assinatura do método no heap de blob.
O ambiente de tempo de execução calcula o endereço de deslocamento desejado a partir da

coluna RVA na terceira linha e retorna este endereço para o compilador JIT, que depois passa
para o novo endereço. O compilador JIT continua a processar o MSIL no novo endereço até
encontrar outro token de metadados, e o processo é repetido.
Usando metadados, o ambiente de tempo de execução tem acesso a todas as informações

necessárias para carregar seu código e processá-lo em instruções de máquina nativas. Desta
maneira, os metadados permitem arquivos autodescritivos e, juntamente com o CTS, herança
entre linguagens.
Assemblies no Common Language Runtime

Assemblies são os blocos de construção de aplicativos .NET Framework; eles formam a unidade
fundamental de implantação, controle de versão, reutilização, ativação de escopo e permissões de
segurança. Um assembly é uma coleção de tipos e recursos, que são construídos para trabalhar
juntos e formam uma unidade lógica de funcionalidade. Um assembly fornece o Common

Language Runtime com as informações necessárias para estar ciente das implementações de
tipo. Para o Runtime, um tipo não existe fora o contexto de um assembly.
Visão Geral Sobre Assemblies

Assemblies são uma parte fundamental da programação com o .NET Framework. Um assembly
executa as seguintes funções:
• Ele contém código que o Common Language Runtime executa. O código Microsoft
Intermediate Language (MSIL), em um arquivo executável portável (PE), não será executado
se ele não possuir um manifesto do assembly associado. Observe que cada assembly pode ter
somente um ponto de entrada (isto é, DllMain, WinMain ou Main).
• Ele forma um limite de segurança. Um assembly é a unidade em que permissões são
solicitadas e concedidas. Para obter mais informações sobre limites de segurança e como eles
se aplicam a assemblies, consulte Considerações Sobre Segurança do Assembly.
• Ele forma um limite de tipo. A identidade de cada tipo inclui o nome do assembly no qual
ele reside. Um tipo chamado MyType, carregado no escopo de um assembly, não é o mesmo
que um tipo chamado MyType, carregado no escopo de outro assembly.
• Ele forma um limite de referência de escopo. O manifesto do assembly contém metadados
do assembly que são usados para resolver tipos e satisfazer solicitações de recursos. Ele
especifica os tipos e recursos que são expostos fora do assembly. O manifesto também
enumera outros assemblies do qual ele depende.
• Ele forma um limite de versão. O assembly é a menor unidade com controle de versão no
Common Language Runtime; todos os tipos e recursos no mesmo assembly estão versionados
como uma unidade. O manifesto do assembly descreve as dependências de versão que você
especifica para qualquer assembly dependente. Para obter mais informações sobre o controle
de versão, consulte Controle de Versão do Assembly.
• Ele forma uma unidade de implantação. Quando um aplicativo é iniciado, somente os
módulos assembly que o aplicativo chama inicialmente devem estar presente. Outros
assemblies, como recursos de localização ou assemblies contendo classes utilitárias, podem
ser recuperados por demanda. Isso permite que aplicativos sejam mantidos simples e
pequenos no primeiro download. Para obter mais informações sobre como implantar
assemblies, consulte Implantação de Aplicativos.
• Essa é a unidade na qual a execução lado a lado é suportada. Para obter mais
informações sobre como executar várias versões de um assembly, consulte Assemblies e
Execução Lado a Lado.
Assemblies podem ser estáticos ou dinâmicos. Assemblies estáticos podem incluir tipos .NET
Framework (interfaces e classes), bem como recursos para o assembly (bitmaps, arquivos JPEG,
arquivos de recursos, e assim por diante). Assemblies estáticos são armazenados em disco em
arquivos PE. Você também pode usar o .NET Framework para criar assemblies dinâmicos, que
são executados diretamente da memória e não são salvos em disco antes da execução. Você
pode salvar assemblies dinâmicos no disco após sua execução.
Há várias maneiras de criar assemblies. Você pode usar ferramentas de desenvolvimento, como
Visual Studio 2005, que você usou anteriormente para criar arquivos .dll ou .exe. Você pode usar
ferramentas fornecidas pelo SDK do .NET Framework para criar assemblies, com módulos criados
em outros ambientes de desenvolvimento. Você também pode usar APIs do Common Language
Runtime, como Reflection.Emit, para criar assemblies dinâmicos.

Benefícios do Assembly
Assemblys são projetados para simplificar a implantação de aplicativos e para solucionar
problemas de versionamento que podem ocorrer em aplicativos baseados em componentes.
Usuários finais e desenvolvedores estão familiarizados com problemas de versionamento e

implantação. Problemas esses que surgem nos atuais sistemas baseados em componentes.
Alguns usuários finais têm sofrido a frustração de instalar um novo aplicativo em seus
computadores apenas para descobrir que outro aplicativo existente simplesmente parou de
funcionar. Muitos desenvolvedores já gastaram inúmeras horas tentando manter consistentes
todas as entradas do registro necessárias para ativar uma classe COM.
Muitos problemas de implantação têm sido resolvidos através uso de assemblys no .NET
Framework. Por eles seres componentes autodescritivos e por não dependerem de entradas do
registro, assemblys permitem que a instalação de aplicativos não tenha impacto algum. Eles
também simplificam a desinstalação e duplicação de aplicativos.
Problemas de Versionamento
Atualmente, dois problemas de versionamento ocorrem em aplicativos Win32:
• Regras de versionamento não podem ser expressas entre partes de um aplicativo e

impostas pelo sistema operacional. A abordagem atual depende da compatibilidade com
versões anteriores, o que é geralmente difícil de garantir. Uma vez publicadas, as definições de
interface devem ser estáticas. Uma única parte do código deve manter a compatibilidade com
as versões anteriores. Além disso, o código deve ser desenvolvido de forma que somente uma
única versão do mesmo possa estar presente e executando em um computador em qualquer
instante de tempo.
• Não há como manter a consistência entre conjuntos de componentes que são criados
juntos e o conjunto que está presente em tempo de execução.
Esses dois problemas de versionamento combinados criam conflitos de DLL, onde a instalação de
um aplicativo pode, inadvertidamente, quebrar um outro existente. Isso ocorre porque foi instalado
um determinado componente de software, ou DLL, que não era totalmente compatível com as
versões anteriores. Após decorrida essa situação, o sistema não possui suporte para diagnosticar
e corrigir o problema.
Acabando com os conflitos de DLL
O Microsoft ® Windows ® 2000 começou a atacar por completo esses problemas. Ele fornece
dois recursos que corrigem parcialmente conflitos de DLL:
• O Windows 2000 permite criar aplicativos cliente cujos arquivos .dll localizam-se na
mesma pasta do executável do aplicativo. O Windows 2000 pode ser configurado para verificar
um componente no diretório onde o executável está localizado antes de verificar o caminho
totalmente qualificado ou procurar o caminho normal. Isso permite que componentes sejam
independentes de componentes instalados e usados por outros aplicativos.
• O Windows 2000 bloqueia arquivos que vêm com o sistema operacional no diretório
System32, para que eles não possam ser substituídos quando novos aplicativos são
instalados.
O Common Language Runtime usa assemblys para continuar essa evolução em direção de uma
solução completa para conflitos de DLL.
A Solução do Assembly

Para resolver problemas de versionamento, assim como problemas restantes que levam a
conflitos de DLL, o ambiente de execução usa assemblys a fim de:
• Permitir que os desenvolvedores especifiquem regras de versão entre diferentes

componentes de software.
• Fornecer a infra-estrutura para impor regras de versão.
• Fornecer a infra-estrutura para permitir que várias versões de um componente sejam
executadas simultaneamente (o que chamamos de execução lado a lado).
Consulte também
Sumário de assembly
Em geral, um assembly estático pode consistir de quatro elementos:
• O manifesto do assembly, que contém metadados do assembly.

• Metadados de tipo.
• Código Microsoft Intermediate Language (MSIL) que implementa os tipos.
• Um conjunto de recursos.
Somente o manifesto do assembly é obrigatório, mas tipos e recursos são ambos necessários
para fornecer ao assembly qualquer funcionalidade significativa.
Há várias maneiras de se agrupar esses elementos em um assembly. Você pode agrupar todos os
elementos em um único arquivo físico, que é mostrado na ilustração a seguir.
Assembly de arquivo único
Como alternativa, os elementos de um assembly podem estar contidos em vários arquivos. Esses
arquivos podem ser módulos de código compilado (.netmodule), recursos (como arquivos .bmp ou
.jpg), ou outros arquivos necessários para o aplicativo. Crie um assembly multi-arquivos quando
desejar combinar módulos escritos em diferentes linguagens e otimizar o download de um
aplicativo colocando tipos raramente usados em um módulo que é baixado apenas quando
necessário.
Na ilustração a seguir, o desenvolvedor de um aplicativo hipotético escolheu separar alguns

códigos utilitários em um módulo diferente e manter um arquivo grande de recurso (neste caso
uma imagem .bmp) em seu arquivo original. O .NET Framework baixa um arquivo somente
quando ele é referenciado; manter códigos raramente referenciados em um arquivo separado do
aplicativo otimiza o download de código.
Assembly multi-arquivos

Observação
Os arquivos que compõem um assembly multi-arquivos não são fisicamente vinculados pelo
sistema de arquivos. Em vez disso, eles são vinculados através do manifesto do assembly e o
Common Language Runtime gerencia-os como uma unidade.
Nesta ilustração, todos os três arquivos pertencem a um assembly, conforme descrito no

manifesto do assembly contido em MyAssembly.dll. Para o sistema de arquivos, eles são três
arquivos separados. Observe que o arquivo Util.netmodule foi compilado como um módulo porque
ele não contém nenhuma informação de assembly. Quando o assembly foi criado, o manifesto do
assembly foi adicionado ao MyAssembly.dll, indicando seu relacionamento com Util.netmodule e
Graphic.bmp.
Assim como você cria hoje seu código-fonte, você toma decisões sobre como particionar a
funcionalidade do seu aplicativo em um ou mais arquivos. Ao criar código do .NET Framework,
você tomará decisões semelhantes sobre como particionar a funcionalidade em um ou mais
assemblies.
Manifesto do Assembly
Cada assembly, seja estático ou dinâmico, contém uma coleção de dados que descrevem como
os elementos do assembly se relacionam entre si. O manifesto do assembly contém esses
metadados do assembly. O manifesto de um assembly contém todos os metadados necessários
para especificar os requisitos de versão e o identificador de segurança, assim como todos os
metadados necessários para definir o escopo do assembly e analisar referências a recursos e
classes. O manifesto do assembly pode ser armazenado em um arquivo PE (.exe ou .dll) com
código da Microsoft Intermediate Language (MSIL) ou em um arquivo PE autônomo que contém
somente informações do manifesto do assembly.
A ilustração a seguir mostra as diferentes maneiras nas quais o manifesto pode se armazenado.
Tipos de assemblys

Para um assembly com um arquivo associado, o manifesto é incorporado no arquivo PE para
formar um assembly de arquivo único. Você pode criar um assembly de vários arquivos com um
arquivo de manifesto autônomo ou com o manifesto incorporado a um dos arquivos PE do
assembly.
Cada manifesto de um assembly executa as seguintes funções:
• Enumerar os arquivos que compõem o assembly.

• Orientar como as referências a tipos e recursos do assembly são mapeadas em arquivos
que contêm suas declarações e implementações.
• Enumerar outros assemblys dos quais depende o assembly.
• Fornecer um nível de indireção entre os consumidores do assembly e detalhes da
implementação do assembly.
• Processar o assembly autodescritivo.
Conteúdo do Manifesto do Assembly
A tabela a seguir mostra as informações contidas no manifesto do assembly. Os primeiros quatro

itens — informações sobre o nome, o número de versão, a cultura e o nome forte do assembly —
compõem a identidade do assembly.
Informações Descrição
Nome do assembly Uma seqüência de texto especificando o nome do assembly.
Número de versão Um número de versão principal e secundário e um número de revisão e de
compilação. O Common Language Runtime usa esses números para impor
uma política de versões.
Cultura Informações sobre a cultura ou a linguagem suportada pelo assembly. Essas
informações devem ser usadas somente para designar um assembly como
um assembly satélite contendo informações específicas de cultura ou de
linguagem. (Um assembly com informações de cultura é automaticamente
considerado um assembly satélite.)
Informações de A chave pública do publisher, caso tenha sido dado ao assembly um nome
nomes fortes forte.
Lista de todos os Um hash de cada arquivo contido no assembly e um nome de arquivo.
arquivos no Observe que todos os arquivos que compõem o assembly devem estar no
assembly mesmo diretório que o arquivo que contém o manifesto do assembly.
Informações de Informações usadas pelo ambiente de execução para mapear a referência

referência de tipo de um tipo ao arquivo que contém sua declaração e implementação. Usado
para tipos que são exportados do assembly.
Informações sobre Uma lista de outros assemblys que são referenciados estaticamente pelo
assemblys assembly. Cada referência inclui o nome do assembly dependente,
referenciados metadados do assembly (versão, cultura, sistema operacional, e assim por
diante) e chave pública, caso o assembly possua um nome forte.
Você pode adicionar ou alterar informações do manifesto do assembly usando os atributos do

assembly em seu código. Você pode alterar informações sobre versão e atributos informativos,
incluindo Trademark (marca comercial), Copyright (direitos autorais), Product (produto), Company
(empresa) e Informational Version (versão informativa). Para obter uma lista completa dos
atributos de um assembly, consulte Definindo os Atributos de um Assembly.
Cache Global de Assemblies

Cada computador onde o Common Language Runtime está instalado tem um cache de código da
máquina chamado de Cache Global de Assemblies. O Cache Global de Assemblies armazena
assemblies especificamente designados para serem compartilhados por vários aplicativos no
computador.
Você deve compartilhar assemblies instalando-os no cache global de assemblies somente quando
você precisa fazê-lo. Como diretriz geral, mantenha as dependências de um assembly privadas, e
localize assemblies no diretório de aplicativo a não ser que o compartilhamento de um Assembly
seja explicitamente necessário. Além disso, não é necessário instalar assemblies no cache global
de assemblies para torná-los acessíveis para interoperabilidade COM ou código não gerenciado.
Observação
Há situações em que você explicitamente não deseja instalar um Assembly no cache global de
assemblies. Se você colocar um dos assemblies que compõem um aplicativo no cache global de
assemblies, você não pode mais duplicar ou instalar o aplicativo usando o comando xcopy para
copiar o diretório do aplicativo. Você também deve mover o assembly no cache global de
assemblies.
Há várias maneiras para implantar um Assembly no cache global de assemblies:
• Use um instalador desenvolvido para funcionar com o cache global de assemblies. Essa é
a opção preferencial para instalar assemblies para o cache global de assemblies.
• Use uma ferramenta de desenvolvimento chamada de ferramenta Global Assembly Cache
(Gacutil.exe), fornecida pelo o .NET Framework SDK
• Use o Windows Explorer para arrastar módulos assemblies para o cache.
Observação
Nos cenários de implantação, use o Windows Installer 2.0 (site em inglês) para instalar assemblies
para o cache global de assemblies. Use o Windows Explorer ou a ferramenta Global Assembly
Cache apenas em cenários de desenvolvimento, porque eles não fornecem contagem de
referência do assembly e outros recursos fornecidos ao usar o Windows Installer.

Os administradores geralmente protegem o diretório systemroot usando uma lista de controle de
acesso (ACL) para controlar escrita e acesso de execução. Pelo fato de o cache global de
assemblies estar instalado em um subdiretório do diretório systemroot, ele herda o ACL dessa
pasta. É recomendável que apenas os usuários com privilégios de administrador tenham
permissão para excluir arquivos do cache global de assemblies.
Assemblies implantados no cache global de assemblies devem ter um nome forte. Quando um
Assembly é adicionado ao cache global de assemblies, são executadas verificações de
integridade em todos os arquivos que compõem o Assembly. O cache executa essas verificações
de integridade para garantir que um Assembly não foi violada, por exemplo, quando um arquivo foi
alterado mas o manifesto não refletir a alteração.
Assemblies de Nomes Fortes

Um nome forte consiste na identidade assembly— seu nome de texto simples, número de versão,
e informações de cultura (se fornecido) — mais uma chave pública e uma assinatura digital. Ela
será gerada a partir de um arquivo Assembly (o arquivo que contém o manifesto do Assembly,
que por sua vez contém os nomes e hashes de todos os arquivos que compõem o assembly),
usando a chave particular correspondente. O Microsoft® Visual Studio® .NET e outras
ferramentas de desenvolvimento fornecidas no .NET Framework SDK podem atribuir nomes fortes
para um Assembly. É esperado que assemblies com o mesmo nome forte sejam idênticos.
Você pode garantir que um nome seja globalmente exclusivo assinando um assembly com um
nome forte. Especificamente, nomes fortes satisfazem os requisitos a seguir:
• Nomes Fortes garantem a exclusividade do nome por confiar em pares de chaves

exclusivas. Ninguém pode gerar o mesmo nome de assembly que você pode, porque um
Assembly gerado com uma chave particular tem um nome diferente que um Assembly gerado
com outra chave particular.
• Nomes Fortes protegem a linhagem da versão de um Assembly. Um nome forte pode
garantir que ninguém pode produzir uma versão posterior do seu Assembly. Os usuários
podem ter certeza que a versão do assembly que eles estão carregando vem do mesmo
Publisher que criou a versão na qual o aplicativo foi compilado.
• Nomes Fortes fornecem uma verificação de integridade forte. Passando as verificações de
segurança do .NET Framework garante-se que o conteúdo do assembly não foi alterado desde
que ele foi criado. Observe, entretanto, que nomes fortes dentro e por eles mesmos não
implicam um nível de confiança como fornecido, por exemplo, por uma assinatura digital e
suportando certificado.
Quando você referencia um assembly de nome forte, você espera obter certos benefícios, como
versão e proteção de nomeação. Se o Assembly de nome forte então referencia um Assembly
com um nome simples, que não tem esses benefícios, você perde as vantagens que iria derivar
pelo uso de um Assembly de nome forte e reverte para conflitos de DLL. Por essa razão,
assemblies de nomes fortes podem apenas referenciar outros assemblies de nomes fortes.
Considerações sobre segurança de assemblies

• Quando você cria um assembly, você pode especificar um conjunto de permissões que o
assembly requer para executar. Se determinadas permissões são concedidas ou não a um
assembly isso é baseado nas evidências.
Há duas formas distintas de evidências que são usadas:

• A evidência de entrada será mesclada com a evidência coletada pelo carregador para criar
um conjunto final de evidências usadas para resolução de política. Os métodos que usam essa
semântica incluem Assembly.Load, Assembly.LoadFrom e Activator.CreateInstance.
• A evidência de entrada é usada inalterada como o conjunto final de evidências usado para
resolução de política. Os métodos que usam essa semântica incluem
AppDomain.DefineDynamicAssembly() e Assembly.Load(byte[]).
Permissões opcionais podem ser concedidas pelo conjunto de políticas de segurança no

computador onde o assembly será executado. Se você desejar que seu código manipule todas as
exceções de segurança potenciais, você pode seguir um desses procedimentos:
• Inserir uma solicitação de permissão para todas as permissões que seu código deve ter, e
tratar a falha em tempo de carga que ocorre se as permissões não são concedidas.
• Não usar uma solicitação de permissão para obter permissões que seu código pode não
precisar, mas estar preparado para manipular exceções de segurança se as permissões não
são concedidas.
Observação
Segurança é uma área complexa, e você tem várias opções para escolher. Para mais
informações, consulte Conceitos chave sobre segurança.
Em tempo de carga, as evidências do assembly são usadas como entrada para políticas de
segurança. A política de segurança é estabelecida pela empresa e pelo administrador do
computador bem como por configurações de políticas de usuário e determina o conjunto de
permissões que é concedido a todos os códigos gerenciados quando executados. Políticas de
segurança podem ser estabelecidas para o publisher do assembly (se ele tiver uma assinatura
gerada por uma ferramenta de assinatura), para o site e zona (em termos do Internet Explorer) de
que o assembly foi baixado, ou para o nome forte do assembly. Por exemplo, um administrador
pode estabelecer políticas de segurança que permitem que todo código baixado do site e
assinado por uma determinada de empresa software acesse um banco de dados em um
computador, mas não concede acesso para gravar no disco do computador.
Assemblies de nome forte e ferramentas de assinatura
Você pode assinar um assembly de duas maneiras diferentes mas complementares: com um
nome forte ou usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) no .NET Framework
versão 1.0 e 1.1 ou a Ferramenta de Assinatura (SignTool.exe) em versões posteriores do .NET
Framework. Assinar um assembly com um nome forte adiciona uma criptografia de chave pública
ao arquivo que contém o manifesto do assembly. Assinatura de nome forte ajuda a verificar
exclusividade de nome, a evitar falsificação de nome, e a fornecer chamadores com alguma
identidade quando uma referência é resolvida.
No entanto, nenhum nível de confiança é associado a um nome forte, o que torna a Ferramenta
de Assinatura de Arquivo (Signcode.exe) e Ferramenta de Assinatura (SignTool.exe) importantes.
As duas ferramentas de assinatura requerem um publisher para provar sua identidade para uma
autoridade de terceiros e obter um certificado. Esse certificado é então incorporado no seu arquivo
e pode ser usado por um administrador para decidir se confia na autenticidade do código.
Você pode dar um nome forte e uma assinatura digital criada usando a Ferramenta de Assinatura
de Arquivo (Signcode.exe) ou a Ferramenta de Assinatura (SignTool.exe) para um assembly, ou
você pode usar um sozinho. As duas ferramentas de assinatura podem assinar somente um
arquivo por vez; para um assembly com vários arquivos, você assina o arquivo que contém o
manifesto do assembly. Um nome forte é armazenado no arquivo que contém o manifesto do

assembly, mas uma assinatura criada usando a Ferramenta de Assinatura (SignTool.exe) ou a
Ferramenta de Assinatura de Arquivo (Signcode.exe) é armazenada em um slot reservado no
arquivo executável portável (PE) que contém o manifesto do assembly. A assinatura de um
assembly usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) ou a Ferramenta de
Assinatura (SignTool.exe) pode ser usada (com ou sem um nome forte) quando você já tem uma
hierarquia de confiança que confia nas assinaturas geradas pela Ferramenta de Assinatura de
Arquivo (Signcode.exe) ou pela Ferramenta de Assinatura (SignTool.exe), ou quando sua política
usa somente a parte chave e não verifica uma cadeia de confiança.
Observação
Ao usar um nome forte e uma assinatura gerada por uma ferramenta de assinatura em um
assembly, o nome forte deve ser atribuído primeiro.
O Common Language Runtime também executa uma verificação de hash; o manifesto do

assembly contém uma lista de todos os arquivos que compõem o assembly, incluindo um hash de
cada arquivo como ele existia quando o manifesto foi criado. Como cada arquivo é carregado, seu
conteúdo é comparado com o valor de hash armazenado no manifesto. Se os dois hashes não
coincidirem, o assembly falha ao carregar.
Devido ao nome forte e à assinatura usarem a garantia de integridade da Ferramenta de

Assinatura de Arquivo (Signcode.exe) ou da Ferramenta de Assinatura (SignTool.exe), você pode
basear a política de segurança para acesso a código nessas duas formas de evidências do
assembly. Nome forte e assinatura usam garantia de integridade da Ferramenta de Assinatura
(SignTool.exe) ou da Ferramenta de Assinatura de Arquivo (Signcode.exe) através de assinaturas
digitais e certificados. Todas as tecnologias mencionadas — Verificação de hash, nome forte, e
assinatura usando a Ferramenta de Assinatura de Arquivo (Signcode.exe) ou a Ferramenta de
Assinatura (SignTool.exe) — trabalham juntas para assegurar que o assembly não tenha sido
alterado de nenhuma maneira.
Versionamento de Assembly
Todos os versionamentos de assemblys que usam o Common Language Runtime são feitos no
nível do assembly. A versão de um assembly e as versões de assemblys dependentes são
registradas no manifesto do assembly. O política de versões padrão do ambiente de execução diz
que aplicativos devem executar somente com as versões com que foram criados e testados, a
menos que essa política de versões seja anulada por uma outra política explícitada nos arquivos
de configuração (o arquivo de configuração do aplicativo, o arquivo de política de editor e o
arquivo de configuração do administrador do computador).
Observação
Versionamento é feito somente em assemblys com nomes fortes.
O ambiente de execução executa as seguintes etapas para resolver uma solicitação de ligação de
assembly:
1. Verificar a referência do assembly original para determinar qual versão do assembly deve
ser ligada.
2. Verificar os arquivos de configuração apropriados para aplicar um política de versões.

3. Determinar o assembly correto a partir da referência do assembly original e de qualquer
redirecionamento especificado nos arquivos de configuração. Determinar a versão que deve
ser ligada ao assembly sendo chamado.
4. Verifica a cache global de assemblys, bases de código especificadas em arquivos de
configuração, e, em seguida, verifica os diretórios e subdiretórios do aplicativo usando as
regras de probing explicadas em Como o Ambiente de Execução Localiza Assemblys.
A ilustração a seguir mostra essas etapas.
Resolvendo uma solicitação de ligação de assembly
Para obter mais informações sobre como configurar aplicativos, consulte Arquivos de
Configuração. Para obter mais informações sobre políticas de ligação, consulte Como o Ambiente
de Execucão Localiza Assemblys.
Informações de Versão
Cada assembly possui duas maneiras diferentes de expressar informações de versão:
• Através do número de versão do assembly. Juntamente com as informações de nome e

cultura do assembly, o número de versão é parte da identidade do assembly. Esse número é
usado pelo ambiente de execução para impor uma política de versões e representa um papel
importante no processo de resolução de tipo em tempo de execução.
• Através de uma versão informativa, uma seqüência que representa informações de versão
adicionais incluída apenas para fins informativos.
Número de Versão do Assembly
Cada Assembly tem um número de versão como parte de sua identidade. Dessa forma, dois
assemblys que diferem pelo número de versão são considerados pelo ambiente de execução
assemblys completamente diferentes. Fisicamente, esse número de versão é representado
através de uma seqüência dividida em quatro partes com o seguinte formato:

< versão principal>.<versão secundária>.<número de compilação>.<revisão>
Por exemplo, a versão 1.5.1254.0 indica que 1 é a versão principal, 5 é a versão secundária, 1254
é o número de compilação e 0 é o número de revisão.
O número de versão é armazenado no manifesto do assembly junto com outras informações de a

identidade, incluindo o nome e a chave pública do assembly e informações de relacionamentos e
identidades de outros assemblys conectados ao aplicativo.
Quando um assembly é criado, a ferramenta de desenvolvimento registra as informações de

dependência de cada assembly referenciado no manifesto do assembly. O ambiente de execução
usa esses números versão, em conjunto com informações de configuração definidas por um
administrador, por um aplicativo, ou por um publisher, a fim de carregar a versão apropriada de
um assembly referenciado.
O ambiente de execução distingue assemblys regulares de assemblys com nomes fortes para fins
de versionamento. A verificação de versão só ocorre em assemblys com nomes fortes.
Para obter informações sobre como especificar uma política de ligação de versão, consulte
Arquivos de Configuração. Para obter informações sobre como o ambiente de execução usa
informações de versão para localizar um Assembly específico, consulte Como o Ambiente de
Execução Localiza Assemblys.
Versão Informativa do Assembly
A versão informativa é uma seqüência que anexa informações adicionais de versão a um

assembly, apenas para fins informativos. Essas informações não são usadas em tempo de
execução. A versão informativa baseada em texto corresponde a literatura de marketing do
produto, a embalagem ou ao nome do produto e não é usada pelo ambiente de execução. Por
exemplo, uma versão informativa poderia ser "Common Language Runtime versão 1.0" ou " NET
Control SP 2 ". Na guia Version da caixa de diálogo File Properties do Microsoft Windows, essas
informações aparecem no item "Product Version".
Observação
Embora você possa especificar qualquer texto, uma mensagem de aviso aparecerá durante a
compilação em dois casos: (i) se a seqüência não possuir o formato usado pelo número de versão
do assembly ou (ii) se está no formato correto, mas contém wildcards. Esse aviso é inofensivo.
A versão informativa é representada usando o atributo

System.Reflection.AssemblyInformationalVersionAttribute. Para obter mais informações sobre o
atributo da versão informativa, consulte Definindo Atributos do Assembly.
Posicionamento do Assembly
Para a maioria dos aplicativos .NET Framework, você localiza assemblies que compõem um
aplicativo no diretório do aplicativo, em uma subpasta da pasta do aplicativo ou no cache global
de assemblies (se o assembly for compartilhado). Você pode substituir onde o Common Language
Runtime procura por um assembly, usando o elemento <CODEBASE> em um arquivo de
configuração. Se o assembly não tiver um nome forte, a localidade especificada usando o
elemento <CODEBASE> é restrita para o diretório do aplicativo ou para a subpasta. Se o
assembly tiver um nome forte, o elemento <CODEBASE> pode especificar qualquer localidade no
computador ou em uma rede.

Regras similares se aplicam à localização de assemblies ao trabalhar com código não gerenciado
ou aplicativos interop COM: se o assembly será compartilhado por vários aplicativos, ele deverá
ser instalado no cache global de assemblies. Assemblies usados com códigos não gerenciados
devem ser registrados e exportados como uma biblioteca de tipos. Assemblies usados pelo COM
interop devem ser registrados no catálogo, embora em alguns casos, esse registro ocorra
automaticamente.
Assemblies e execução lado a lado

Execução lado a lado é a capacidade de armazenar e executar várias versões de um aplicativo ou
componente no mesmo computador. Isso significa que você pode ter várias versões do runtime, e
várias versões de aplicativos e componentes que usam uma versão do runtime, no mesmo
computador ao mesmo tempo. A execução lado a lado lhe dá mais controle sobre quais versões
de um componente um aplicativo está vinculado, e mais controle sobre que versão do Runtime um
aplicativo usa.
Suporte para armazenamento lado a lado e execução de diferentes versões do mesmo assembly
é uma parte integral de nomeação forte e está embutido no infra-estrutura do Runtime. Pelo fato
de o número da versão do assembly de nome forte fazer parte de sua identidade, o tempo de
execução pode armazenar várias versões de o mesmo assembly no cache global de assemblies,
e carregar esses módulos em tempo de execução.
Embora o Runtime proporcione a capacidade para criar aplicativos lado a lado, a execução lado a
lado não é automática. Para obter mais informações sobre a criação de aplicativos para execução
lado a lado, consulte Diretrizes para criar aplicativos e componentes para execução lado a lado.
Visão Geral da Biblioteca de Classes do .NET Framework

O .NET Framework inclui classes, interfaces e tipos de valor que aceleram e otimizam o processo
de desenvolvimento e fornecem acesso à funcionalidades do sistema. Para facilitar a
interoperabilidade entre linguagens, os tipos do .NET Framework são compatíveis com CLS e,
portanto, podem ser usados por qualquer linguagem de programação cujo compilador está de
acordo com a CLS (Common Language Specification).
Os tipos do .NET Framework compões a base na qual os aplicativos, componentes e controles do

.NET são criados. O .NET Framework inclui tipos que executam as seguintes funções:
• Representar tipos de dados base e exceções.

• Encapsular estruturas de dados.
• Executar E/S.
• Acessar informações sobre os tipos carregados.
• Invocar as verificações de segurança do .NET Framework.
• Fornecer acesso a dados, uma GUI detalhada do lado do cliente e uma GUI do lado do
cliente controlada pelo servidor.
O .NET Framework fornece um rico conjunto de interfaces, bem como classes abstratas e
concretas. Você pode usar diretamente as classes concretas ou pode derivar suas próprias
classes a partir delas. Para usar a funcionalidade de uma interface, você pode criar uma classe
que implementa a interface ou derivar uma classe de uma das classes do .NET Framework que
implementa a interface.
Convenções de Nomenclatura

Os tipos do .NET Framework usam um esquema de nomenclatura de sintaxe de ponto que dá a
idéia de hierarquia. Essa técnica agrupa tipos relacionados em namespaces para que os tipos
possam ser procurados e referenciados mais facilmente. A primeira parte do nome completo —
até o ponto mais a direita — constitui o nome do namespace. A última parte do nome é o nome do
tipo. Por exemplo, System.Collections.ArrayList representa o tipo ArrayList que pertence ao
namespace System.Collections. Os tipos em System.Collections podem ser usados para
manipular coleções de objetos.
Esse esquema de nomenclatura facilita, para os desenvolvedores de bibliotecas, a extensão do

.NET Framework a fim de criar grupos hierárquicos de tipos e nomeá-los de uma maneira
consistente e informativa. Espera-se que os desenvolvedores de bibliotecas usem as seguintes
diretrizes ao criar nomes para seus namespaces:
NomeDaEmpresaNomeDaTecnologia
Por exemplo, o namespace Microsoft.Word está de acordo com essa diretriz.
O uso de padrões de nomenclatura para agrupar tipos relacionados em namespaces é uma

maneira muito útil de criar e documentar bibliotecas de classes. Entretanto, esse esquema de
nomenclatura não tem efeito sobre a visibilidade, acesso a membro, herança, segurança ou
vinculação. Um namespace pode ser particionado em vários assemblys. Um único assembly pode
conter tipos de vários namespaces diferentes. O assembly fornece a estrutura formal para o
versionamento, a implantação, a segurança, o carregamento e a visibilidade no Common
Language Runtime.
Para obter mais informações sobre namespaces e nomes de tipos, consulte CTS (Common Type
System).
O Namespace System
O namespace System é o namespace raiz para tipos fundamentais do .NET Framework. Esse
namespace inclui classes que representam os tipos de dados base usados por todos os
aplicativos: Object (a raiz da hierarquia de herança), Byte, Char, Array, Int32, String, etc. Muitos
desses tipos correspondem aos tipos de dados primitivos que são usados pelas linguagens de
programação. Quando você escreve um código usando os tipos do .NET Framework, você pode
usar a correspondente palavra-chave da linguagem onde um tipo de dado base do .NET
Framework é esperado.
A tabela a seguir lista alguns dos tipos de valor que são fornecidos pelo .NET Framework. É dada
uma breve descrição cada tipo e uma indicação do tipo correspondente em Visual Basic, C# e
C++. A tabela também inclui entradas para a classes Object e String, para as quais várias
linguagens possuem as palavras-chave correspondentes.
Tipo de
Nome dado em Tipo de Tipo de Tipo de
da Visual dado em dado em dado em
Categoria classe Descrição Basic C# C++ JScript
Inteiro Byte Um inteiro de 8 bits sem Byte Byte char Byte
sinal.
SByte Um inteiro de 8 bits com SByte sbyte signed SByte
sinal. char
Não compatível com CLS.
Int16 Um inteiro de 16 bits com Short short short short
sinal.

Int32 Um inteiro de 32 bits com Integer int int int
sinal. -ou-
long
Int64 Um inteiro de 64 bits com Long long __int64 long
sinal.
UInt16 Um inteiro e 16 bits sem UShort ushort unsigned UInt16
sinal. short
UInt32 Um inteiro de 32 bits sem UInteger uint unsigned UInt32
sinal. int
Não compatível com CLS. -ou-
unsigned
long
UInt64 Um inteiro de 64 bits sem ULong ulong unsigned UInt64
sinal. __int64
Ponto Single Número de ponto flutuante Single float float float
flutuante de precisão simples (32
bits).
Double Número de ponto flutuante Double double double double
de precisão dupla (64 bits).
Lógico Boolean Um valor booleano (true Boolean bool bool bool
ou false).
Outros Char Um caractere unicode (16 Char char wchar_t char
bits).
Decimal Um valor decimal (128 Decimal decimal Decimal Decimal
bits).
IntPtr Um inteiro com sinal cujo IntPtr IntPtr IntPtr IntPtr
tamanho depende da Nenhum Nenhum Nenhum
plataforma subjacente (um tipo tipo tipo
valor de 32 bits em uma interno. interno. interno.
plataforma de 32 bits e um
valor de 64 bits em uma
plataforma de 64 bits).
UIntPtr Um inteiro sem sinal cujo UIntPtr UIntPtr UIntPtr UIntPtr
tamanho depende da Nenhum Nenhum Nenhum
plataforma subjacente (um tipo tipo tipo
valor de 32 bits em uma interno. interno. interno.
plataforma de 32 bits e um
valor de 64 bits em uma
plataforma de 64 bits).
Objetos de Object A raiz da hierarquia de Object object Object* Object
Classe objeto.
String Uma seqüência de String string String* String
caracteres Unicode
imutável e de comprimento
fixo.

Além dos tipos de dados base, o namespace System contém mais de 100 classes, variando de
classes que tratam exceções a classes que lidam com os principais conceitos do ambiente de
execução, como domínios de aplicativo e coleta de lixo. O namespace System também contém
vários namespaces de segundo nível.
Para obter mais informações sobre namespaces, consulte a Referência do .NET Framework. Essa
documentação fornece uma visão geral sobre cada namespace, assim como uma descrição
formal de cada tipo e de seus membros.
Localizador rápido de tecnologia

A tabela a seguir fornece uma referência rápida para as principais áreas de tecnologias do .NET
Framework.
Para aprender sobre... Consultar...
Biblioteca de classes do .NET Visão geral sobre a biblioteca de classes do .NET

Framework Framework
ADO.NET ADO.NET
Domínios de aplicativos Usando domínios de aplicativos
ASP.NET Criando aplicativos ASP.NET

Visão geral do ASP.NET
Controles de servidores Web do ASP.NET
Assemblies Programação com assemblies
Programação assíncrona COMO: Encadear chamadas assíncronas com um método

de Web Service
CodeDom Geração e compilação dinâmicas de código fonte
Common Language Runtime Common Language Runtime
Configuração Configurando aplicativos

Configurando aplicativos ASP.NET
Acesso a dados Acesso a dados
Depuração Depuração e perfil de aplicativos
Implantação Implantação de ClickOnce para aplicativos de formulários do

Windows
Implantando aplicativos .NET Framework

Noções básicas sobre implantação de .NET Framework
Designers e o ambiente de design Estendendo suporte em tempo de design
Eventos Tratamento e disparada de eventos
Exceções Tratamento e lançamento de exceções
Coleta de lixo Coleta de lixo
GDI + Elementos gráficos e desenho em formulários do Windows
Tipos genéricos Reflexão e tipos genérico
E/S E/S de arquivo e de fluxo
Interoperabilidade Interoperabilidade
Desenvolvimento móvel .NET Compact Framework

Criando aplicativos móveis ASP .NET
Redes Programação de redes
Reflexão Reflexão
Arquitetura de comunicação remota Objetos remotos

Visão geral sobre a arquitetura de comunicação remota do
.NET Framework
Segurança Segurança no .NET Framework

Conceitos chaves sobre segurança
Componentes atendidos Escrevendo componentes atendidos

Visão geral sobre componentes atendidos
Serialização Serialização
Execução lado a lado Execução lado a lado
Threads Threads gerenciadas
Formulários do Windows Formulários do Windows no .NET Framework

Controles de formulários do Controles de formulários do Windows
Windows
XML Documentos e dados XML
XML Web Services Visão geral sobre XML Web Services
Como Criar uma Listagem de Diretório
O exemplo de código a seguir mostra como usar as classes de E/s para criar uma lista de todos
os arquivos com a extensão ".exe " em um diretório.
Exemplo
C#
using System; using System.IO; class DirectoryLister { public static void Main(String[] args) { string path =
"."; if (args.Length > 0) { if (File.Exists(args[0]) { path = args[0]; } else { Console.WriteLine("{0} not found;
using current directory:", args[0]); } DirectoryInfo dir = new DirectoryInfo(path); foreach (FileInfo f in
dir.GetFiles("*.exe")) { String name = f. Name; long size = f.Length; DateTime creationTime =
f.CreationTime; Console.WriteLine("{0,-12:N0} {1,-20:g} {2}", size, creationTime, name); } } }
Neste exemplo, (.. ",) e o código relaciona todos os arquivos na pasta atual ter uma extensão.exe,
junto com seus tamanho do arquivo, hora de criação, e nome. " é a pasta atual, indicada pelo
DirectoryInfo Supondo que havia arquivos.exe na subpasta \Bin da C:\MyDir, a saída desse código
pode parecer isso:
953 7/20/2000 10:42 AM C:\MyDir\Bin\paramatt.exe 664 7/27/2000 3:11 PM C:\MyDir\Bin\tst.exe 403

8/8/2000 10:25 AM C:\MyDir\Bin\dirlist.exe
Se você desejar uma lista de arquivos em outro diretório, como o diretório de raiz C:\, passar o
argumento " C:\ " para o executável gerado por compilação esse código, por exemplo: "
testApplication.EXE C:\ ".
Observação
Usuários Visual Basic podem optar por usar os métodos e propriedades fornecidas pelo objeto
My.Computer.FileSystem para a E/s de arquivos. Para obter mais informações, consulte Objeto
My.Computer.FileSystem.
Como: Ler e gravar em um arquivo de dados recém criado
O BinaryWriter e BinaryReader classes são usados para gravar e ler dados, em vez de caracteres
seqüências. O exemplo de código a seguir demonstra gravar dados e Ler dados de um fluxo de
arquivo novo e vazio (Test.data). Após criar os dados arquivos na pasta atual, a associada
BinaryWriter e BinaryReader são criados, é usado para gravar os inteiros 0 a 10 para Test.data,
que deixa o ponteiro de arquivo no final do arquivo. e BinaryWriter Após definir o ponteiro de
arquivo volta para a origem, as BinaryReader leituras sem o conteúdo especificado.

Exemplo
C#
using System; using System.IO; class MyStream { private const string FILE_NAME = "Test.data"; public
static void Main(String[] args) { // Create the new, empty data file. if (File.Exists(FILE_NAME)) {
Console.WriteLine("{0} already exists!", FILE_NAME); return; } FileStream fs = new
FileStream(FILE_NAME, FileMode.CreateNew); // Create the writer for data. BinaryWriter w = new
BinaryWriter(fs); // Write data to Test.data. for (int i = 0; i < 11; i++) { w.Write( (int) i); } w.Close();
fs.Close(); // Create the reader for data. fs = new FileStream(FILE_NAME, FileMode.Open,
FileAccess.Read); BinaryReader r = new BinaryReader(fs); // Read data from Test.data. for (int i = 0; i < 11;
i++) { Console.WriteLine(r.ReadInt32()); } r.Close(); fs.Close(); } }
Se Test.data é acionada. já existe no diretório atual, um IOException Usar FileMode.Create para

criar um novo arquivo sem organizando sempre um IOException.
Como: Abrir e anexar aum arquivo de log
e StreamWriterStreamReader caracteres para gravar e ler caracteres fluxos. O exemplo de código

a seguir abre o log.txt arquivo para entrada, ou cria o arquivo se ele ainda não existir, e acrescenta
informações ao final do arquivo. O conteúdo do arquivo são gravados na saída padrão para
exibição. Como uma alternativa para este exemplo, as informações pode ser armazenadas como
uma única seqüência ou matriz de seqüência, e a WriteAllText. ou WriteAllLines método pode ser
usado para obter a mesma funcionalidade
Observação
Do My.Application.Log Usuários Visual Basic podem optar por usar os métodos e propriedades
fornecidas pelo ou My.Computer.FileSystem objetos para criar ou gravar em arquivos de log.
Para obter mais informações, consulte Objeto My.Application.Log e Objeto
Exemplo
C#
using System; using System.IO; class DirAppend { public static void Main(String[] args) { using
(StreamWriter w = File.AppendText("log.txt")) { Log ("Test1", w); Log ("Test2", w); // Close the writer and
underlying file. w.Close(); } // Open and read the file. using (StreamReader r = File.OpenText("log.txt")) {
DumpLog (r); } } public static void Log (String logMessage, TextWriter w) { w.Write("\r\nLog Entry : ");
w.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
w.WriteLine(" :"); w.WriteLine(" :{0}", logMessage); w.WriteLine ("-------------------------------"); // Update
the underlying file. w.Flush(); } public static void DumpLog (StreamReader r) { // While not at the end of the
file, read and write lines. String line; while ((line=r.ReadLine())!=null) { Console.WriteLine(line); } r.Close();
}}
Como Escrever Texto em um Arquivo
Os exemplos de código a seguir mostram como gravar texto em um arquivo de texto.

O primeiro exemplo mostra como adicionar texto a um arquivo existente. O segundo exemplo
mostra como criar um novo arquivo de texto e gravar uma seqüência a ele. Funcionalidade
semelhante pode ser fornecida pelos métodos WriteAllText.
Observação
Exemplo
C#
using System; using System.IO; class Test { public static void Main() { // Create an instance of StreamWriter
to write text to a file. // The using statement also closes the StreamWriter. using (StreamWriter sw = new
StreamWriter("TestFile.txt")) { // Add some text to the file. sw.Write("This is the "); sw.WriteLine("header
for the file."); sw.WriteLine("-------------------"); // Arbitrary objects can also be written to the file.
sw.Write("The date is: "); sw.WriteLine(DateTime.Now); } } }
C#
using System; using System.IO; public class TextToFile { private const string FILE_NAME = "MyFile.txt";
public static void Main(String[] args) { if (File.Exists(FILE_NAME)) { Console.WriteLine("{0} already
exists.", FILE_NAME); return; } using (StreamWriter sw = File.CreateText(FILE_NAME)) { sw.WriteLine
("This is my file."); sw.WriteLine ("I can write ints {0} or floats {1}, and so on.", 1, 4.2); sw.Close(); } } }
Como: Ler texto de um arquivo
Os exemplos de código a seguir mostram como ler texto de um arquivo de texto. O segundo
exemplo notifica você quando o final do arquivo for detectado. Do ReadAllLines essa
funcionalidade também pode ser obtida usando ou ReadAllText métodos.
Exemplo
C#
using System; using System.IO; class Test { public static void Main() { try { // Create an instance of
StreamReader to read from a file. // The using statement also closes the StreamReader. using (StreamReader
sr = new StreamReader("TestFile.txt")) { String line; // Read and display lines from the file until the end of
// the file is reached. while ((line = sr.ReadLine()) != null) { Console.WriteLine(line); } } } catch (Exception
e) { // Let the user know what went wrong. Console.WriteLine("The file could not be read:");
Console.WriteLine(e.Message); } } }
C#
using System; using System.IO; public class TextFromFile { private const string FILE_NAME = "MyFile.txt";
public static void Main(String[] args) { if (!File.Exists(FILE_NAME)) { Console.WriteLine("{0} does not
exist.", FILE_NAME); return; } using (StreamReader sr = File.OpenText(FILE_NAME)) { String input; while
((input=sr.ReadLine())!=null) { Console.WriteLine(input); } Console.WriteLine ("The end of the stream has
been reached."); sr.Close(); } }

Este código cria um StreamReader que aponta para MyFile.txt por meio de uma chamada para
File.OpenText. Retorna StreamReader.ReadLine cada linha como uma seqüência. Quando não
houver nenhum mais caracteres para ler, uma mensagem é exibida com essa informação, e o
fluxo está fechado.
Observação
Como Ler Caracteres de uma Seqüência de Caracteres
O exemplo de código a seguir permite que você a ler um determinado número de caracteres uma
seqüência existente, começando no local especificado na seqüência. Use StringReader para fazer
isso, conforme demonstrado abaixo.
Este código define uma seqüência e converte-para uma matriz de caracteres, que então pode ser
lido pelo utilizando o método apropriado StringReader.Read.
Este exemplo lê apenas o número especificado de caracteres da seqüência, da seguinte maneira.
Some number o
Exemplo
C#
using System; using System.IO; public class CharsFromStr { public static void Main(String[] args) { // Create
a string to read characters from. String str = "Some number of characters"; // Size the array to hold all the
characters of the string // so that they are all accessible. char[] b = new char[24]; // Create an instance of
StringReader and attach it to the string. StringReader sr = new StringReader(str); // Read 13 characters from
the array that holds the string, starting // from the first array member. sr.Read(b, 0, 13); // Display the
output. Console.WriteLine(b); // Close the StringReader. sr.Close(); } }
Como Escrever Caracteres em uma Seqüência de Caracteres
O exemplo de código a seguir grava um determinado número de caracteres de uma matriz de

caracteres em uma seqüência existente, começando no local especificado na matriz. Use
StringWriter para fazer isso, conforme demonstrado abaixo.
Exemplo
C#
using System; using System.IO; using System.Text; public class CharsToStr { public static void Main(String[]
args) { // Create an instance of StringBuilder that can then be modified. StringBuilder sb = new
StringBuilder("Some number of characters"); // Define and create an instance of a character array from
which // characters will be read into the StringBuilder. char[] b = {' ','t','o',' ','w','r','i','t','e',' ','t','o','.'}; //
Create an instance of StringWriter // and attach it to the StringBuilder. StringWriter sw = new
StringWriter(sb); // Write three characters from the array into the StringBuilder. sw.Write(b, 0, 3); //
Display the output. Console.WriteLine(sb); // Close the StringWriter. sw.Close(); } }

Este exemplo ilustra o uso do para modificar uma seqüência existente. um StringBuilder Observe
que isso requer uma declaração adicional using, como a StringBuilder classe é um membro do
espaço para nome System.Text. Além disso, em vez de definir uma seqüência e convertê-la em
uma matriz de caracteres, este é um exemplo de criar uma matriz de caractere diretamente e
inicializando ele.
Esse código produz o seguinte resultado.
Some number of characters to
Como Adicionar ou Remover Entradas da Lista de Controle de Acesso
Para adicionar ou remover entradas controle acesso (ACL) Lista para ou de um arquivo, ou
DirectorySecurity Objeto deve ser obtido o arquivo ou pasta, modificado, e aplicados novamente
ao arquivo ou pasta.. o FileSecurity
Para adicionar ou remover uma entrada ACL de um arquivo

1. Chame o GetAccessControl método para obter um FileSecurity objeto que contém as
entradas ACL atuais de um arquivo.
2. Adicionar ou remover entradas ACL do objeto FileSecurity retornado da etapa 1.
3. Passar o FileSecurity objeto para o SetAccessControl método para aplicar as alterações.
Para adicionar ou remover uma entrada ACL de um diretório
1. Chame o GetAccessControl método para obter um DirectorySecurity objeto que contém
as entradas ACL atuais de uma pasta.
2. Adicionar ou remover entradas ACL do objeto DirectorySecurity retornado da etapa 1.
3. Passar o DirectorySecurity objeto para o SetAccessControl método para aplicar as
alterações.
Exemplo
C#
using System; using System.IO; using System.Security.AccessControl; namespace FileSystemExample { class
FileExample { public static void Main() { try { string fileName = "test.xml"; Console.WriteLine("Adding
access control entry for " + fileName); // Add the access control entry to the file. AddFileSecurity(fileName,
@"DomainName\AccountName", FileSystemRights.ReadData, AccessControlType.Allow);
Console.WriteLine("Removing access control entry from " + fileName); // Remove the access control entry
from the file. RemoveFileSecurity(fileName, @"DomainName\AccountName", FileSystemRights.ReadData,
AccessControlType.Allow); Console.WriteLine("Done."); } catch (Exception e) { Console.WriteLine(e); } } //
Adds an ACL entry on the specified file for the specified account. public static void AddFileSecurity(string
fileName, string account, FileSystemRights rights, AccessControlType controlType) { // Get a FileSecurity
object that represents the // current security settings. FileSecurity fSecurity =
File.GetAccessControl(fileName); // Add the FileSystemAccessRule to the security settings.
fSecurity.AddAccessRule(new FileSystemAccessRule(account, rights, controlType)); // Set the new access
settings. File.SetAccessControl(fileName, fSecurity); } // Removes an ACL entry on the specified file for the
specified account. public static void RemoveFileSecurity(string fileName, string account, FileSystemRights
rights, AccessControlType controlType) { // Get a FileSecurity object that represents the // current security
settings. FileSecurity fSecurity = File.GetAccessControl(fileName); // Add the FileSystemAccessRule to the

security settings. fSecurity.RemoveAccessRule(new FileSystemAccessRule(account, rights, controlType)); //
Set the new access settings. File.SetAccessControl(fileName, fSecurity); } } }
Você deve fornecer um usuário ou conta de grupo válido para executar esse exemplo. Este
exemplo usa um File objeto; no entanto, o mesmo procedimento é usado para o FileInfo,
Directory., e DirectoryInfo Classes
Criando Novas Seqüências de Caracteres

O.NET Framework fornece vários métodos da classe System.String que criar novos objetos de
seqüência, combinando várias seqüências, matrizes de seqüências, ou objetos. A tabela a seguir
lista diversos métodos útil.
Nome do
método Uso
String.Format Cria uma seqüência formatada de um conjunto de objetos de entrada.
String.Concat Cria seqüências de dois ou mais seqüências.
String.JOIN Cria uma nova seqüência, combinando uma matriz de seqüências.
String.Insert Cria uma nova seqüência inserindo uma seqüência no índice especificado de
uma seqüência existente.
String.CopyTo Cópias especificado caracteres em uma seqüência em uma posição
especificada de caracteres em uma matriz.
Formato
Você pode usar o String.Format método para criar seqüências formatadas e concatenar
seqüências que representam vários objetos Qualquer objeto passado esse método converte
automaticamente em uma seqüência. Por exemplo, se seu aplicativo deve exibir um Int32 valor e
um DateTime valor para o usuário, você pode construir uma seqüência para representar esses
valores usando o Format método facilmente. Para obter informações sobre como formatar
convenções usadas com esse método, consulte a seção sobre composição formatação.
O exemplo a seguir usa o Format método para criar uma seqüência que usa uma variável Inteiro.
C#
int MyInt = 12; string MyString = String.Format("Your dog has {0} fleas. It is time to get a flea collar. The
current universal date is: {1:u}." , MyInt, DateTime.Now); Console.WriteLine(MyString);
O exemplo anterior exibe o texto ' Your dog has 12 fleas. It is time to get a flea collar. The current
universal date is: 2001-04-10 15:51:24Z.. ' para o console Exibe DateTime.Now a data atual e tempo
de uma maneira especificada pela cultura associada a segmento atual.
Concat
O String.Concat método pode ser usado para facilmente criar um novo objeto seqüência de
caracteres de dois ou mais objetos existentes. Ele fornece uma forma independente de linguagem
para concatenar seqüências. Esse método aceita qualquer classe que deriva de System.Object.
O exemplo a seguir cria uma seqüência de dois objetos de seqüência e um caractere separating.

C#
string MyString = "Hello"; string YourString = "World!"; Console.WriteLine(String.Concat(MyString, ' ',
YourString));
Esse código exibe Hello World! para o console.
Ingressar
O String.Join método cria uma nova seqüência de uma matriz de seqüências e uma seqüência
de caracteres separadores. Esse método é útil se você desejar concatenar várias seqüências
juntos, fazer uma lista talvez separada por uma vírgula.
O exemplo a seguir usa um espaço para vincular uma matriz de seqüência de caracteres.
C#
string[] MyString = {"Hello", "and", "welcome", "to", "my" , "world!"}; Console.WriteLine(String.Join(" ",
MyString));
Esse código exibe Hello and welcome to my world! para o console.
Inserir
O String.Insert método cria uma nova seqüência inserindo uma seqüência em uma posição na
outra seqüência especificada. Esse método usa um índice com base zero. O exemplo a seguir
insere uma seqüência no quinta a posição do MyString índice e cria uma nova seqüência com
esse valor.
C#
string MyString = "Once a time."; Console.WriteLine(MyString.Insert(4, " upon"));
Esse código exibe Once upon a time. para o console.
CopyTo
O String.CopyTo método copia partes de uma seqüência em uma matriz de caracteres. Você
pode especificar os dois índice Início da seqüência e o número de caracteres a serem copiados.
Este método utiliza o índice fonte, uma matriz de caracteres, o índice de destino, e o número de
caracteres para copiar. Todos os índices são baseada em zero.
O exemplo a seguir usa o CopyTo método para copiar os caracteres da palavra " Hello " de um
objeto de seqüência para a primeira posição de índice de uma matriz de caracteres.
C#
string MyString = "Hello World!"; char[] MyCharArray = {'W','h','e','r','e'}; Console.WriteLine("The original
character array: {0}", MyCharArray); MyString.CopyTo(0, MyCharArray,0 ,5); Console.WriteLine("The new
character array: {0}", MyCharArray);
Esse código exibirá o seguinte para o console.
The original character array: Where The new character array: Hello

Aparando e Removendo Caracteres
Se você estiver analisando uma frase em palavras individuais, você pode finalizar backup com
palavras que tenham espaços em branco (também chamados espaços em branco) em qualquer
uma das extremidades da palavra. Nessa situação, você pode usar um dos métodos aparo na
classe System.String para remover qualquer número de espaços ou outros caracteres de uma
posição especificada na seqüência de caracteres A tabela a seguir descreve os métodos aparo
disponíveis.
Nome do
método Uso
String.Trim Remove espaços em branco de início e no fim de uma seqüência.
String.TrimEnd Remove caracteres especificados em uma matriz de caracteres a partir do final
de uma seqüência.
String.TrimStart Remove caracteres especificados em uma matriz de caracteres de início de
uma seqüência.
String.Remove Remove um número especificado de caracteres de uma posição índice
especificado na seqüência.
Aparar
Facilmente você pode remover espaços em branco de ambas as extremidades de uma seqüência
usando o String.Trim método, conforme mostrado no exemplo o seguir.
C#
String MyString = " Big "; Console.WriteLine("Hello{0}World!", MyString ); string TrimString =
MyString.Trim(); Console.WriteLine("Hello{0}World!", TrimString );
Esse código exibe as seguintes linhas ao console.
Hello Big World! HelloBigWorld!
TrimEnd
O String.TrimEnd método Remove caracteres a partir do final de uma seqüência, criando um

novo objeto de seqüência. Uma matriz de caracteres é passado para este método para especificar
os caracteres a ser removido. A ordem dos elementos na matriz de caracteres não afeta a
operação aparo. O Trim pára quando for encontrado um caractere não especificado na matriz.
O exemplo a seguir remove as letras de uma seqüência usando o TrimEnd método última. Neste
exemplo, a posição do caractere 'r' e o 'W' caractere estão invertidos para ilustrar que a ordem dos
caracteres na matriz não importa. Observe que este código remove a palavra última de MyString
mais a primeira parte.
C#
string MyString = "Hello World!"; char[] MyChar = {'r','o','W','l','d','!',' '}; string NewString =
MyString.TrimEnd(MyChar); Console.WriteLine(NewString);
Esse código exibe He para o console.

O exemplo a seguir remove a última palavra de uma seqüência usando o TrimEnd método. Nesse
código, uma vírgula segue a palavra Hello e, porque a vírgula não está especificada na matriz de
caracteres para cortar, o Trim termina na vírgula.
C#
string MyString = "Hello, World!"; char[] MyChar = {'r','o','W','l','d','!',' '}; string NewString =
MyString.TrimEnd(MyChar); Console.WriteLine(NewString);
Esse código exibe Hello, para o console.
TrimStart
O String.TrimStart método é semelhante ao método String.TrimEnd exceto que ele cria uma
nova seqüência, removendo caracteres do início da seqüência um objeto existente. Uma matriz de
caracteres é passado para o TrimStart método para especificar os caracteres a ser removido.
Como com o TrimEnd método, a ordem dos elementos na matriz de caracteres não afeta a
operação aparo. O Trim pára quando for encontrado um caractere não especificado na matriz.
O exemplo a seguir remove a primeira palavra de uma seqüência. Neste exemplo, a posição do
caractere 'l' e o 'H' caractere estão invertidos para ilustrar que a ordem dos caracteres na matriz
não importa.
C#
string MyString = "Hello World!"; char[] MyChar = {'e', 'H','l','o',' ' }; string NewString =
MyString.TrimStart(MyChar); Console.WriteLine(NewString);
Esse código exibe World! para o console.
Remover
O String.Remove método, começando em uma posição especificada em uma seqüência

existente, remove um número especificado de caracteres. Este método assume um índice com
base zero.
O exemplo a seguir remove dez caracteres de um Início de seqüência na posição cinco de um

índice da seqüência baseada em zero.
C#
string MyString = "Hello Beautiful World!"; Console.WriteLine(MyString.Remove(5,10));
Esse código exibe Hello World! para o console.
Preenchendo Seqüências de Caracteres

Pode usar um dos métodos a seguir para criar uma nova versão de uma seqüência existente que
é alinhado à direita ou alinhada à esquerda a um número especificado de espaços. A nova
seqüência ou pode ser preenchida com espaços vazios (também chamados espaços em branco)
ou com caracteres personalizados.
Nome do
método Uso

String.PadLeft Alinha à direita e PADS uma seqüência para que seja uma distância
especificada a partir do início da seqüência seu caractere mais à direita.
String.PadRight Alinha à esquerda e PADS uma seqüência para que seja uma distância
especificada a partir do final de seqüência seu caractere mais à direita.
PadLeft
O String.PadLeft método cria uma nova seqüência que é alinhado à direita para que o último
caractere seja um número de espaços do primeiro índice da seqüência especificado. Espaços em
branco são inseridos se você não usar uma substituição que permite que você se especificar seu
próprio caractere de preenchimento personalizada.
O exemplo a seguir usa o PadLeft método para criar uma nova seqüência que tenha um
comprimento total de vinte espaços.
C#
string MyString = "Hello World!"; Console.WriteLine(MyString.PadLeft(20, '-'));
Este exemplo exibe --------Hello World! para o console.
PadRight
O String.PadRight método cria uma nova seqüência que é alinhado à esquerda para que a
seqüência atual será estendida especificado um número de espaços para a direita do primeiro
índice a seqüência na. Esse método preenche a nova seqüência com espaços em branco se você
não especificar um caractere personalizado.
O exemplo a seguir usa o PadRight método para criar uma nova seqüência que tenha um
comprimento total de vinte espaços.
C#
string MyString = "Hello World!"; Console.WriteLine(MyString.PadRight(20, '-'));
Este exemplo exibe Hello World!-------- para o console.
Comparando Seqüências de Caracteres

O.NET Framework fornece vários métodos para comparar os valores de seqüências. A tabela a
seguir lista e descreve os métodos Comparison valor.
Nome do método Uso

String.Compare Compara os valores das duas seqüências. Retorna um valor inteiro.
String.CompareOrdinal Compara duas seqüências sem considerar a cultura local. Retorna um
valor inteiro.
String.CompareTo Compara o objeto de seqüência atual outra seqüência. Retorna um valor
inteiro.
String.StartsWith Determina se uma seqüência começa com a seqüência passada. Retorna
um valor booleano.
String.EndsWith Determina se uma seqüência termina com a seqüência passada. Retorna

um valor booleano.
String.Equals Determina se duas seqüências são os mesmos. Retorna um valor
booleano.
String.IndexOf Retorna a posição de índice de um caractere ou seqüência, começando a
partir do início da seqüência você está examinando. Retorna um valor
inteiro.
String.LastIndexOf Retorna a posição de índice de um caractere ou seqüência, começando a
partir do final de seqüência você está examinando. Retorna um valor
inteiro.
Compare
O String.Compare método fornece uma maneira completa de comparar o objeto de seqüência

atual para outro objeto ou seqüência. Esse método é culturally ciente. Você pode usar esta função
para comparar dois seqüências ou substrings de duas seqüências. Além disso, overloads são
fornecidos que considerar ou Ignorar maiúsculas e culturais variância. A tabela a seguir mostra
valores inteiros três que podem ser retornados por esse método.
Tipo de valor Condição

Um inteiro negativo é strA menor que strB.
0 igual a strAstrB.
Um inteiro positivo Esta instância é maior que value.
Ou- Ou-
1 é value uma referência nula (Nothing no Visual Basic.)
O exemplo a seguir usa o Compare método para determinar os valores das duas seqüências
relativos.
C#
string MyString = "Hello World!"; Console.WriteLine(String.Compare(MyString, "Hello World?"));
Este exemplo exibe -1 para o console.
O exemplo anterior é confidenciais culture-por padrão. Para executar uma comparação de

seqüência culture-insensitive, use uma sobrecarga do String.Compare método que permite que
você para especificar a cultura para usar, fornecendo um culture parâmetro. Para obter um
exemplo que demonstra como usar o String.Compare método para realizar uma comparação
culture-insensitive, consulte Executar Comparisons String Insensitive Culture-.
CompareOrdinal
O String.CompareOrdinal método compara dois objetos de seqüência sem considerar a cultura

local. Os valores de retorno desse método são idênticos aos valores retornados pelo método
Compare na tabela anterior.
O exemplo a seguir usa o CompareOrdinal método para comparar os valores das duas
seqüências.
C#
string MyString = "Hello World!"; Console.WriteLine(String.CompareOrdinal(MyString, "hello world!"));

Este exemplo exibe -32 para o console.
CompareTo
O String.CompareTo método compara a seqüência que o objeto de seqüência atual encapsula a

outro seqüência ou objeto. Os valores de retorno desse método são idênticos aos valores
retornados pelo método Compare na tabela anterior.
O exemplo a seguir usa o CompareTo método para comparar o MyString objeto do OtherString
objeto.
C#
String MyString = "Hello World"; String OtherString = "Hello World!"; int MyInt =
MyString.CompareTo(OtherString); Console.WriteLine( MyInt );
Este exemplo exibe 1 para o console.
Todos os overloads do método String.CompareTo executar comparações confidenciais culture-e

maiúsculas de minúsculas por padrão. Nenhum overloads desse método são fornecidos que
permitem a você para realizar uma comparação insensitive culture-. Para maior clareza de código,
é recomendável que você utilize o String.Compare método em vez disso, especificando
CultureInfo.CurrentCulture para operações confidenciais culture-ou CultureInfo.InvariantCulture
para operações insensitive culture-. Para obter exemplos que demonstram como usar o
String.Compare método para realizar comparações confidenciais culture-e-insensitive culture,
consulte Executar Comparisons String Insensitive Culture-.
Igual a
O String.Equals método facilmente pode determinar se duas seqüências são os mesmos.

Maiúsculas de Minúsculas esse método retorna um true ou false boolean valor. Pode ser usado
de uma classe existente, conforme ilustrado no exemplo a seguir. O exemplo a seguir usa o
Equals método para determinar se um objeto de seqüência contém a frase " Hello World ".
C#
string MyString = "Hello World"; Console.WriteLine(MyString.Equals("Hello World"));
Este exemplo exibe True para o console.
Esse método também pode ser usado como um método estático. O exemplo a seguir compara
dois objetos de seqüência usando um método estático.
C#
string MyString = "Hello World"; string YourString = "Hello World";
Console.WriteLine(String.Equals(MyString, YourString));
StartsWith e EndsWith
Você pode utilizar o String.StartsWith método para determinar se um objeto de seqüência

começa com os mesmos caracteres que abranger outra seqüência. Esse método maiúsculas de
minúsculas retorna true se o objeto de seqüência atual começa com a seqüência passada e false

se não estiver. O exemplo a seguir usa esse método para determinar se um objeto de seqüência
começa com " Hello ".
C#
string MyString = "Hello World"; Console.WriteLine(MyString.StartsWith("Hello"));
O String.EndsWith método Compara uma seqüência passada para os caracteres que existem no
final da seqüência o objeto atual. Ele também retorna um valor booleano. O exemplo a seguir
verifica o fim de uma seqüência usando o EndsWith método.
C#
string MyString = "Hello World"; Console.WriteLine(MyString.EndsWith("Hello"));
Este exemplo exibe False para o console.
IndexOf e LastIndexOf
Você pode usar o String.IndexOf método para determinar a posição da primeira ocorrência de um
caractere específico dentro de uma seqüência. Este método maiúsculas de minúsculas inicia
contagem do início de uma seqüência e retorna a posição de um caractere utilizando um índice
com base zero passado. Se o caractere não puder ser encontrado, um valor de – 1 é retornado.
O exemplo a seguir usa o IndexOf método para procurar a primeira ocorrência da. ' l ' caracteres
em uma seqüência
C#
string MyString = "Hello World"; Console.WriteLine(MyString.IndexOf('l'));
O String.LastIndexOf método é semelhante ao método String.IndexOf exceto que ela retorna a

posição da última ocorrência de um caractere específico dentro de uma seqüência. Ele diferencia
maiúsculas de minúsculas e usa um índice com base zero.
O exemplo a seguir utiliza o LastIndexOf método para pesquisar para a última ocorrência da. ' l '
caracteres em uma seqüência
C#
string MyString = "Hello World"; Console.WriteLine(MyString.LastIndexOf('l'));
Ambos os métodos são úteis quando usada em conjunto com o String.Remove método. Você
pode usar um ou LastIndexOf Métodos para recuperar a posição do caractere, e forneça naquela
posição para o Remove método para remover um caractere ou uma palavra que comece com
esse caractere. o IndexOf

Alterando a Caixa
Se você escrever um aplicativo que aceita entrada de um usuário, nunca pode certificar-que caso
ele ou ela usará para inserir os dados. Como os métodos que comparam seqüências e caracteres
diferenciam maiúsculas de minúsculas, você deve converter caso de seqüências de caracteres
inseridos pelos usuários antes comparando-os em valores constantes. Você pode alterar
facilmente caso de uma seqüência. A tabela a seguir descreve dois métodos alteração caso. Cada
método fornece uma substituição que aceita uma cultura.
Nome do método Uso
String.ToUpper Converte todos os caracteres em uma seqüência em maiúsculas.
String.ToLower Converte todos os caracteres em uma seqüência em minúsculas.
ToUpper
O String.ToUpper método altera todos os caracteres em uma seqüência em maiúsculas. O

exemplo seguinte converte a seqüência " World hello! de " Misto caso em maiúsculo.
C#
String MyString = "Hello World!"; Console.WriteLine(MyString.ToUpper());
Este exemplo exibe HELLO WORLD! para o console.
O exemplo anterior é confidenciais culture-por padrão. Para executar uma alteração caso culture-
insensitive, use uma sobrecarga do String.Upper método que permite que você para especificar a
cultura para usar, fornecendo um culture parâmetro. Para obter um exemplo que demonstra como
usar o String.Upper método para executar uma alteração caso culture-insensitive, consulte
Executar alterações caso Insensitive Culture-.
ToLower
O String.ToLower método é semelhante ao método anterior, mas em vez disso converte todos os
caracteres em uma seqüência para minúsculas. O exemplo a seguir converte a seqüência " World
hello! " em minúsculas.
C#
String MyString = "Hello World!"; Console.WriteLine(MyString.ToLower());
Este exemplo exibe hello world! para o console.
O exemplo anterior é confidenciais culture-por padrão. Para executar uma alteração caso culture-
insensitive, use uma sobrecarga do String.Lower método que permite que você para especificar a
cultura para usar, fornecendo um culture parâmetro. Para obter um exemplo que demonstra como
usar o String.Lower método para executar uma alteração caso culture-insensitive, consulte
Executar alterações caso Insensitive Culture-.

Usando a Classe StringBuilder
O String objeto é imutável. Sempre que você utilizar um dos métodos da classe System.String,
você criar um novo objeto de seqüência na memória, que requer uma nova alocação de espaço
para esse novo objeto. Em situações em que você precise realizar modificações repetidas em
uma seqüência de caracteres, a sobrecarga associada à criando um novo String objeto pode ser
caro. A System.Text.StringBuilder classe pode ser usada quando você deseja modificar uma
seqüência sem criar um novo objeto. Por exemplo, usando a StringBuilder classe pode melhorar
o desempenho quando concatenação Muitas seqüências juntos em um loop.
Você pode criar uma nova instância da classe StringBuilder por inicializar a variável com um dos
métodos sobrecarregados de construtor, conforme ilustrado no exemplo a seguir.
C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
Definir a capacidade e comprimento
Embora você pode especificar um valor para o número máximo de caracteres que pode conter. é
um objeto dinâmico que permite que você para expandir o número de caracteres na seqüência
que ele encapsula, o StringBuilder Esse valor é chamada a capacidade do objeto e não deve ser
confundido com o comprimento da seqüência de caracteres que mantém o atual StringBuilder.
Por exemplo, você pode criar uma nova instância da classe StringBuilder com a seqüência " Alô
", que possui um comprimento de 5, e você pode especificar que ele tiver a capacidade máxima
de 25. Quando você modificar ele não não realocar tamanho para si até que a capacidade seja
alcançada. o StringBuilder, Quando isso ocorrer, o novo espaço é distribuído automaticamente e
a capacidade é duplicada. Você pode especificar a capacidade da StringBuilder classe usando
um dos construtores sobrecarregados. O exemplo a seguir especifica que o MyStringBuilder objeto
pode ser expandido para um máximo de 25 espaços.
C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!", 25);
Além disso, você pode usar a leitura / gravar Capacidade propriedade para definir o tamanho
máximo do objeto. O exemplo a seguir usa a Capacity propriedade para definir o comprimento
máximo de objeto.
C#
MyStringBuilder.Capacity = 25;
O EnsureCapacity método pode ser usado para verificar a capacidade do atual StringBuilder. Se
a capacidade for maior que o valor passado, nenhuma alteração é feita; no entanto, se a
capacidade for menor que o valor passado, a capacidade atual é alterada para corresponder o
valor passado.
A Comprimento propriedade pode também ser exibido ou definido. Se você definir a Length
propriedade para um valor que é maior que a Capacity propriedade, a Capacity propriedade
automaticamente é alterada para o mesmo valor que a Length propriedade. A configuração da
Length propriedade para um valor que é menor que o comprimento da seqüência de caracteres
dentro da atual StringBuilder diminui a seqüência.
Modificar a seqüência de caracteres StringBuilder

A tabela a seguir lista os métodos que podem ser usados para modificar o conteúdo de um
StringBuilder.
Nome do método Uso
StringBuilder.Append Acrescenta informações ao final do atual StringBuilder.
StringBuilder.AppendFormat Substitui um especificador de formato passado em uma seqüência

com texto formatado.
StringBuilder.Insert Insere uma seqüência ou objeto para o índice especificado do atual

StringBuilder.
StringBuilder.Remove Remove um número especificado de caracteres da atual

StringBuilder.
StringBuilder.Replace Substitui um caractere especificado em um índice especificado.
Acrescentar
O Append método pode ser usado para adicionar texto ou uma representação seqüência de um
objeto ao final de uma seqüência representada por atual StringBuilder. O exemplo a seguir
inicializa e então acrescenta algum texto para o final do objeto. Para " Hello World " um
StringBuilder Espaço em é alocado automaticamente conforme necessário.
C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!"); MyStringBuilder.Append(" What a
beautiful day."); Console.WriteLine(MyStringBuilder);
Este exemplo exibe Hello World! What a beautiful day. para o console.
AppendFormat
Do Formatação seção o AppendFormat método adiciona texto ao final do StringBuilder, mas

também implementa a IFormattable interface e portanto aceita as seqüências Formato padrão
descritas em. Você pode usar esse método para personalizar o formato de variáveis e acrescentar
esses valores para um StringBuilder. O exemplo a seguir utiliza o AppendFormat método para
colocar um valor inteiro formatado como um valor de moeda no final de um StringBuilder.
C#
int MyInt = 25; StringBuilder MyStringBuilder = new StringBuilder("Your total is ");
MyStringBuilder.AppendFormat("{0:C} ", MyInt); Console.WriteLine(MyStringBuilder);
Este exemplo exibe Your total is $25.00 para o console.
Inserir
O Insert método adiciona uma seqüência ou objeto para uma posição especificada na atual
StringBuilder. O exemplo a seguir utiliza esse método para inserir uma palavra na sexta posição
de um StringBuilder.

C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!"); MyStringBuilder.Insert(6,"Beautiful ");
Console.WriteLine(MyStringBuilder);
Este exemplo exibe Hello Beautiful World! para o console.
Remover
Use o Remove método para remover um número especificado de caracteres da atual

StringBuilder, começando em um índice com base zero especificado. O exemplo a seguir utiliza
o Remove método para diminuir um StringBuilder.
C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!"); MyStringBuilder.Remove(5,7);
Este exemplo exibe Hello para o console.
Replace
O Replace método pode ser usado para substituir caracteres dentro do StringBuilder objeto com
outro caractere especificado. O exemplo a seguir usa o Replace método para localizar um
StringBuilder objeto para todas as ocorrências do caractere ponto de exclamação (!) e substitui-
los com o caractere ponto de interrogação (?).
C#
StringBuilder MyStringBuilder = new StringBuilder("Hello World!"); MyStringBuilder.Replace('!', '?');
Este exemplo exibe Hello World? para o console.
Como Executar Manipulações sobre Seqüência de Caracteres Usando Operações Básicas
O exemplo a seguir usa alguns dos métodos discutidos nos tópicos Básico operações String para
construir uma classe que executa manipulations de seqüência de uma maneira que pode ser
encontrada em um aplicativo do mundo real. A MailToData classe armazena o nome e endereço
de uma pessoa em propriedades separadas e fornece uma maneira para combinar o City, State., e
Zip campos em uma única seqüência para exibição para o usuário Além disso, a classe permite ao
usuário para inserir a cidade, estado, e informações código postal como uma única seqüência; o
aplicativo analisa a seqüência de caracteres única e insere as informações adequadas na
propriedade correspondente automaticamente.
Para simplificar, este exemplo usa um aplicativo de console com uma interface de linha de
comando.
Exemplo
C#
using System; class MainClass { static void Main(string[] args) { MailToData MyData = new MailToData();
Console.Write("Enter Your Name:"); MyData.Name = Console.ReadLine(); Console.Write("Enter Your
Address:"); MyData.Address = Console.ReadLine(); Console.Write("Enter Your City, State, and ZIP Code
separated by spaces:"); MyData.CityStateZip = Console.ReadLine(); Console.WriteLine("Name: {0}",

MyData.Name); Console.WriteLine("Address: {0}", MyData.Address); Console.WriteLine("City: {0}",
MyData.City); Console.WriteLine("State: {0}", MyData.State); Console.WriteLine("Zip: {0}", MyData.Zip);
Console.WriteLine("The following address will be used:"); Console.WriteLine(MyData.Address);
Console.WriteLine(MyData.CityStateZip); } } public class MailToData { string name = " "; string address = "
"; string citystatezip = " "; string city = " "; string state = " "; string zip = " "; public MailToData() { } public
string Name { get{return name;} set{name = value;} } public string Address { get{return address;}
set{address = value;} } public string CityStateZip { get { return ReturnCityStateZip(); } set { citystatezip =
value; ParseCityStateZip(); } } public string City { get{return city;} set{city = value;} } public string State {
get{return state;} set{state = value;} } public string Zip { get{return zip;} set{zip = value;} } private void
ParseCityStateZip() { int CityIndex; int StateIndex; // Check for an exception if the user did not enter spaces
between // the elements. try { // Find index position of the space between // city and state and assign that
value to CityIndex. CityIndex = citystatezip.IndexOf(" "); // Initialize the CityArray to the value of the //
index position of the first white space. char[] CityArray = new char[CityIndex]; // Copy the city to the
CityArray. citystatezip.CopyTo(0,CityArray ,0, CityIndex); // Find index position of the space between //
state and zip and assign that value to CityIndex. StateIndex = citystatezip.LastIndexOf(" "); // Initialize the
StateArray to the length of the state. char[] StateArray = new char[StateIndex - CityIndex]; // Copy the state
to the StateArray. citystatezip.CopyTo(CityIndex, StateArray, 0, (StateIndex - CityIndex)); // Initialize the
ZipArray to the length of the zip. char[] ZipArray = new char[citystatezip.Length - StateIndex]; // Copy the
zip to the ZipArray. citystatezip.CopyTo(StateIndex, ZipArray, 0, (citystatezip.Length - StateIndex)); //
Assign city to the value of CityArray. city = new String(CityArray); // Trim white spaces, commas, and so on.
city = city.Trim(new char[]{' ', ',', ';', '-', ':'}); // Assign state to the value of StateArray. state = new
String(StateArray); // Trim white spaces, commas, and so on. state = state.Trim(new char[]{' ', ',', ';', '-', ':'});
// Assign zip to the value of ZipArray. zip = new String(ZipArray); // Trim white spaces, commas, and so on.
zip = zip.Trim(new char[]{' ', ',', ';', '-', ':'}); } // If an exception is encountered, alert the user to enter spaces
// between the elements. catch(OverflowException) { Console.WriteLine("\n\nYou must enter spaces
between elements.\n\n"); } } private string ReturnCityStateZip() { // Make state uppercase. state =
state.ToUpper(); // Put the value of city, state, and zip together in the proper manner. string MyCityStateZip
= String.Concat(city, ", ", state, " ", zip); return MyCityStateZip; } }
Quando o código anterior é executado, o usuário é solicitado a digitar sua própria nome e
endereço. O aplicativo coloca as informações nas propriedades adequadas e exibe as
informações novamente para o usuário, criar uma única seqüência que exibe a cidade, estado e
CEP informações.
Como Converter Tipos de Dados Usando System.Convert
A System.Convert classe fornece um conjunto completo de métodos para conversões com

suporte. Ele fornece uma maneira idioma neutro para realizar conversões e está disponível para
todos os idiomas que direcionar o Common Language Runtime. Enquanto idiomas diferentes
podem ter técnicas diferentes para converter tipos de dados, a Convert classe assegura que
todas as conversões comuns serão disponíveis em um formato genérico. Esta classe executa
conversões restrição, bem como conversões para tipos de dados não relacionadas. Por exemplo,
conversões de String tipos para tipos numéricos, DateTime Tipos a String tipos, e String Tipos
para Boolean tipos têm suporte. Do lista de métodos para obter uma lista de conversões
disponíveis, consulte na classe Convert. A Convert classe executa conversões verificados e
sempre gera uma exceção se não houver suporte para a conversão. A exceção é geralmente um
OverflowException. Para obter uma lista de conversões com suporte, consulte o Digite tabelas de
conversão.

Você pode passar o valor que você deseja para converter em um dos métodos apropriados na
classe Convert e inicializar o valor retornado para uma nova variável. Por exemplo, o código a
seguir usa a Convert classe para transformar um String valor em um Boolean valor.
Exemplo
C#
string MyString = "true"; bool MyBool = Convert.ToBoolean(MyString); // MyBool has the value of True.
A Convert classe também é útil se você tiver uma seqüência que você deseja converter em um
valor numérico. O exemplo de código a seguir converte uma seqüência de caracteres que contém
caracteres numéricos em um Int32 valor.
C#
string newString = "123456789"; int MyInt = Convert.ToInt32(newString); // MyInt has the value of
123456789.
A Convert classe também pode ser usada para uma conversão restrição que não pode ser
executada implicitamente em você estiver usando o idioma específico. O exemplo de código a
seguir mostra uma conversão de restrição em uma menor Int32 utilizando o Convert.ToInt32
Método. um Int64
C#
Int64 MyInt64 = 123456789; int MyInt = Convert.ToInt32(MyInt64); // MyInt has the value of 123456789.
Às vezes, executar uma conversão restrição com as Convert alterações de classe o valor do item
está sendo convertido. O seguinte código exemplo converte em um Int32 valor. um Double Nesse
caso, o valor é arredondado de 42.72 para 43 para concluir a conversão.
C#
Double MyDouble = 42.72; int MyInt = Convert.ToInt32(MyDouble); // MyInt has the value of 43.
Como Remover Caracteres Inválido de uma Seqüência de Caracteres
O exemplo de código a seguir usa o método estático Regex.Replace para tirar de uma seqüência
caracteres inválidos. Você pode usar o CleanInput método definido aqui para retirar
potencialmente prejudiciais caracteres que tiver sido inseridos em um campo Texto em um
formulário que aceita entrada do usuário. Retorna CleanInput uma seqüência após stripping fora
todos os caracteres exceto nonalphanumeric @, - (um traço), e. (um período).
Exemplo
C#
String CleanInput(string strIn) { // Replace invalid characters with empty strings. return
Regex.Replace(strIn, @"[^\w\.@-]", ""); }
Como Verificar se Seqüências de Caracteres Estão em um Formato de Email Válido
O exemplo de código a seguir usa o método estático Regex.IsMatch para verificar se uma
seqüência está no formato de email válido. O IsValidEmail método retorna true Se a seqüência
contém um endereço de email válido e false se ele não estiver, mas leva nenhuma outra ação.
Você pode usar IsValidEmail Para filtrar sem endereços de email que contém caracteres inválidos

antes o aplicativo armazena os endereços em um banco de dados ou exibe-os em uma página
ASP.NET.
Exemplo
C#
bool IsValidEmail(string strIn) { // Return true if strIn is in valid e-mail format. return Regex.IsMatch(strIn,
@"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"); }
Coleções e Estruturas de Dados

Dados intimamente relacionados podem ser manuseados com mais eficiência Quando agrupadas
juntas para uma coleção. Em vez de escrever código separado para manipular cada objeto
individual, você pode usar o mesmo código para processar todos os elementos de uma coleção.
Para gerenciar uma coleção, a Array classe e as System.Collections classes são usadas para
adicionar, remover e modificar a elementos individuais da coleção ou um intervalo de elementos.
Uma coleção inteira ainda pode ser copiada para outra coleção.
Algumas Collections Classes terão Recursos, classificação e a maioria são indexadas.

Gerenciamento de memória é tratado automaticamente, e a capacidade de uma coleção é
expandida conforme necessário. Sincronização fornece segurança do segmento ao acessar
membros da coleção. Algumas Collections classes podem gerar wrappers que tornam a coleção
somente leitura ou de tamanho fixo. Qualquer Collections classe pode gerar seu próprio
enumerador que torna fácil a percorrer os elementos.
No.NET Framework versão 2.0, a coleção genérica classes Fornecer nova funcionalidade e
facilitar para criar conjuntos de tipo forte. Do System.Collections.Generic Consulte e
System.Collections.ObjectModel espaços de nome.
Definir coleções
Uma coleção é um conjunto de objetos que são agrupados da mesma forma digitados.
Objetos de qualquer tipo podem ser agrupados em uma única coleção do tipo Object para tirar
proveito dos construções que são inerentes no mesmo idioma. Por exemplo, a instrução C#
foreach (for each. no Visual Basic) espera todos os objetos na coleção para ser de um único tipo
No entanto, em uma coleção de tipo Object, processamento adicional é feito nos elementos
individualmente, como boxing e unboxing ou conversões, que afetam o desempenho da coleção.
Boxing e unboxing geralmente ocorrem se armazenar ou recuperar um tipo de valor em uma
coleção de tipo Object.
Genéricas coleções, como List, e altamente digitadas coleções nongeneric, como StringCollection,
evitar esses acertos de desempenho se o tipo de elemento é o tipo que a coleção é destinada a
(por exemplo, armazenar ou recuperar seqüências de.) um StringCollection Além disso,
conjuntos de tipo forte executar automaticamente validação Tipo de cada elemento adicionado à
coleção.
Todas as coleções que direta ou indiretamente implementam a ICollection interface ou a

ICollection interface genérico compartilhar vários recursos, além de métodos que adicionar,
remover, ou procurar elementos:

• Um enumerador.
Um enumerador é um objeto que itera através de sua coleção associada. Ele pode ser
considerado de um ponteiro móvel para qualquer elemento na coleção. Um enumerador pode
ser associado a uma coleção, mas um conjunto pode ter vários enumeradores. A instrução C#
foreach (for each. no Visual Basic) usa o enumerador e oculta a complexidade da
manipulação o enumerador
• Membros de sincronização.
Sincronização fornece segurança do segmento ao acessar elementos da coleção. As coleções
são não segmento seguro por padrão. Apenas classes de alguns em espaços para nome
System.Collections fornecem um Synchronize método que cria um wrapper isenta de
segmentos através da coleção. No entanto, todas as classes em todos os System.Collections
espaços fornecem uma SyncRoot propriedade que pode ser usada para criar seus próprios
wrapper isenta de segmentos por classes derivadas. Uma IsSynchronized propriedade
também é fornecida para determinar se a coleção é segmento seguro. Sincronização não está
disponível na interface ICollection genérico.
• The CopyTo method.
Todas as coleções podem ser copiadas para uma matriz usando o CopyTo método; no
entanto, a ordem dos elementos na matriz novo está baseado a seqüência em que o
enumerador retorna-los. A matriz resultante é sempre unidimensional com um limite inferior de
zero.
Observe que a ICollection interface genérica tem membros adicionais que não inclui a interface
nongeneric.
Os seguintes recursos são implementados em algumas classes em espaços para nome

System.Collections:
• Capacidade e Contagem.
A capacidade de uma coleção é o número de elementos ele pode conter. A contagem de uma
coleção é o número de elementos ele realmente contém. A BitArray é um caso especial; sua
capacidade é o mesmo que seu comprimento, que é o mesmo que a contagem. Algumas
coleções ocultar a capacidade, a contagem ou ambos.
Automaticamente todas as coleções na System.Collections espaços expanda na capacidade
quando a capacidade atual é alcançada. A memória é realocada, e os elementos são copiados
da coleção antiga para a nova OU. Isso reduz o código necessário para usar a coleção;
entretanto, o desempenho da coleção pode ainda ser afetado negativamente. A melhor
maneira de evitar desempenho deficiente causado por vários realocações é para definir a
capacidade inicial a ser o tamanho estimado da coleção.
• Bound LOWER.
O limite inferior de uma coleção é o índice de seu primeiro elemento. Todas as coleções
indexadas na System.Collections espaços têm um limite inferior de zero. tem Array um limite
inferior de zero por padrão, mas um limite inferior diferente pode ser definido ao criar uma
instância da Array classe usando CreateInstance.
classes System.Collections geralmente podem ser categorizados em três tipos:
• Normalmente usados coleções.

Estas são as variações comuns de coletas de dados, como tabelas hash, filas, pilhas,
dicionários, e listas. Coleções comumente usadas ter versões genéricos e versões nongeneric.
• Bit coleções.

Esses são coleções cujos elementos são sinalizadores de bit. Se eles comportar de maneira
ligeiramente diferente das outras coleções.
• Especializado coleções.
Esses são coleções com finalidades, geralmente para lidar com um tipo específico de
elemento, como StringDictionary altamente específicas.
Certifique-se de escolher uma classe coleção cuidadosamente. Como cada coleção tem seu
próprio funcionalidade, cada também possui seu próprio limitações. O mais especializada uma
coleção é, quanto mais limitado ele é. Para obter dicas sobre como escolher uma coleção,
consulte Selecionar uma Classe de coleção.
Comumente usados tipos da coleção

Tipos de coleção são as variações comuns de coletas de dados, como tabelas hash, filas, pilhas,
dicionários, e listas.
Coleções são baseadas na ICollection interface, a IList Interface, interface IDictionary, ou suas
contrapartes genéricos. A IList interface e a IDictionary interface ambos são derivados a partir da
ICollection interface; portanto, todas as coleções são baseadas na ICollection interface seja
direta ou indiretamente. Nas coleções com base na interface IList (.,)) ou diretamente na interface
ICollection, cada elemento contém apenas um valor, como Array, ArrayList ou List, como Queue,
Stack ou LinkedList (, Nas coleções com base na interface IDictionary a Hashtable. e SortedList
Classes genéricos), cada elemento contém uma chave e um valor, como (e SortedList classes, ou
o Dictionary A KeyedCollection classe é exclusiva porque é uma lista de valores com chaves
incorporadas nos valores, e, portanto, ele funciona como uma lista e como um dicionário.
Coleções genéricas são a melhor solução para forte digitando. Entretanto, se o idioma não
oferece suporte generics, espaço para nome System.Collections inclui coleções, base, como
CollectionBase, ReadOnlyCollectionBase,. e DictionaryBase, quais são classes base abstratas
que podem ser estendidos para criar classes coleção que estão digitados altamente
Coleções podem variar, dependendo em como os elementos são armazenados, como eles são
classificados, como pesquisas são executadas, e como comparações são feitas. A Queue classe
e a Queue classe genérica fornecem listas primeiro First-In--Out, enquanto a Stack classe e a
Stack classe fornecem listas última in primeiro-fora. A SortedList classe e a SortedList classe
genérica fornecem classificadas versões de classe Hashtable e a Dictionary classe genérica. Os
elementos de uma Hashtable ou uma Dictionary são acessíveis somente para a chave do
elemento, mas os elementos de uma SortedList ou uma KeyedCollection são acessíveis, seja
através da tecla ou pelo índice do elemento. Os índices em todas as coleções são base zero,
exceto Array, que permite matrizes que são base não zero.
Coleções de bits
Coleções bits são coleções cujos elementos são sinalizadores de bit. Ter porque cada elemento é
um pouco em vez de um objeto, essas coleções comportamento um pouco diferente das outras
coleções.
A BitArray classe é uma classe coleção na qual a capacidade é sempre o mesmo que a
contagem. Elementos são adicionados ao aumentando a Length propriedade; elementos são
excluídos diminuindo a Length propriedade. um BitArray A BitArray classe oferece métodos que
não são encontrados em outras coleções, incluindo aqueles que permitem vários elementos a ser
modificado usando um filtro, como And, Or uma vez, Xor., Not e SetAll

A BitVector32 classe é uma estrutura que oferece a mesma funcionalidade como BitArray, mas
com desempenho mais rápido. é BitVector32 mais rápido porque é um tipo de valor e portanto
alocados na pilha, enquanto BitArray é um tipo de referência e, portanto, alocado na pilha.
Pode BitVector32 Armazenar exatamente 32 bits, enquanto BitArray pode armazenar um

número de bits variável. Armazena BitVector32 os sinalizadores de bit e pequenos números
inteiros, tornando assim ideal para dados que não seja expostos para o usuário. No entanto, se o
número de sinalizadores de bit necessário é desconhecido, é variável, ou é maior que 32, use
BitArray.
é BitArray no espaço para nome System.Collections; BitVector32 é no espaço para nome

System.Collections.Specialized.
Coleções especializados
Coleções especializadas são coleções com finalidades altamente específicas. é
NameValueCollection baseado no NameObjectCollectionBase; No entanto,
NameValueCollection aceita vários valores por chave, enquanto NameObjectCollectionBase
aceita apenas um valor por chave.
Algumas coleções altamente digitadas no espaço para nome System.Collections.Specialized são

StringCollection e StringDictionary, ambos os quais contêm valores que são seqüências
exclusivamente.
A CollectionsUtil classe cria instâncias de coleções não diferencia maiúsculas de minúsculas.
Algumas coleções transformar. Por exemplo, a HybridDictionary classe inicia como se tornar
grande. e se torna um Hashtable quando um ListDictionary O KeyedCollection é uma lista mas ela
também cria um dicionário de pesquisa quando o número de elementos atinge um limite
especificado.
Criando e Manipulating coleções

As coleções mais comuns são fornecidas pelo .NET Framework. Você pode usar qualquer uma
das-los ou criar sua próprias coleção com base em um deles. Cada coleção foi projetada para
finalidades específicas. Os membros incluídos no cada System.Collections Classe refletem o
objetivo da coleção. Além disso, as coleções genéricas no System.Collections.Generic tornam
mais fácil para criar conjuntos de tipo forte.
Se você optar por implementar seu próprio coleção, use as seguintes diretrizes:
• Inicie com a classe base direita e interfaces. Consulte Selecionar uma Classe de coleção
Para obter dicas sobre como escolher um tipo de coleção.
• Considere a possibilidade de fazer sua coleção altamente digitada. Conjuntos de tipo forte
fornece validação tipo automática e evitar processos que afetam negativamente o
desempenho, como boxing e unboxing e conversões. Se o idioma suporta generics, use um
dos tipos System.Collections.Generic. Se o idioma não oferece suporte generics,
System.Collections.Specialized contém exemplos de coleções de tipo forte.
• Considere fornecer sincronização em sua classe. Consulte Coleções e sincronização
(segurança do segmento) Para obter detalhes.
• Considerar a ativação de serialização para sua classe. Consulte Conceitos de serialização
Para obter detalhes.

Selecionando uma Classe de Coleção
Certifique-se Escolha sua System.Collections Classe cuidadosamente. Usando o tipo errado pode
restringir o uso da coleção.
Considere as seguintes questões:
• Você precisa uma lista seqüencial onde o elemento normalmente será descartado após
seu valor é recuperado?
o Caso afirmativo, considere o uso da Queue classe ou a Queue classe genérica se
você precisar comportamento (FIFO) primeiro First-In--fora. Considere o uso da Stack classe
ou a Stack classe genérica se você precisar comportamento (LIFO) última in primeiro-Out.
o Caso contrário, considere usar as outras coleções.
• Você precisa acessar os elementos em uma determinada ordem, tais como FIFO, LIFO, ou
aleatórios?
o A Queue classe e a Queue classe genérica oferece acesso fifo.
o A Stack classe e a Stack classe genérica oferece acesso LIFO.
o A LinkedList classe genérico permite acesso seqüencial originados do topo para o
final ou o final para a cabeça de.
o O restante das coleções oferecem acesso aleatório.
• Você precisa acessar cada elemento pelo índice?
o O ArrayList e StringCollection Classes e a List classe genérica oferecem acesso a
seus elementos pelo índice baseado em zero do elemento.
o O Hashtable, SortedList e SortedDictionary Classes genéricos oferecem acesso a
seus elementos pela chave do elemento., ListDictionary e StringDictionary classes, e o
Dictionary
o O NameObjectCollectionBase e SortedList Classes genéricos oferecem acesso a
seus elementos por um o índice baseado em zero ou a chave do elemento. e
NameValueCollection classes, e o KeyedCollection
• Cada elemento irá conter um valor, uma combinação de uma chave e um valor, ou uma
combinação de uma chave e vários valores?
o Um valor: usar qualquer um das coleções com base na IList interface ou a IList
interface genérica.
o Uma chave e um valor: usar qualquer um das coleções com base na IDictionary
interface ou a IDictionary interface genérica.
o Um valor com chave incorporado: usar a KeyedCollection classe genérica.
o Uma chave e vários valores: usar a NameValueCollection classe.
• Você precisa classificar os elementos de forma diferente de como eles foram inseridos?
o A Hashtable classe classifica seus elementos por seus códigos hash.
o A SortedList classe com base em implementações de interface IComparer e a
IComparer interface genérica. e SortedDictionary e SortedList Classes genéricos classificar
seus elementos através da tecla,
o Fornece ArrayList um Sort método que leva uma IComparer Implementação como
um parâmetro. Sua contraparte genérico, a List classe genérica, fornece um Sort método que
leva uma implementação da interface IComparer como um parâmetro genérico.
• Você precisa pesquisas rápidas e recuperação de informações?

o é ListDictionary mais rápido do que Hashtable para coleções pequenos (10 itens
ou menos). A SortedDictionary classe genérico oferece pesquisa mais rápida que a
Dictionary classe genérica.
• Você precisa coleções que aceitam somente seqüências?
o (StringCollection). com base em IList e StringDictionary (com base em
IDictionary) estão no espaço para nome System.Collections.Specialized
o Além disso, você pode usar qualquer uma das classes a coleção genérica no
espaço para nome System.Collections.Generic como coleções de seqüência de tipo forte,
especificando a String classe para seus argumentos tipo genérico.
Enumerar uma coleção

O.NET Framework fornece enumeradores como uma maneira fácil para iterar através de um
conjunto. Enumeradores somente ler dados na coleção; eles não podem ser usados para
modificar a coleção subjacente.
Alguns idiomas fornecem uma instrução que oculta a complexidade da usando enumeradores
diretamente. A instrução C# foreach, a instrução C++ for each, e a instrução For Each Visual
Basic usam enumeradores.
Sobre Enumerators
Um enumerador flattens uma coleção para que os membros podem ser acessados
seqüencialmente. Coleção diferentes classes podem ter diferentes seqüências. Por exemplo, um
enumerador para um ArrayList preserva um enumerador para um Hashtable exibe os elementos
acordo para o código hash do elemento a ordem na qual os elementos são inseridos da coleção,
enquanto.
Cada enumerador é baseado na IEnumerator interface ou a IEnumerator interface genérica, que

requer os seguintes membros:
• A Current propriedade aponta para o membro atual na coleção.

• A MoveNext propriedade move o enumerador para o próximo membro na coleção.
• A Reset propriedade move o enumerador volta para o início da coleção. é Current
posicionado antes do primeiro elemento. Não está Reset disponível na interface genérico
IEnumerator.
Comportamento de um enumerador
Inicialmente, o Enumerador está posicionado antes do primeiro elemento na coleção. Também

Reset traz o enumerador para essa posição. Nesta posição, Current é indefinido. Portanto, você
deve chamar MoveNext para avançar o enumerador para o primeiro elemento da coleção antes
de ler o valor da Current.
Retorna Current o mesmo objeto até MoveNext ou Reset é chamado. Define MoveNextCurrent
Como o elemento seguinte.
Se MoveNext passagens final da coleção, o Enumerador está posicionado após o último

elemento na coleção e MoveNext retorna false. Quando o enumerador está nesta posição, para
MoveNext também retornar false chamadas subseqüentes. Se a última chamada para MoveNext
retornado false, Current é indefinido.
Em coleções Generic não-, você pode chamar Reset seguido por MoveNext para mover o
enumerador volta para o início da coleção.

Em genéricas coleções, você não pode definir Current para o primeiro elemento da coleção
novamente; você deve criar uma nova instância de enumerador em vez disso.
Um enumerador permanece válida, desde que a coleção permanece inalterada. Se as alterações

forem feitas para a coleção,, como adicionar, modificar ou excluir elementos, o enumerador é
irrecoverably invalidated e seu comportamento é indefinido.
O enumerador não não ter acesso exclusivo à coleção; portanto, enumerando através de um
conjunto é um procedimento seguro do segmento intrinsically não. Para garantir segurança do
segmento durante enumeração, você pode bloquear a coleção durante toda a enumeração. Para
permitir que a coleção para ser acessado por vários segmentos para leitura e gravação, você
deverá implementar sua próprias sincronização.
Coleções e sincronização (segurança do segmento)

Por padrão, classes no System.Collections e espaços para nome relacionados são não segmento
seguro. Vários leitores podem ler a coleção com confiança; no entanto, qualquer modificação para
a coleção produz resultados para todos os segmentos que acessar a coleção, incluindo os
segmentos de leitor indefinidos.
classes System.Collections podem ser feitas segmento seguro usando qualquer um dos
seguintes métodos:
• Criar um invólucro isenta de segmentos usando o Synchronized método, e acessar a

coleção exclusivamente a esse wrapper.
• Se a classe não não tiver um Synchronized método, derivar de classe e implementar um
Synchronized método usando a SyncRoot propriedade.
• Usam um mecanismo de bloqueio, como a lock instrução no C# (SyncLock. no Visual
Basic, a Monitor classe em C++), sobre a SyncRoot propriedade ao acessar a coleção
Ao implementar o Synchronized método, classes derivadas devem substituir a IsReadOnly

propriedade para retornar o valor correto.
A Array classe não inclui um Synchronized método e, embora ele possui uma SyncRoot
propriedade, a classe não pode ser derivada de. Portanto, uma matriz pode ser feita segmento
seguro somente através do mecanismo de bloqueio.
Classes a coleção genérica não incluir membros de sincronização; no entanto, alguns genérica
classes, como Collection, Dictionary,. explicitamente implementar membros de sincronização
herdados da interface nongeneric ICollection e List,
Comparações e classifica em coleções

As System.Collections Classes realizar comparações em quase todos os processos envolvidos no
gerenciamento coleções, se procurar o elemento para remover ou retornando o valor de um par e
chave-valor-.
Dois construções são usadas para comparações. O Equals método, herdadas ou derivados
Object, simplesmente Retorna um Boolean para indicar se dois objetos são iguais. O
IComparable.CompareTo método e o IComparer.Compare método retornar um número inteiro
que indica como os dois valores comparam em relação uns aos outros. é Equals usado para
verificações de igualdade; e System.IComparable.CompareTo( métodos, são usados para
classificar. e System.Collections.IComparer.Compare(System.Object,System.Object) métodos e

suas contrapartes nas interfaces genéricos, o System.IComparable.CompareTo(System.Object) a
System.Collections.Generic.IComparer.Compare(
As comparações podem ser entre elementos da coleção, ou entre um elemento e um valor

especificado. Quando não explicitamente comparers são especificados, pelo menos um dos
objetos sendo comparadas é esperado para implementar a IComparable interface e ser capaz de
comparar próprio com o outro objeto.
Algumas classes possuem métodos que aceitam uma IComparer Implementação como um
parâmetro. Quando esses métodos são usados e o IComparer parâmetro é não uma referência
nula (Nothing. no Visual Basic), os objetos estão sendo comparados não são necessários para
implementar IComparable próprios No entanto, ele é sempre uma boa prática para implementar
IComparable Em todas as classes que podem ser usados como valores em uma coleção de lista
ou chaves em uma coleção do dicionário.
Alguns overloads de construtor para coleções do dicionário aceitar uma IComparer

implementação, que é usada para comparar chaves sempre que comparações são necessárias.
tem Array overloads de seu Sort método que aceitam uma IComparer implementação, que é
usada somente para essa chamada específica para o Sort método.
A configuração de cultura atual do sistema pode afetar o comparações e classifica dentro de uma
coleção. Por padrão, comparações e classifica nas Collections classes são confidenciais culture-.
Para ignorar a configuração de cultura e portanto obter comparação consistente e classificar
resultados, use o InvariantCulture. com overloads membro que aceitam uma CultureInfo Para
obter mais informações, consulte Executar operações String Insensitive Culture-em coleções e
Executar operações String Insensitive Culture-em matrizes.
Quando Usar Coleções Genéricas

Geralmente usar coleções genéricas é recomendável, pois você ganha a vantagem imediata de
segurança de tipo sem precisar fazer derivar de um tipo de coleção base e implementar membros
específicos do tipo. Além disso, tipos a coleção genérica geralmente executar melhor que os tipos
coleção nongeneric correspondentes (e melhor que tipos derivados de tipos nongeneric coleção
Base).. quando os elementos da coleção são tipos valor, porque com generics não existe há
necessidade de caixa os elementos
Os seguintes tipos genéricos correspondem aos tipos de coleção existente:
• é List a classe genérica correspondente a ArrayList.

• é Dictionary a classe genérica correspondente a Hashtable.
• é Collection a classe genérica correspondente a CollectionBase. Pode Collection Ser
usada como uma classe base, mas diferentemente CollectionBase ele é não abstrato,
tornando ainda mais fácil para usar.
• é ReadOnlyCollection a classe genérica correspondente a ReadOnlyCollectionBase. é
ReadOnlyCollection Não abstrata, e tem um construtor que facilita para expor um existente
List como uma coleção somente leitura.
• O StackQueue,. e SortedList Classes genéricos correspondem para as classes nongeneric
respectivos com os mesmos nomes
Tipos adicionais
Existem vários tipos a coleção genérica que não têm contrapartes nongeneric:

• é LinkedList uma lista vinculada de propósito geral que fornece operações de inserção e
remoção O(1).
• é SortedDictionary um dicionário classificado com O (log n) operações de inserção e
recuperação, tornando-uma alternativa útil para SortedList.
• é KeyedCollection um híbrido entre uma lista e um dicionário, que fornece uma maneira
para armazenar objetos que contêm suas próprias chaves.
Funcionalidade adicional
Alguns dos tipos genéricos têm funcionalidade não encontrada na coleção nongeneric os tipos.
Por exemplo, a List classe, que corresponde da classe nongeneric ArrayList, tem um número de
métodos que aceitam representantes genéricas, como o Predicate representante que permite que
você se especificar métodos de pesquisa a lista, o Action representante que representa métodos
que atuam sobre cada elemento da lista, e o Converter representante que permite que você definir
conversões entre tipos.
A List classe permite-lhe especificar suas próprias IComparer implementações interface genérica
para classificação e pesquisa a lista. O SortedDictionary e SortedList classes também possui
esse recurso, e em disso permitem os comparers deve ser especificado quando a coleção é
criada. Do Dictionary de maneira semelhante, e KeyedCollection classes permitem que você
para especificar suas próprias comparers de igualdade.
Classe genérica List

Representa uma lista de objetos que podem ser acessados pelo índice altamente digitada.
Oferece métodos para pesquisar, classificar e manipular listas.
Namespace: System.Collections.Generic
Assembly: mscorlib (em mscorlib.dll)
Sintaxe
C#
[SerializableAttribute] public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection,
IEnumerable
Parâmetros de tipo
T
O tipo de elementos em Da lista.
Comentários
A List classe é o equivalente da classe ArrayList genérico. Ele implementa a IList interface
genérica usando uma matriz cujo tamanho é aumentado dinamicamente conforme necessário.
A List classe usa uma comparer de igualdade e um comparer pedido.
• Métodos, como Contains, IndexOf e Remove Usar um comparer de igualdade para os

elementos Lista., LastIndexOf O comparer de igualdade padrão para tipo T é determinada da
seguinte maneira. Se tipo T implementa a IEquatable interface genérica, então o comparer de
igualdade é o Equals método de interface; caso contrário, o comparer de igualdade padrão é
Object.Equals(Object).

• Métodos, como BinarySearch e Sort use um comparer pedido para os elementos lista. O
comparer padrão para tipo T é determinada da seguinte maneira. Se tipo T implementa a
IComparable interface genérica, então o comparer padrão é o CompareTo método de interface;
caso contrário, se tipo T implementa a interface nongeneric IComparable, então o comparer
padrão é o CompareTo método de interface. Se tipo T implementa nenhuma interface, então
não há nenhum comparer padrão, e um representante comparer ou comparação deve ser
fornecido explicitamente.
O List não é garantida a serem classificados. Você deve classificar a serem classificados. antes
de executar operações (como BinarySearch) que exigem o List o List
Elementos nessa coleção podem ser acessados usando um índice inteiro. Índices nessa coleção
são baseada em zero.
Aceita Lista null reference (Nothing in Visual Basic) como um valor válido para tipos de referência
e permite elementos duplicados.
Considerações sobre desempenho
A decidir se deseja usar ou ArrayList Classe, ambos os quais têm semelhante funcionalidade,
lembrar que a List classe efetua melhor na maioria dos casos e é tipo seguro.. o List Se um tipo
de referência for usado para tipo T de classe List, o comportamento das duas classes é idêntico.
No entanto, se um tipo de valor for usado para tipo T, você precisará considerar implementação e
questões boxing.
Se um tipo de valor for utilizado para tipo T, o compilador gera uma implementação da classe List
especificamente para esse tipo de valor. Isso significa um elemento um lista de um List objeto não
tenha que ser Boxed antes do elemento pode ser usado, e Após cerca de 500 elementos de lista
são criados a memória economizada elementos lista boxing não é maior que a memória usada
para gerar a implementação de classe.
Certifique-se o tipo de valor usado para tipo T implementa a IEquatable interface genérico. Caso
contrário, métodos, como Contains deve chamar o Object.Equals(Object) método, que caixas o
elemento lista afetado. Do BinarySearch se o tipo de valor implementa a IComparable interface e
você possuir o código de fonte também implementam a IComparable interface genérica para
evitar e Sort métodos de boxing elementos de lista. Se você não possui código-fonte, passar um
IComparer objeto para o BinarySearch e Sort métodos
Ele é para sua vantagem em usar a implementação específicos do tipo de classe List em vez de
através da ArrayList classe ou escrever um conjunto wrapper altamente digitado mesmo. A razão
é sua implementação deve fazer que o .NET Framework faz por você já, e o Common Language
Runtime pode compartilhar código linguagem intermediária Microsoft e metadados, que não pode
sua implementação.
Exemplo
O exemplo de código a seguir demonstra várias propriedades e métodos da classe List genérico.
O construtor padrão é usado para criar uma lista de seqüências com uma capacidade de 0. A
Capacity propriedade é exibida e depois o Add método é usado para adicionar vários itens. Os
itens são listados, e a Capacity propriedade será exibida novamente, juntamente com a Count
propriedade, para mostrar que a capacidade foi aumentou conforme necessário.
O Contains método é usado para testar a presença de um item na lista, o Insert método é usado
para inserir um novo item no meio da lista, e o conteúdo da lista são exibidos novamente.

A propriedade padrão Item (o indexador em C#) é usada para recuperar um item, o Remove
método é usado para remover a primeira instância de adicionada anteriormente, o item duplicado
e o conteúdo será exibido novamente. O Remove método Sempre remove a primeira instância
encontrar.
O TrimExcess método é usado para reduzir a capacidade para corresponder a contagem, e

Capacity. e Count propriedades são exibidas Se a capacidade não utilizada tinha sido menos de
10 % da capacidade total, a lista não seria foram redimensionada.
Finalmente, o Clear método é usado para remover todos os itens da lista, e Capacity. e Count
propriedades são exibidas
C#
using System; using System.Collections.Generic; public class Example { public static void Main() {
List<string> dinosaurs = new List<string>(); Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
dinosaurs.Add("Tyrannosaurus"); dinosaurs.Add("Amargasaurus"); dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus"); dinosaurs.Add("Compsognathus"); Console.WriteLine(); foreach(string
dinosaur in dinosaurs) { Console.WriteLine(dinosaur); } Console.WriteLine("\nCapacity: {0}",
dinosaurs.Capacity); Console.WriteLine("Count: {0}", dinosaurs.Count);
Console.WriteLine("\nContains(\"Deinonychus\"): {0}", dinosaurs.Contains("Deinonychus"));
Console.WriteLine("\nInsert(2, \"Compsognathus\")"); dinosaurs.Insert(2, "Compsognathus");
Console.WriteLine(); foreach(string dinosaur in dinosaurs) { Console.WriteLine(dinosaur); }
Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);
Console.WriteLine("\nRemove(\"Compsognathus\")"); dinosaurs.Remove("Compsognathus");
Console.WriteLine(); foreach(string dinosaur in dinosaurs) { Console.WriteLine(dinosaur); }
dinosaurs.TrimExcess(); Console.WriteLine("\nTrimExcess()"); Console.WriteLine("Capacity: {0}",
dinosaurs.Capacity); Console.WriteLine("Count: {0}", dinosaurs.Count); dinosaurs.Clear();
Console.WriteLine("\nClear()"); Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
Console.WriteLine("Count: {0}", dinosaurs.Count); } } /* This code example produces the following output:
Capacity: 0 Tyrannosaurus Amargasaurus Mamenchisaurus Deinonychus Compsognathus Capacity: 8
Count: 5 Contains("Deinonychus"): True Insert(2, "Compsognathus") Tyrannosaurus Amargasaurus
Compsognathus Mamenchisaurus Deinonychus Compsognathus dinosaurs[3]: Mamenchisaurus
Remove("Compsognathus") Tyrannosaurus Amargasaurus Mamenchisaurus Deinonychus Compsognathus
TrimExcess() Capacity: 5 Count: 5 Clear() Capacity: 5 Count: 0 */
Hierarquia de herança
System.Object
System.Collections.Generic.List
Segurança de segmentos
Estático público (Shared. no Visual Basic) os membros do tipo são segmento seguro Os membros
da instância não são garantidos para ser segmento seguro.
Suporte vários leitores simultaneamente,, desde que a coleção não é modificada A List.
Enumerando através de um conjunto é intrinsically não um procedimento isenta de segmentos. No
caso raro onde uma enumeração contends com um ou mais acessos de gravação, a única
maneira para garantir segurança do segmento é para bloquear a coleção durante toda a
enumeração. Para permitir que a coleção para ser acessado por vários segmentos para leitura e
gravação, você deverá implementar sua próprias sincronização.

Plataformas
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for
Pocket PC, Windows Mobile for Smartphone, Windows Server 2003,
Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2,
Windows XP Starter Edition
O .NET Framework não dá suporte a todas as versões de cada plataforma. Para obter uma lista
das versões com suporte, consulte Requisitos do sistema.
Informações de versão
.NET Framework
Compatível com: 2.0
.NET Compact Framework
Classe genérica SortedDictionary

Representa uma coleção de pares chave / valor que são classificadas na chave.
Namespace: System.Collections.Generic
Assembly: System (em system.dll)
Sintaxe
C#
[SerializableAttribute] public class SortedDictionary<TKey,TValue> : IDictionary<TKey,TValue>,
ICollection<KeyValuePair<TKey,TValue>>, IEnumerable<KeyValuePair<TKey,TValue>>, IDictionary,
ICollection, IEnumerable
Parâmetros de tipo
TKey
O tipo das teclas no dicionário.
TValue
O tipo dos valores no dicionário.
Comentários
A SortedDictionary classe genérico é uma árvore da pesquisa binário com recuperação O (log
n), onde n é o número de elementos no dicionário. Neste aspecto, ele é semelhante para a
SortedList classe genérico. As duas classes têm modelos de objeto semelhantes, e ambas têm O
(log n) recuperação. Onde as duas classes diferem está em uso de memória e velocidade de
inserção e remoção:
• Usa SortedList menos memória que SortedDictionary.

• oferece SortedDictionary mais rápidas operações de inserção e remoção para dados não
classificados:. (n O log n) (em oposição ao para SortedList)

• Se a lista estiver preenchida todos de uma vez dos dados SortedList classificados é mais
rápida que SortedDictionary.
Cada par chave / valor pode ser recuperado como uma KeyValuePair estrutura, ou através da
interface nongeneric IDictionary. um DictionaryEntry
As chaves devem ser imutáveis, desde que eles são usados como chaves no SortedDictionary..
o SortedDictionary Cada chave em um SortedDictionary deve ser exclusivo. Uma chave não
pode ser a null reference (Nothing in Visual Basic), mas um valor pode ser, se o tipo TValue de
valor é um tipo de referência.
Requer SortedDictionary uma implementação comparer para realizar comparações de chave.

Você pode especificar uma implementação da interface IComparer genérica, utilizando um
construtor que aceita um comparer parâmetro; se você não especificar uma implementação, o
comparer Comparer.Default genérico padrão é usada. Se tipo TKey implementa a
System.IComparable interface genérico, o comparer padrão usa essa implementação.
A foreach instrução da linguagem C# (for each. em C++, For Each no Visual Basic) requer o tipo
de cada elemento na coleção Desde cada elemento do tipo elemento é não o tipo da chave ou o
tipo do valor. é um par chave / valor, o SortedDictionary Em vez disso, o tipo de elemento é
KeyValuePair. O código a seguir mostra sintaxe C#, C++ e Visual Basic.
C#
foreach (KeyValuePair<int, string> kvp in myDictionary) {...}
A foreach instrução é um invólucro em torno o enumerador, que permite somente leitura a partir
da coleção, não gravar para ele.
Exemplo
O exemplo de código a seguir cria um vazio SortedDictionary de seqüências com chaves de

seqüência e usa o Add método para adicionar alguns elementos. O exemplo demonstra que o
Add método gera um ArgumentException quando tentativa de adicionar uma chave duplicada.
O exemplo usa a Item propriedade (o indexador em C#) para recuperar valores, demonstrando
que é acionada quando uma chave solicitado é não existir, e mostra que o valor associado a uma
chave pode ser substituída. um KeyNotFoundException
O exemplo mostra como usar o TryGetValue método como uma forma mais eficiente para
recuperar valores se um programa com freqüência deve tentar valores chave que não estão no
dicionário, e ele mostra como usar o ContainsKey método para testar se uma chave existe antes
de chamar o Add método.
O exemplo mostra como para enumerar as chaves e valores em um dicionário e como enumerar
as chaves e valores sozinho usando a Keys propriedade e a Values propriedade.
Finalmente, o exemplo demonstra o Remove método.
C#
using System; using System.Collections.Generic; public class Example { public static void Main() { // Create
a new dictionary of strings, with string keys. // Dictionary<string, string> openWith = new
Dictionary<string, string>(); // Add some elements to the dictionary. There are no // duplicate keys, but
some of the values are duplicates. openWith.Add("txt", "notepad.exe"); openWith.Add("bmp", "paint.exe");
openWith.Add("dib", "paint.exe"); openWith.Add("rtf", "wordpad.exe"); // The Add method throws an

exception if the new key is // already in the dictionary. try { openWith.Add("txt", "winword.exe"); } catch
(ArgumentException) { Console.WriteLine("An element with Key = \"txt\" already exists."); } // The Item
property is another name for the indexer, so you // can omit its name when accessing elements.
Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]); // The indexer can be used to change
the value associated // with a key. openWith["rtf"] = "winword.exe"; Console.WriteLine("For key = \"rtf\",
value = {0}.", openWith["rtf"]); // If a key does not exist, setting the indexer for that key // adds a new
key/value pair. openWith["doc"] = "winword.exe"; // The indexer throws an exception if the requested key is
// not in the dictionary. try { Console.WriteLine("For key = \"tif\", value = {0}.", openWith["tif"]); } catch
(KeyNotFoundException) { Console.WriteLine("Key = \"tif\" is not found."); } // When a program often has
to try keys that turn out not to // be in the dictionary, TryGetValue can be a more efficient // way to retrieve
values. string value = ""; if (openWith.TryGetValue("tif", out value)) { Console.WriteLine("For key = \"tif\",
value = {0}.", value); } else { Console.WriteLine("Key = \"tif\" is not found."); } // ContainsKey can be used
to test keys before inserting // them. if (!openWith.ContainsKey("ht")) { openWith.Add("ht",
"hypertrm.exe"); Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]); } // When you use
foreach to enumerate dictionary elements, // the elements are retrieved as KeyValuePair objects.
Console.WriteLine(); foreach( KeyValuePair<string, string> kvp in openWith ) { Console.WriteLine("Key =
{0}, Value = {1}", kvp.Key, kvp.Value); } // To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl = openWith.Values; // The elements of the
ValueCollection are strongly typed // with the type that was specified for dictionary values.
Console.WriteLine(); foreach( string s in valueColl ) { Console.WriteLine("Value = {0}", s); } // To get the
keys alone, use the Keys property. Dictionary<string, string>.KeyCollection keyColl = openWith.Keys; // The
elements of the KeyCollection are strongly typed // with the type that was specified for dictionary keys.
Console.WriteLine(); foreach( string s in keyColl ) { Console.WriteLine("Key = {0}", s); } // Use the Remove
method to remove a key/value pair. Console.WriteLine("\nRemove(\"doc\")"); openWith.Remove("doc"); if
(!openWith.ContainsKey("doc")) { Console.WriteLine("Key \"doc\" is not found."); } } } /* This code example
produces the following output: An element with Key = "txt" already exists. For key = "rtf", value =
wordpad.exe. For key = "rtf", value = winword.exe. Key = "tif" is not found. Key = "tif" is not found. Value
added for key = "ht": hypertrm.exe Key = txt, Value = notepad.exe Key = bmp, Value = paint.exe Key = dib,
Value = paint.exe Key = rtf, Value = winword.exe Key = doc, Value = winword.exe Key = ht, Value =
hypertrm.exe Value = notepad.exe Value = paint.exe Value = paint.exe Value = winword.exe Value =
winword.exe Value = hypertrm.exe Key = txt Key = bmp Key = dib Key = rtf Key = doc Key = ht
Remove("doc") Key "doc" is not found. */
Hierarquia de herança
System.Object
System.Collections.Generic.SortedDictionary
Segurança de segmentos
Estático público (Shared. no Visual Basic) os membros do tipo são segmento seguro Os membros
da instância não são garantidos para ser segmento seguro.
Suporte vários leitores simultaneamente,, desde que a coleção não é modificada A

SortedDictionary. Mesmo assim, enumerando através de um conjunto é intrinsically não um
procedimento isenta de segmentos. Para garantir segurança do segmento durante enumeração,
você pode bloquear a coleção durante toda a enumeração. Para permitir que a coleção para ser
acessado por vários segmentos para leitura e gravação, você deverá implementar sua próprias
sincronização.

Plataformas
Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003,
Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2,
Windows XP Starter Edition
O .NET Framework não dá suporte a todas as versões de cada plataforma. Para obter uma lista
das versões com suporte, consulte Requisitos do sistema.
Informações de versão
.NET Framework
Como Usar Exceções Específicas em um Bloco Catch
Quando ocorre uma exceção, ele é passado a pilha e cada bloco catch é fornecido a oportunidade
para lidar com ele. A ordem das instruções Catch é importante. Colocar blocos catch direcionados
a exceções específicas antes um bloco catch de Exceção geral ou o compilador pode emitir um
erro. O bloco catch adequada é determinado pela correspondência o tipo de exceção para o nome
da exceção especificada no bloco catch. Se não houver nenhum específico catch bloco, a
Exceção é capturada por um bloco catch gerais, se existir.
O exemplo de código a seguir usa um bloco try / catch para capturar um InvalidCastException. O
exemplo cria uma classe chamada Employee com uma única propriedade nível funcionário,
(Emlevel). Um método , PromoteEmployee, assume um objeto e incrementa o nível do funcionário.
Um InvalidCastException ocorre quando uma DATETIME instância é passada para o
PromoteEmployee método.
Exemplo
C#
using System; public class Employee { //Create employee level property. public int Emlevel { get {
return(emlevel); } set { emlevel = value; } } int emlevel; } public class Ex13 { public static void
PromoteEmployee(Object emp) { //Cast object to Employee. Employee e = (Employee) emp; // Increment
employee level. e.Emlevel = e.Emlevel + 1; } public static void Main() { try { Object o = new Employee();
DateTime newyears = new DateTime(2001, 1, 1); //Promote the new employee. PromoteEmployee(o);
//Promote DateTime; results in InvalidCastException as newyears is not an employee instance.
PromoteEmployee(newyears); } catch (InvalidCastException e) { Console.WriteLine("Error passing data to
PromoteEmployee method. " + e); } } }
O Common Language Runtime captura exceções que não são detectadas por um bloco catch.
Dependendo de como o Runtime é configurado, será exibida uma caixa de diálogo de depuração
ou executar o programa pára e uma caixa de diálogo com informações de exceção é exibida. Para
obter informações sobre depuração, consulte Depuração e perfil Applications.
Como: Usar o bloco Try/Catch para capturar exceções
Coloque as seções de código que podem descartar exceções em um bloco try e colocar código
que manipula exceções em um bloco catch. O bloco catch é uma série de instruções começando
com a palavra-chave catch, seguida por um tipo de exceção e uma ação a ser executada.
Observação
Praticamente qualquer linha de código pode causar uma exceção, especialmente exceções que
são geradas pelo Common Language Runtime, como OutOfMemoryException propriamente dito,
e StackOverflowException. A maioria dos aplicativos não necessário para lidar com essas
exceções, mas você deve estar ciente dessa possibilidade ao escrever bibliotecas a ser usado por
outros. Para obter sugestões sobre quando para definir código em um bloco try, consulte Práticas
recomendadas para tratamento de exceções.
O exemplo de código a seguir usa um bloco try / catch para capturar uma exceção possível. O
Main método contém um bloco try com uma StreamReader instrução que abre um arquivo de
dados chamado data.txt e grava uma seqüência a partir do arquivo. Após o bloco Try é um bloco
catch que captura qualquer exceção que resulta da bloco try.
Exemplo
C#
using System; using System.IO; using System.Security.Permissions; // Security permission request.
[assembly:FileIOPermissionAttribute(SecurityAction.RequestMinimum, All = @"d:\\data.txt")] public class
ProcessFile { public static void Main() { try { StreamReader sr = File.OpenText("data.txt");
Console.WriteLine("The first line of this file is {0}", sr.ReadLine()); } catch(Exception e) {
Console.WriteLine("An error occurred: '{0}'", e); } } }
Este exemplo ilustra uma instrução catch básico que irá detectar qualquer exceção. Em geral, é
recomendável programação prática para capturar um tipo específico de Exceção em vez de usar a
instrução básica catch. Para obter mais informações sobre catching exceções específicas,
consulte Usando exceções específicas em um bloco catch.
Como Criar Exceções Definida pelo Usuário
Se você quiser que os usuários para poder se programaticamente distinguir entre algumas
condições de erro, você pode criar seus próprios exceções definida pelo usuário. O.NET
Framework fornece uma hierarquia de classes de exceção basicamente derivadas de uma classe
Exceção base. Cada um dessas classes define uma exceção específica, para que em muitos
casos você só precise capturar a exceção. Você também pode criar suas próprias classes de
exceção por derivar da classe Exception.
Ao criar seu próprio exceções, é recomendável codificação prática para finalizar o nome de classe
de exceção definida pelo usuário com a palavra " exceção ". Também é boa prática para
implementar as três recomendada construtores comuns, como mostrado no exemplo o seguir.
Observação
No situações onde você estiver usando o Remoting,, você precisa garantir que os metadados para
qualquer exceção definida pelo usuário está disponível no servidor (chamado) e para o cliente (o
objeto proxy ou chamador). Por exemplo, Código chamar um método em um domínio de
aplicativos separados deve ser capaz para localizar o conjunto que contém uma Exceção
acionada por uma chamada remota. Para obter mais informações, consulte Práticas
recomendadas para tratamento de exceções.

No exemplo a seguir, uma Nova Exceção é derivada da Exception classe,
EmployeeListNotFoundException. Construtores três são definidos na classe, cada levando
parâmetros diferentes.
Exemplo
C#
using System; public class EmployeeListNotFoundException: Exception { public
EmployeeListNotFoundException() { } public EmployeeListNotFoundException(string message) :
base(message) { } public EmployeeListNotFoundException(string message, Exception inner) : base(message,
inner) { } }
Como Usar Blocos Finally
Quando ocorre uma exceção, execução pára e controle é dada ao manipulador de exceção mais
próximo. Isso geralmente significa que linhas de código você pretende sempre ser chamado não
serão executadas. Alguns limpeza de recursos, tais como fechar um arquivo, sempre deve ser
executada mesmo que uma exceção é gerada. Para fazer isso, você pode usar bloco finally. Um A
finalmente bloco será sempre executado, independentemente de se uma exceção é gerada.
O exemplo de código a seguir usa um bloco try / catch para capturar um

ArgumentOutOfRangeException. O Main método cria duas matrizes e tenta se copiar uma para a
outra. A ação gera um ArgumentOutOfRangeException e o erro é gravado no console. O
finalmente bloco executa independentemente sobre o resultado da ação da cópia.
Exemplo
C#
using System; class ArgumentOutOfRangeExample { static public void Main() { int[] array1={0,0}; int[]
array2={0,0}; try { Array.Copy(array1,array2,-1); } catch (ArgumentOutOfRangeException e) {
Console.WriteLine("Error: {0}",e); } finally { Console.WriteLine("This statement is always executed."); } } }
Como Lançar Exceções Explicitamente
Explicitamente você pode acionar uma exceção usando a instrução throw. Você também pode
descartar uma exceção caught novamente usando a instrução throw. É recomendável codificação
prática para adicionar informações a uma exceção que é rethrown para fornecer mais informações
ao depurar.
O exemplo de código a seguir usa um bloco try / catch para detectar um possível
FileNotFoundException. Do FileNotFoundException seguinte bloco Try é um bloco catch que
captura e grava uma mensagem para o console se o arquivo de dados não for encontrado. A
próxima instrução é a Instrução throw que gera um novo FileNotFoundException e adiciona
informações de texto para a exceção.
Exemplo
C#
using System; using System.IO; public class ProcessFile { public static void Main() { FileStream fs = null; try
//Opens a text tile. { fs = new FileStream("data.txt", FileMode.Open); StreamReader sr = new
StreamReader(fs); string line; //A value is read from the file and output to the console. line = sr.ReadLine();
Console.WriteLine(line); } catch(FileNotFoundException e) { Console.WriteLine("[Data File Missing] {0}",
e); throw new FileNotFoundException("[data.txt not in c:\\dev directory]",e); } finally { fs.Close(); } } }

Como Consumir Eventos em um Aplicativo do Windows Forms
Um cenário comum em aplicativos Windows Forms é para exibir um formulário com controles, e
depois executar uma ação específica com base no que controlam o usuário clicar. Por exemplo,
um Button controle gerará um evento quando o usuário clica-lo no formulário. Ao manipular o
evento, o aplicativo pode executar a lógica aplicativo apropriado para que clique de botão.
Para obter mais informações sobre Windows Forms, consulte Guia de introdução ao Windows
Forms.
Para lidar com um botão clique evento em um formulário do Windows

1. Criar um formulário que tem um Button controle do Windows.
C#
private Button button; Private WithEvents myButton As Button
2. Define um manipulador de eventos que corresponda a Click Assinatura de representante

de evento. O Click evento usa a EventHandler classe para o tipo delegate e a EventArgs
classe para os dados do evento.
C#
void Button_Clicked(object sender, EventArgs e) {...} Sub Button_Clicked(sender As Object, e As
EventArgs) ... End Sub
3. Adicione o método do manipulador de eventos para o Click evento do Button.

C#
button.Click += new EventHandler(this.Button_Clicked); AddHandler myButton.Click, AddressOf
Me.Button_Clicked
Observação
Um Designer (tais como Visual Studio 2005) será fazer esta Cabeamento de evento para você,
gerando código que é semelhante ao código, neste exemplo.
Exemplo
O exemplo de código a seguir manipula o Click evento de para alterar a cor de TextBox Plano de
Fundo. um Button Mostrar os elementos em negrito o manipulador de eventos e como ele é
cabeado para o Click evento do Button.
O código, neste exemplo foi escrito sem usar um criador visual (tais como Visual Studio 2005) e
contém somente essenciais elementos de programação. Se você usar um designer, ele irá gerar
código adicional.
C#
using System; using System.ComponentModel; using System.Windows.Forms; using System.Drawing; public
class MyForm : Form { private TextBox box; private Button button; public MyForm() : base() { box = new
TextBox(); box.BackColor = System.Drawing.Color.Cyan; box.Size = new Size(100,100); box.Location = new
Point(50,50); box.Text = "Hello"; button = new Button(); button.Location = new Point(50,100); button.Text
= "Click Me"; // To wire the event, create // a delegate instance and add it to the Click event. button.Click +=
new EventHandler(this.Button_Clicked); Controls.Add(box); Controls.Add(button); } // The event handler.
private void Button_Clicked(object sender, EventArgs e) { box.BackColor = System.Drawing.Color.Green; }

// The STAThreadAttribute indicates that Windows Forms uses the // single-threaded apartment model.
[STAThreadAttribute] public static void Main(string[] args) { Application.Run(new MyForm()); } } Option
Explicit Option Strict Imports System Imports System.ComponentModel Imports System.Windows.Forms
Imports System.Drawing Public Class MyForm Inherits Form Private box As TextBox Private WithEvents
myButton As Button Public Sub New() box = New TextBox() box.BackColor = System.Drawing.Color.Cyan
box.Size = New Size(100, 100) box.Location = New Point(50, 50) box.Text = "Hello" myButton = New
Button() myButton.Location = New Point(50, 100) myButton.Text = "Click Me"
AddHandler myButton.Click, AddressOf Me.Button_Clicked
Controls.Add(box) Controls.Add(myButton) End Sub ' The event handler. Private Sub
Button_Clicked(sender As Object, e As EventArgs) box.BackColor = System.Drawing.Color.Green End Sub '
The STAThreadAttribute indicates that Windows Forms uses the ' single-threaded apartment model.
<STAThreadAttribute()> _ Public Shared Sub Main(args() As String) Application.Run(New MyForm()) End
Sub End Class
Salvar o código anterior em um arquivo com (uma extensão. cs) para um arquivo C# e.vb para
Visual Basic 2005, compilar, e executar. Por exemplo, se o arquivo de origem for denominado
WinEvents.cs (ou WinEvents.vb), execute o seguinte comando:
C#
csc /r:System.DLL /r:System.Windows.Forms.DLL /r:System.Drawing.DLL WinEvents.cs vbc
/r:System.DLL /r:System.Windows.Forms.DLL /r:System.Drawing.DLL WinEvents.vb
Seu arquivo executável será denominado WinEvents.exe.
Como Conectar Métodos de Manipulação de Eventos a Eventos
Para consumir eventos definidos na outra classe, você deve definir e registrar um manipulador de
eventos. O manipulador de eventos deve ter a mesma assinatura método como o representante
declarado para o evento. Registrar o manipulador de eventos, adicionando o manipulador ao
evento. Após ter adicionado o manipulador de eventos para o evento, o método é chamado
sempre que a classe gera o evento.
Para um exemplo completo que ilustra eventos raising e Handling, consulte Como aumentar e
Consume eventos:.
Para adicionar um método do manipulador de eventos para um evento

1. Definir um método do manipulador de eventos com a mesma assinatura como o
representante de evento.
C#
public class WakeMeUp { // AlarmRang has the same signature as AlarmEventHandler. public void
AlarmRang(object sender, AlarmEventArgs e) {...}; ... }
2. Criar uma instância do representante, usando uma referência para o método do

manipulador de eventos. Quando a instância de representante é chamada, ele por sua vez
chama o método do manipulador de eventos.
C#

// Create an instance of WakeMeUp. WakeMeUp w = new WakeMeUp(); // Instantiate the event
delegate. AlarmEventHandler alhandler = new AlarmEventHandler(w.AlarmRang);
3. Adicione a instância de representante para o evento. Quando o evento é gerado, a

instância de representante e seu método do manipulador de evento associado é chamado.
C#
// Instantiate the event source. AlarmClock clock = new AlarmClock(); // Add the delegate instance to
the event. clock.Alarm += alhandler;
O seguinte programa exemplo demonstra elevar um evento em uma classe e manipular o evento
no outra classe. A AlarmClock classe define o evento Alarm público, e fornece métodos para
aumentar o evento. A AlarmEventArgs classe é derivada da EventArgs e define os dados
específicos a um Alarm evento. A WakeMeUp classe define o método AlarmRang, que trata um
Alarm evento. A AlarmDriver classe usa as classes juntos, como o AlarmRang Método de
WakeMeUp manipular o Alarm evento do AlarmClock.
Este programa exemplo usa conceitos descritos com detalhes no Eventos e representantes e
Elevar um evento.
Exemplo
C#
// EventSample.cs. // namespace EventSample { using System; using System.ComponentModel; // Class
that contains the data for // the alarm event. Derives from System.EventArgs. // public class
AlarmEventArgs : EventArgs { private readonly bool snoozePressed ; private readonly int nrings;
//Constructor. // public AlarmEventArgs(bool snoozePressed, int nrings) { this.snoozePressed =
snoozePressed; this.nrings = nrings; } // The NumRings property returns the number of rings // that the
alarm clock has sounded when the alarm event // is generated. // public int NumRings { get { return nrings;}
} // The SnoozePressed property indicates whether the snooze // button is pressed on the alarm when the
alarm event is generated. // public bool SnoozePressed { get {return snoozePressed;} } // The AlarmText
property that contains the wake-up message. // public string AlarmText { get { if (snoozePressed) { return
("Wake Up!!! Snooze time is over."); } else { return ("Wake Up!"); } } } } // Delegate declaration. // public
delegate void AlarmEventHandler(object sender, AlarmEventArgs e); // The Alarm class that raises the
alarm event. // public class AlarmClock { private bool snoozePressed = false; private int nrings = 0; private
bool stop = false; // The Stop property indicates whether the // alarm should be turned off. // public bool
Stop { get {return stop;} set {stop = value;} } // The SnoozePressed property indicates whether the snooze //
button is pressed on the alarm when the alarm event is generated. // public bool SnoozePressed { get {return
snoozePressed;} set {snoozePressed = value;} } // The event member that is of type AlarmEventHandler. //
public event AlarmEventHandler Alarm; // The protected OnAlarm method raises the event by invoking //
the delegates. The sender is always this, the current instance // of the class. // protected virtual void
OnAlarm(AlarmEventArgs e) { AlarmEventHandler handler = Alarm; if (handler != null) { // Invokes the
delegates. handler(this, e); } } // This alarm clock does not have // a user interface. // To simulate the alarm
mechanism it has a loop // that raises the alarm event at every iteration // with a time delay of 300
milliseconds, // if snooze is not pressed. If snooze is pressed, // the time delay is 1000 milliseconds. // public
void Start() { for (;;) { nrings++; if (stop) { break; } else if (snoozePressed) {
System.Threading.Thread.Sleep(1000); { AlarmEventArgs e = new AlarmEventArgs(snoozePressed, nrings);
OnAlarm(e); } } else { System.Threading.Thread.Sleep(300); AlarmEventArgs e = new
AlarmEventArgs(snoozePressed, nrings); OnAlarm(e); } } } } // The WakeMeUp class has a method
AlarmRang that handles the // alarm event. // public class WakeMeUp { public void AlarmRang(object

sender, AlarmEventArgs e) { Console.WriteLine(e.AlarmText +"\n"); if (!(e.SnoozePressed)) { if
(e.NumRings % 10 == 0) { Console.WriteLine(" Let alarm ring? Enter Y"); Console.WriteLine(" Press
Snooze? Enter N"); Console.WriteLine(" Stop Alarm? Enter Q"); String input = Console.ReadLine(); if
(input.Equals("Y") ||input.Equals("y")) return; else if (input.Equals("N") || input.Equals("n")) {
((AlarmClock)sender).SnoozePressed = true; return; } else { ((AlarmClock)sender).Stop = true; return; } } }
else { Console.WriteLine(" Let alarm ring? Enter Y"); Console.WriteLine(" Stop Alarm? Enter Q"); String
input = Console.ReadLine(); if (input.Equals("Y") || input.Equals("y")) return; else {
((AlarmClock)sender).Stop = true; return; } } } } // The driver class that hooks up the event handling method
of // WakeMeUp to the alarm event of an Alarm object using a delegate. // In a forms-based application, the
driver class is the // form. // public class AlarmDriver { public static void Main (string[] args) { //
Instantiates the event receiver. WakeMeUp w= new WakeMeUp(); // Instantiates the event source.
AlarmClock clock = new AlarmClock(); // Wires the AlarmRang method to the Alarm event. clock.Alarm +=
new AlarmEventHandler(w.AlarmRang); clock.Start(); } } }
Como Manipular Vários Eventos Usando Propriedades de Evento
Para usar propriedades de evento em Visual Basic 2005 (eventos personalizados), você definir as
propriedades de evento na classe que aumenta os eventos, e defina os delegados para as
propriedades de evento em classes que manipular os eventos. Para implementar várias
propriedades de evento em uma classe, deve a classe internamente armazenar e manter o
representante definido para cada evento. Uma abordagem comum é para implementar uma
coleção de representante que é indexada por uma chave de evento.
Para armazenar os delegados para cada evento, você pode usar a EventHandlerList classe, ou
implementar sua própria coleção A classe coleção deve fornecer métodos para definir, acessando,
e recuperar o representante do manipulador de eventos de acordo com a chave de evento. Por
exemplo, você pode usar uma Tabela de hash classe, ou derivar uma classe personalizada de
classe DictionaryBase. Os detalhes da implementação da coleção de representante não precisará
ser expostos fora sua classe.
Cada propriedade de evento dentro da classe define um método de assessor Add e um método
de assessor remover. O acessador de adição para uma propriedade de evento adiciona a
instância de representante entrada à coleção de representante. O acessador remover para uma
propriedade de evento remove a instância de representante entrada da coleção de representante.
As assessores propriedade de evento usar a chave predefinida para a propriedade de evento para
adicionar e remover instâncias de uma coleção de representante.
Para manipular vários eventos usando propriedades de evento

1. Definir uma coleção de representante dentro da classe que gera os eventos.
2. Defina uma chave para cada evento.
3. Definir as propriedades de evento na classe que gera os eventos.
4. Use a coleção de representante para implementar a adicionar e remover Métodos
acessadores para as propriedades de evento.
5. Use as propriedades de evento pública para adicionar e remover representantes do
manipulador de eventos nas classes que manipular os eventos.
Exemplo
O exemplo C# implementa as propriedades MouseDown de evento e MouseUp, Usando. para

armazenar representante cada do evento um EventHandlerList As palavras-chave das
construções Propriedade das evento são em negrito.

Observação
Não há suporte para propriedades de evento no Visual Basic 2005.
C#
// The class SampleControl defines two event properties, MouseUp and MouseDown. class SampleControl:
Component { // : // Define other control methods and properties. // : // Define the delegate collection.
protected EventHandlerList listEventDelegates = new EventHandlerList(); // Define a unique key for each
event. static readonly object mouseDownEventKey = new object(); static readonly object mouseUpEventKey
= new object(); // Define the MouseDown event property. public event MouseEventHandler MouseDown { //
Add the input delegate to the collection. add { listEventDelegates.AddHandler(mouseDownEventKey, value);
} // Remove the input delegate from the collection. remove {
listEventDelegates.RemoveHandler(mouseDownEventKey, value); } } // Define the MouseUp event
property. public event MouseEventHandler MouseUp { // Add the input delegate to the collection. add {
listEventDelegates.AddHandler(mouseUpEventKey, value); } // Remove the input delegate from the
collection. remove { listEventDelegates.RemoveHandler(mouseUpEventKey, value); } } }
Como Implementar Eventos em sua Classe
Os procedimentos a seguir descrevem como implementar um evento em uma classe. O primeiro

procedimento implementa um evento que não não associou dados; ele usa as classes
System.EventArgs e System.EventHandler para dados e delegue o manipulador de eventos. O
segundo procedimento implementa um evento com dados personalizada; ela define classes para
os dados do evento e o manipulador de representante eventos personalizados.
Para um exemplo completo que ilustra eventos raising e Handling, consulte Como aumentar e
Consume eventos:.
Para implementar um evento sem dados eventos específicos

1. Definir um membro de evento pública na sua classe. Definir o tipo do membro de evento
para um System.EventHandler representante.
C#
public class Countdown { ... public event EventHandler CountdownCompleted; }
2. Fornece um método protegido na sua classe que gera o evento. Nome do método
OnEventName. Aumentar o evento dentro do método.
C#
public class Countdown { ... public event EventHandler CountdownCompleted; protected virtual void
OnCountdownCompleted(EventArgs e) { if (CountdownCompleted != null)
CountdownCompleted(this, e); } }
3. Determinar quando para elevar o evento na sua classe. Chamar OnEventName para
elevar o evento.
C#
public class Countdown { ... public void Decrement { internalCounter = internalCounter - 1; if
(internalCounter == 0) OnCountdownCompleted(new EventArgs()); } }
Para implementar um evento com dados eventos específicos

1. Definir uma classe que fornece dados para o evento. Nome da classe EventNameArgs,
derivar a classe de System.EventArgs, e adicionar os membros específicos eventos-.
C#
public class AlarmEventArgs : EventArgs { private readonly int nrings = 0; private readonly bool
snoozePressed = false; //Properties. public string AlarmText { ... } public int NumRings { ... } public
bool SnoozePressed{ ... } }
2. Declare um representante para o evento. Nome o representante

EventNameEventHandler.
C#
public delegate void AlarmEventHandler(object sender, AlarmEventArgs e);
3. Definir um membro de evento pública denominado EventName na sua classe. Definir o tipo
do membro de evento para o tipo delegate de evento.
C#
public class AlarmClock { ... public event AlarmEventHandler Alarm; }
4. Definir um método protegido na sua classe que gera o evento. Nome do método
OnEventName. Aumentar o evento dentro do método.
C#
public class AlarmClock { ... public event AlarmHandler Alarm; protected virtual void
OnAlarm(AlarmEventArgs e) { if (Alarm != null) Alarm(this, e); } }
5. Determinar quando para elevar o evento na sua classe. Chamar OnEventName para gerar
o evento e passar dados específicos eventos-usando EventNameEventArgs o.
C#
Public Class AlarmClock { ... public void Start() { ... System.Threading.Thread.Sleep(300);
AlarmEventArgs e = new AlarmEventArgs(false, 0); OnAlarm(e); } }

Depuração (Como fazer em C#)
Esta página possui um link para a Ajuda sobre tarefas de depuração amplamente usadas. Para
ver outras categorias de tarefas populares abordadas na Ajuda, consulte Como fazer em C#.
Compilando no Visual Studio

O Visual Studio 2005 fornece ferramentas para testar e depurar aplicativos continuamente à
medida que eles são compilados. Quando um projeto do Visual Studio é criado, são definidas
configurações-padrão de projeto e são atribuídas configurações-padrão de compilação à solução
para fornecer-lhe contexto para quando ele for compilado. As equipes de desenvolvimento podem
editar essas configurações-padrão de solução e projeto conforme necessário, e criar novas
configurações, salvando cópias modificadas de configurações-padrão.
Compilação Durante o Desenvolvimento de Aplicativos

Uma solução e seus projetos individuais são normalmente criados e testados usando uma
compilação de depuração (Debug). Os desenvolvedores compilarão uma em modo de depuração
várias vezes no decorrer de cada etapa do seu processo de desenvolvimento. A depuração é um
processo de duas etapas. Primeiramente, erros de tempo de compilação são corrigidos. Esses
erros podem incluir sintaxe incorreta, palavras-chave incorretas e inconsistências entre tipos de
dados. Em seguida, o depurador é usado para detectar e corrigir problemas tais como erros
lógicos e erros semânticos que são detectados em tempo de execução.
Quando um projeto ou solução estiver totalmente desenvolvido e suficientemente depurado, seus

componentes são compilados em uma versão de lançamento (Release). Via de regra, uma
compilação de lançamento emprega várias otimizações. Compilações otimizadas são compiladas
para serem menores e de execução mais rápida que compilações não-otimizadas.
Selecionando e Editando Configurações de Compilação
Use a Caixa de Diálogo Configuration Manager para definir configurações de projeto, que são
conjuntos de propriedades para cada combinação suportada de versão e plataforma (por
exemplo, Release Win32). Você pode criar suas próprias compilações especiais, como uma
configuração de compilação de perguntas e respostas para os testadores, ou uma configuração
de compilação pessoal para experimentar alguns códigos preliminares. Você pode usar o Project
Designer para modificar as configurações de cada combinação de compilação e plataforma. Para
mais informações, consulte Introdução ao Compilador do Projeto.
Use a caixa de diálogo Solution Property Pages para definir as propriedades da solução. As
propriedades mais comuns incluem configurações para o projeto de inicialização e dependências
de projeto. As propriedades de configuração incluem menus suspensos listando tipos de
configurações do projeto e plataformas disponíveis, e caixas de seleção para selecionar os
projetos a serem criados e a serem implantados (se ativado). A combinação de configuração de
projeto e plataforma escolhida determina a configuração de compilação do projeto a ser usada.
Para mais informações, consulte Caixa de Diálogo Solution Property Pages.
Use a lista suspensa Solution Configurations na barra de ferramentas Standard para selecionar
a configuração compilação solução ativa, e para abrir a caixa de diálogo Configuration Manager.
Você também pode acessar o Configuration Manager selecionando Configuration Manager a
partir do menu Build.

Configurações de Compilação
Configurações de compilação fornecem uma maneira de armazenar várias versões de solução e
propriedades do projeto. A configuração ativa pode ser rapidamente acessada e alterada,
permitindo que você facilmente crie várias configurações do mesmo projeto.
Por padrão, e projetos criados com Visual Studio incluiem configurações Debug e Release.
Configurações Debug são automaticamente configuradas para depurar um aplicativo, e
configurações Release são configuradas para a versão final do aplicativo. Para mais informações,
consulte COMO: defina configurações Debug e Versão. Você também pode criar e editar suas
próprias configurações personalizadas de solução e projeto para atender às necessidades do seu
aplicativo. Para mais informações, consulte Como criar e editar configurações:.
Dois níveis de configurações de compilação podem ser definidos no Visual Studio: configurações
de solução e configurações do projeto.
Configurações de Solução
Um Configuração de solução especifica como os projetos em uma solução serão compilados e (se
ativado) implantado. Para definir uma nova configuração de solução, abra a Caixa de Diálogo
Configuration Manager . e selecione New da lista Active solution configuration
Cada entrada em uma configuração de solução inclui um nome de projeto, uma configuração, uma
configuração de plataforma, uma configuração de compilação, e (se ativado) uma configuração
Deploy. A combinação da configuração de solução e da configuração de plataforma escolhidas
determina a configuração do projeto que será usada. Para obter mais informações sobre solução
de plataformas, consulte Criar plataformas.
Você pode criar quaisquer números de configurações de solução, cada um com um nome
exclusivo. O Ambiente integrado de desenvolvimento do Visual Studio (IDE) automaticamente
atribui configurações de solução sempre que você:
• Adicionar uma plataforma de projeto com Create new solution platforms selecionada.
• Adicionar uma configuração de projeto com Create new solution configurations
selecionada.
• Adicionar um novo projeto que irá ser implantado em várias plataformas, um dos quais é
novo.
Configurações de solução também fornecem informações de contexto do projeto em geral para o

IDE. Por exemplo, se a configuração de solução ativa especifica que um projeto será compilado
para um dispositivo móvel, a Caixa de ferramentas exibirá somente itens de projeto que podem
ser usados em um projeto de dispositivo móvel enquanto você estiver trabalhando neste projeto.
Configurações do projeto
A configuração e plataforma do projeto são usadas juntas para especificar as propriedades a

serem usadas ao compilar o projeto. Um projeto pode ter um conjunto de propriedades de projeto
definidas para cada combinação exclusiva de uma configuração e plataforma. Propriedades do
projeto são editadas com o Project Designer. Determinados painéis no Project Designer contêm
listas suspensas que indicam a configuração e combinação de plataforma do projeto atual.
Você pode definir as propriedades dependentes da configuração em cada configuração de projeto

conforme necessário. Propriedades de projeto podem ser usadas para determinar, por exemplo,

quais itens de projeto serão incluídos em uma compilação particular, quais arquivos de saída
serão criados, onde os arquivos de saída serão colocados, e como eles serão otimizados.
Configurações de projeto podem diferir bastante. Por exemplo, as propriedades de configuração

de um projeto podem especificar que seu arquivo de saída seja otimizado para que o binário
resultante ocupe o espaço mínimo, enquanto outro projeto pode ser otimizado de forma que o seu
executável execute com a velocidade máxima.
Configurações do projeto não são armazenadas pelo usuário, mas pela solução, para que elas
possam ser compartilhadas por uma equipe. Embora as dependências de projeto são
independentes da configuração, somente os projetos especificados na configuração de solução
ativa serão compilados.
Alterar Configurações de Solution
Quando você cria uma solução, o Visual Studio usa a configuração de solução ativa, que
especifica as configurações do projeto para usar para cada projeto a ser compilado. Você pode
alterar a configuração ativa diretamente na lista suspensaSolution Configurations na barra de
ferramentas padrão, ou a partir da caixa de diálogo Configuration Manager .
Observação
Se você não puder encontrar as configurações de solução na barra de ferramentas padrão ou não
puder acessar o Configuration Manager, você pode ter as configurações de desenvolvedor do
Visual Basic aplicadas. Para mais informações, consulte COMO: Gerenciar configurações de
compilação desenvolvedor de configurações aplicado.
Como o IDE atribui configurações do projeto para serem compiladas
Quando você cria uma nova solução de configuração (ao invés de copiar a que já exista), o IDE
determina as configurações padrão do projeto para os projetos que ele irá compilar usando os
seguintes critérios de seleção para cada projeto (avaliados nesta ordem):
1. A nova solução de configuração criará uma configuração de projeto cujo nome

corresponde exatamente ao seu. Os nomes de configuração não diferenciam maiúsculas de
minúsculas.
2. Se não houver nenhuma correspondência de nome exato, a nova configuração de solução
irá compilar uma configuração de projeto cujo nome corresponde à parte de configuração do
seu nome, mesmo que a parte da plataforma também não corresponda. (Lembre-se que a
convenção de nomeação é <configuration name> <platform-name>.)
3. Se ainda não houver correspondência, a nova configuração de solução irá compilar a
primeira configuração listada para o projeto.
Como o IDE atribui configurações de solução
Quando você cria uma configuração de projeto e marca Create new solution configurations o
IDE procura uma configuração de solução nomeada apropriadamente para compilar o projeto em
cada plataforma que ele suporta. Em alguns casos, o IDE irá renomear as configurações de
solução existentes ou criar novas.
A IDE determina como atribuir as configurações de solução usando os critérios de seleção a

seguir:

• Se uma configuração de projeto não especifica uma plataforma ou especifica uma única
plataforma, então uma configuração de solução cujo nome corresponde àquele da nova
configuração de projeto será encontrada ou adicionada. Nesse caso, o nome da solução de
configuração padrão não inclui um nome de plataforma; ele assume a forma <project
configuration name>.
• Se um projeto suportar várias plataformas, uma solução de configuração será encontrada
ou adicionada para cada configuração de projeto para compilar cada projeto em cada
plataforma que ele suporta. O nome de cada configuração de solução inclui o nome de
configuração do projeto e o nome da plataforma; ele assume a forma <project configuration
name> <platform name>.
Compilar plataformas
Plataformas de compilação fornecem uma maneira de armazenar várias versões de solução e
propriedades de projeto aplicáveis especificamente para direcionar plataformas. Por exemplo,
você pode criar uma configuração do Debug que direciona para uma plataforma x 86, e uma
configuração do Debug que direciona para uma plataforma x64. A plataforma ativa pode ser
rapidamente acessada e alterada, permitindo que você facilmente crie um projeto selecionando
várias plataformas.
COMO: configurar projetos para plataformas de destino
Visual Studio 2005 permite que você configure seus aplicativos para direcionar para diferentes
plataformas, incluindo plataformas de 64 bits. Para obter mais informações sobre suporte em
plataforma de 64 bits no Visual Studio 2005, consulte Aplicativos de 64 bits.
Selecionando plataformas com o Gerenciador de configurações
O Configuration Manager fornece uma maneira para você adicionar rapidamente uma nova
plataforma de destino em seu projeto. Se você selecionar uma das plataformas incluídas no Visual
Studio, as propriedades de seu projeto são modificadas para compilá-lo para a plataforma
selecionada.
Para configurar um projeto e direcioná-lo a uma plataforma de 64 bits

1. No menu Build, clique em Configuration Manager.
2. Na lista de solução de plataforma Active, selecione a plataforma de 64 bits para o
direcionamento da solução. Se a plataforma não existir na lista, selecione New.
3. Na caixa de diálogo New Solution Platform, selecione a plataforma de 64 bits para o
direcionamento da solução.
Observação
Se você criar um novo nome para sua configuração, você pode ter que modificar as configurações
em Project Designer para direcionar a plataforma correta.
4. Se você deseja copiar as configurações de uma configuração de plataforma atual,

selecione a configuração da plataforma para copiar configurações, e clique em OK.
As propriedades para todos os projetos direcionados para uma plataforma de 64 bits são
atualizadas, e a próxima compilação do projeto será otimizada em plataformas de 64 bits.
Direcionando plataformas no criador de projeto

O Project Designer também fornece uma maneira de direcionar para diferentes plataformas em
seu projeto. Se selecionar uma das plataformas incluídas na lista da caixa de diálogo New
Solution Platform não funcionar para sua solução, você pode criar um nome de configuração
personalizado e modificar as configurações no Project Designer para direcionar a plataforma
correta.
Observação
Projetos Visual J# não podem ser configurados para direcionar para diferentes plataformas.
Executar esta tarefa varia de acordo com a linguagem de programação que você estiver usando.
Consulte os seguintes links para obter mais informações:
• Para Visual Basic projetos, consulte COMO: Otimizar um aplicativo para um Tipo
específico de CPU.
• Para projetos Visual C#, consulte PAGE compilação, Designer projeto c (#).
• Para projetos Visual C++, consulte COMO: configurar projetos Visual C++ para direcionar
para plataformas de 64 bits.
COMO: Configurar projetos para direcionar para várias plataformas
Visual Studio 2005 permite que uma solução direcione para várias arquiteturas de CPU diferentes,
ou plataformas, de uma vez. As propriedades para definir isto são acessados através da Caixa de
Diálogo do Configuration Manager.
Selecionando uma plataforma
A Caixa de diálogo Configuration Manager permite que você crie e defina configurações e
plataformas no nível de solução e de projeto. Cada combinação de configurações no nível de
solução e destinos pode ter um conjunto exclusivo de propriedades associadas a ela, permitindo
que você facilmente alterne entre, por exemplo, uma configuração Release que direciona uma
plataforma x64, uma configuração Release que direciona uma plataforma x 86, e uma
configuração Debug que direciona uma plataforma x 86.
Para definir a configuração para direcionar diferentes plataformas

2. Em Active solution platform box, selecione a plataforma que você deseja direcionar a
solução, ou selecione <New> para criar uma nova plataforma. Para obter informações sobre
como usar a caixa de diálogo New Solution Platform, consulte a New Solution Platform
Dialog Box.. Visual Studio. irá compilar seu aplicativo para direcionar a plataforma que é
definida como a plataforma ativa na caixa de diálogo Configuration Manager
Remover uma plataforma
Se você percebe que não tem necessidade de uma plataforma, pode removê-la usando a caixa de
diálogo Gerenciador de configurações. Este procedimento removerá todas as configurações de
solução e projeto que você configurou para essa combinação de configuração e de destino.
Para remover uma plataforma

2. Em a Active solution platform box, selecione <Edit>. A Edit Solution Platforms Caixa
de diálogo é aberta.
3. Clique na plataforma você deseja remover, e clique em Remove.
Selecionando várias plataformas com uma solução
Porque você pode alterar as configurações com base na combinação de configuração e

configurações de plataforma, você pode configurar uma solução que pode selecionar mais de uma
plataforma.
Para direcionar várias plataformas

1. Use o Configuration Manager para adicionar pelo menos duas plataformas destino para a
solução.
2. Selecione a plataforma que você deseja direcionar a partir da lista Active solution
platform.
3. Compilar uma solução.
Para criar várias configurações de solução de uma única vez
1. Use o Configuration Manager para adicionar pelo menos duas plataformas destino para a
solução.
2. Use a janela Batch Build para criar várias configurações de solução de uma vez. Para
mais informações, consulte a caixa de diálogo compilação em lotes.
É possível ter uma plataforma no nível de solução como, por exemplo, x64, e não ter projetos
nesta solução direcionando para a mesma plataforma. Também é possível ter vários projetos na
sua solução, cada um direcionado para diferentes plataformas. É recomendável que se você tiver
uma dessas situações, você crie uma nova configuração com um nome descritivo para evitar
confusão.
COMO: Preparar e gerenciar Compilações
Visual Studio 2005 oferece uma variedade de formas para ajudá-lo a organizar quais arquivos
estão incluídos em uma compilação de uma solução ou projeto, qual conjunto de propriedades do
projeto está em vigor enquanto compila, e em que ordem os projetos serão compilados. Esta
seção contém tópicos que explicam vários procedimentos para preparar e gerenciar compilações.
A seguir estão os procedimentos comuns do Visual Studio para preparar e gerenciar compilações.
Observação
As opções disponíveis nas caixas de diálogo, e os nomes e locais do menu de comandos que
você vê, podem diferir do que é descrito na Ajuda dependendo das configurações ou edição
ativas. Esta página Ajuda foi escrita com base no General Development settings. Para exibir ou
alterar as configurações, escolha Import and Export Settings no menu Tools. Para mais
informações, consulte Configurações do Visual Studio.
Para compilar, recompilar, ou limpar uma solução inteira

1. Em Solution Explorer, selecione ou abra a solução desejada.
2. No menu Build, escolha Build Solution, Rebuild Solution,. ou Clean Solution
o Escolha Build ou Build Solution para compilar somente os arquivos e
componentes de projetos que foram alterados desde a última compilação.

Observação
O comando Build passa a ser Build Solution quando uma solução inclui mais de um projeto.
o Escolha Rebuild Solution para " Limpar " a primeira solução, e então compilar
todos os arquivos e componentes de projeto .
o Escolha Clean Solution para excluir quaisquer arquivos intermediários e de saída,
deixando somente os arquivos e componentes de projeto, dos quais novas ocorrências de
arquivos intermediários e de saída podem ser compiladas.
Para criar ou reconstruir um único projeto
1. Em Solution Explorer, selecione ou abra o projeto desejado.
2. No menu Build, escolha Build [Project Name] ou Rebuild [Project Name].
o Escolha Build [Project Name] para criar somente esses componentes de projeto
que foram alterados desde a última compilação.
o Escolha Rebuild [Project Name] para " Limpar " o projeto primeiro, e então
compilar os arquivos de projeto e todos os seus componentes.
Para criar somente o projeto de inicialização e suas dependências
1. No menu Tools, escolha Options.
2. Na caixa de diálogo Options, expanda a pasta Projects and Solutions, e escolha Build
and Run.
A caixa de diálogo Compilar e executar, projetos e soluções, Opções é aberta.
3. Selecione a opção Only build startup projects and dependencies on Run.
Quando esta opção estiver selecionada, somente o projeto de inicialização atual e suas
dependências são criados quando você:
o Escolhe Start (F5) a partir do Menu Debug.
Ou-
o Escolhe Build Solution (CTRL+SHIFT+B) a partir do Menu Build.
Quando esta opção estiver desmarcada, o comando anterior não compila todos os projetos,
suas dependências, e os arquivos de solução. Por padrão, esta opção não é selecionada.
Para compilar somente o projeto Visual C++ selecionado
• Somente para projetos em Visual C++, um submenu Project Only do menu Build exibe
três comandos específicos do projeto:
o Criar somente projname < >
o Reconstruir somente projname < >
o Limpar somente projname < >
Esses três comandos compilam, limpam e compilam, ou limpam o Projeto Visual C++
atualmente selecionado no Solution Explorer, sem compilar ou limpar quaisquer dependências
do projeto ou arquivos de solução.
Para compilar em lotes várias configurações do projeto
1. No menu Build, escolha Batch Build.
2. Marque as caixas de seleção para as configurações do projeto que deseja criar.
3. Escolha Build ou Rebuild.
Para definir opções de salvar para os comandos de compilação

2. Na caixa de diálogo Options, expanda a pasta Projects and Solutions, e escolha Build
and Run.
A caixa de diálogo Opções, Criar e executar, projetos e soluções abre.
3. Selecione uma opção na lista Before building.
Para mostrar comentários sobre compilações
2. Na caixa de diálogo Options, expanda a pasta Projects and Solutions, e escolha
General.
A caixa de diálogo Opções, Geral, projetos e soluções abre.
3. Se desejar que a janela de saída venha para a frente e mostre o andamento da
compilação, selecione Show Output window when build starts.
4. Se você desejar para ver todos os erros de uma compilação na lista a tarefas quando a
compilação é terminado, selecione Always show Error List if build finishes with errors.
COMO: Alterar a pasta de saída de compilação
Visual Studio fornece uma maneira para que você modifique a localidade de saída gerada pelo
seu projeto. Devido a diferenças no Project Designers para as diferentes linguagens, o
procedimento para modificar a pasta de saída de compilação varia.
Projetos do Visual Basic
Para projetos Visual Basic, a alteração da pasta de saída de compilação é feita através do
Compile Pane. do Project Designer. Para mais informações, consulte COMO: alterar o local de
compilação para um aplicativo.
,Projetos Visual C# e Visual J#

Para alterar o diretório de saída de compilação:
1. No menu Project, clique em Properties.
2. Clique na guiaBuild.
3. Clique no botão Browse ao lado da caixa Output e selecione uma nova pasta de saída de
compilação.
Visual projetos C++
Para alterar o diretório de saída da compilação:
2. Expanda a guia Configuration Properties e clique em General.
3. Altere a caixa Output Directory para a nova pasta de saída.
COMO: compilar para uma pasta de saída comum
Por padrão, o Visual Studio 2005 cria cada projeto em uma solução na sua própria pasta dentro
da solução. Você pode alterar os caminhos de saída de compilação dos projetos para forçar que
todas as saídas sejam colocadas na mesma pasta.
Para colocar todas as saídas de solução em uma pasta comum

1. Clique em um projeto na solução.

3. Dependendo do tipo de projeto, clique na guia Compile ou na guia Build, e defina o
Output path para uma pasta que será usada por todos os projetos na solução. o
4. Repita as etapas de 1 a 3 para todos os projetos na solução.
COMO: Personalizar Eventos de Compilação
Eventos de compilação especificam comandos executados antes do inicio da compilação ou

depois que a compilação termina. Eventos de compilação são executados somente se a
compilação atingir esses pontos com êxito no processo de compilação. Devido a diferenças na
elaboração do projeto para os diferentes idiomas, o procedimento para personalizar eventos de
compilação varia.
Projetos do Visual Basic
Para obter informações sobre como personalizar eventos de compilação para projetos do Visual
Basic, consulte Especificando eventos de compilação:.
Projetos Visual C# e Visual J#
Para obter informações sobre como personalizar eventos de compilação para Projetos Visual C# e
Visual J# , consulte COMO: especificar eventos de compilação (c #, j #).
Projetos Visual C++
Para obter informações sobre como personalizar eventos de compilação para projetos Visual C++
, consulte Especificando eventos de compilação.
COMO: definir vários projetos de inicialização
Visual Studio 2005 permite que você especifique como mais de um projeto é executado quando
você inicia o depurador.
Para definir vários projetos de inicialização

1. Em Solution Explorer, selecione a solução.
2. No menu Project, clique em Properties. O A caixa de diálogo de páginas de Propriedades
da Solução abre.
3. Expanda o nó Common Properties, e clique em Startup Project.
4. Clique em Multiple Startup Projects e defina as ações do projeto. Para mais informações,
consulte Projetos de inicialização, Propriedades Comuns, Caixa de diálogo de Páginas de
Propriedades de Solução.
COMO: Criar e Remover Dependências de Projeto
Ao criar uma solução que contém vários projetos, pode ser necessário criar determinados projetos
primeiro, para gerar código usado por outros projetos. Quando um projeto consome código
executável gerado pelo outro projeto, o projeto que gera o código é conhecido como uma

dependência de projeto do projeto que consome o código. Essas relações de dependência podem
ser definidas na Caixa de Diálogo Project Dependencies.
Para atribuir dependências a projetos

1. Em Solution Explorer, selecione um projeto.
2. No menu Project, escolha Project Dependencies.
A caixa de diálogo Project Dependencies é aberta.
Observação
A opção Project Dependencies somente estará disponível em soluções contendo mais de um

projeto.
3. Na aba Dependencies , selecione um projeto a partir do menu suspenso Project.

4. No campo Depends on, selecione a caixa de seleção de qualquer outro projeto que deve
ser compilado antes deste projeto.
Para remover dependências de projetos
1. Em Solution Explorer, selecione um projeto.
2. No menu Project, escolha Project Dependencies.
A caixa de diálogo Project Dependencies é aberta.
Observação
A opção Project Dependencies somente estará disponível em soluções contendo mais de um

projeto.
3. Na aba Dependencies, selecione um projeto a partir do menu suspenso Project.

4. No campo Depends on, desmarque as caixas de seleção ao lado de outros projetos que
não sejam mais dependências deste projeto.
Compilar elementos de interface do usuário

Esses elementos de interface do usuário ajudam-no a compilar seus aplicativos e controlar o
andamento da compilação.
Caixa de Diálogo Batch Build

Use esta caixa de diálogo para criar várias configurações de projeto todas ao mesmo tempo. Você
pode decidir, por exemplo, compilar todas as configurações de projeto para um projeto com um
comando. Você pode acessar esta caixa de diálogo a partir do menu Build.
Verifique as configurações de compilação do projeto
Cada entrada inclui os seguintes campos:
Projeto

Exibe nomes de projetos na solução atual. Podem aparecer várias entradas para o mesmo
projeto, uma para cada configuração de projeto. Todas as entradas de todos os projetos
são listados numa única lista simples.
Configuração
Exibe o tipo de compilação do projeto especificado pela configuração de solução

selecionado (Solution Config).
Plataforma
Exibe o nome da plataforma na qual o projeto será executado
Solução Config
Exibe a configuração de compilação da solução que irá fornecer o contexto como este tipo
de configuração do projeto é compilado para a plataforma especificada. Por exemplo,
suponha que projeto P1 dependa de recursos de outro projeto, P2. A configuração da
solução especificará que a configuração de projeto de P1 para esta plataforma seja
compilada, e que a configuração de projeto de P2 que fornecerá os recursos dos quais P1
precisa também seja compilada.
Para alterar uma configuração de solução, use a Caixa de Diálogo Configuration Manager
para editar a configuração da solução ou criar uma nova configuração. Após alterar uma
configuração de solução, clique em Rebuild nesta caixa de diálogo para a compilação em
lotes de todas as configurações do projeto.
Criar
Especifica se a configuração de projeto especificada deve ser incluída na compilação em

lotes.
Botões
Criar
Compila apenas os itens de projeto para as combinações selecionadas de configuração do

projeto e plataforma que foram alterados desde a última compilação.
Recriar
Faz uma compilação completa a partir do zero de todos os itens para os itens de projeto
selecionado para as combinações selecionado de configuração do projeto e plataforma.
Limpar
Exclui todos os arquivos intermediários e pastas de saída para as combinações

selecionadas de configuração do projeto e plataforma.
Selecione Tudo
Marca cada configuração de projeto a ser incluída na compilação em lotes.
Desmarcar tudo
Remove cada configuração de projeto da compilação em lotes.

Fechar
Fecha a caixa de diálogo Batch Build.
Janela de saída
Esta janela pode exibir mensagens de status para vários recursos no ambiente de
desenvolvimento integrados (IDE). Para exibir a janela Output , selecione Output a partir do
menu View. Para fechar a janela Output e voltar o foco para o editor, pressione a tecla Escape
(ESC).
Toolbar
Show output from
Exibe um ou mais painéis de saída para serem visualizados. Vários painéis de informações
podem estar disponíveis, dependendo de quais ferramentas do IDE tiverem usado a janela
Output para enviar mensagens para o usuário.
Find Messsage in Code
Move o ponto de inserção no Editor de Códigos para a linha que contém o erro de
compilação selecionado.
Go to Previous Message
Altera o foco na janela Output para o erro de compilação anterior e move o ponto de
inserção no Editor de Códigos para a linha que contém esse erro de compilação.
Go to Next Message
Altera o foco na janela Output para o próximo erro de compilação e move o ponto de
inserção no Editor de Códigos para a linha que contém esse erro de compilação.
Clear all
Limpa todo o texto a partir do Painel Output.
Toggle Word Wrap
Ativa e desativa o recurso quebra automática de linha no painel Output. Quando a quebra
automática de linha estiver ativada, a continuação de textos que se estendem além área
de visualização são exibidos na linha seguinte.
Painel Output
O painel Output escolhido na lista Show output from exibe a saída a partir da origem indicada.
Direcionando mensagens para a janela output
Para exibir a janela Output sempre que você criar um projeto, selecione a opção Show Output
window when build starts na caixa de dialogo General, Projects and Solutions Option. Em

seguida, com um arquivo de código aberto para edição, clique nos botões Go To Previous
Message e Go to Next Message na barra de ferramentas da janela Output para selecionar as
entradas do painel Output. Na medida em que você faz isso, o ponto de inserção no editor de
código saltará para a linha do código onde o problema selecionado ocorre.
Certos recursos do IDE (Integrated Development Enviroments, ambiente de desenvolvimento

integrado) e comandos chamados na Janela de Comando entregam suas saídas para a janela
Output. Saídas de ferramentas externas como arquivos .bat e .com, normalmente exibidas na
janela do DOS, serão roteadas para um painel Output quando você seleciona a opção Use
Output Window na caixa de diálogo External Tools. Muitos outros tipos de mensagens também
podem ser exibidas nos painéis Output. Por exemplo, quando a sintaxe TSQL em um
procedimento armazenado é verificada em um banco de dados de destino, os resultados serão
exibidos na janela Output.
Você também pode programar seus próprios aplicativos para escreverem mensagens de
diagnóstico em tempo de execução em um painel Output. Para fazer isso, use membros da
classe Debug ou Trace no espaço para nome da System.Diagnostics da .NET Framework Class
Library Reference. Membros de classe Debug exibem a saída quando você compila as
configurações de depuração da sua solução ou projeto; membros da classe Trace exibem a saída
quando você compila tanto as configurações de depuração quanto as de criação de versão. Para
mais informações, consulte Mensagens de diagnóstico na janela de saída.
No Visual C++, você pode criar etapas personalizadas de compilação e criar eventos cujos avisos
e erros são exibidos e contados no painel Output. Pressionando F1 em uma linha de saída será
exibido um tópico da Ajuda apropriado. Para mais informações, consulte Formatação da saída de
uma etapa de compilação personalizada ou evento de compilação.
Caixa de Diálogo Configuration Manager

Use esta caixa de diálogo para criar e editar configurações de compilação de soluções e
configurações de projeto. Quaisquer alterações feitas em configurações de compilação de
soluções são refletidas na página Configuration da caixa de diálogo Solution Property Pages.
Você pode acessar o Configuration Manager a partir do menu Build, da caixa de diálogo
Solution Property Pages, ou da lista suspensa de configurações de solução na barra de
ferramentas principal.
Configuração de solução ativo
Exibe as configurações de compilação de solução disponíveis. Use esta lista suspensa ou

a lista suspensa Configuration na barra de ferramentas principal para alterar a
configuração de solução ativa. Para criar novas configurações de solução e modificar
configurações existentes, escolha <New...> ou <Edit...> na lista suspensa.
Plataforma solução ativo
Exibe as plataformas disponíveis para as quais compilar a solução. Quando você altera a
plataforma de solução ativa, a alteração é aplicada para todos os projetos na solução. Para
criar novas plataformas de solução e modificar plataformas existentes, escolha <New...>
ou <Edit...> na lista suspensa.
Contextos projeto
Cada entrada em Project contexts na configuração de compilação da solução

selecionada inclui um nome de projeto, para selecionar os projetos a ser criado listas
suspensas de tipos de configuração e plataformas, e caixas de seleção e (se ativado). A

combinação de tipo e plataforma escolhida determina a configuração do projeto que será
usada. Clique nos cabeçalhos de coluna para classificar as colunas na grade.
Projeto
Exibe os nomes dos projetos encontrados na solução atual.
Configuração
Exibe o tipo de compilação de projeto desejada, e lista todos os tipos disponíveis de

compilação. Para criar um novo tipo de compilação para o projeto ou renomear um tipo
existente, escolha <New...> ou <Edit...> desta lista suspensa.
Plataforma
Exibe a plataforma na qual a compilação desejada deve executar e lista todas as

plataformas disponíveis para o projeto. Para adicionar uma nova plataforma ou editar um
arquivo existente, escolha <New...> ou <Edit...> desta lista suspensa. O tipo de projeto
com o qual você estiver trabalhando determina se você pode adicionar mais de uma
plataforma e que plataformas estão disponíveis para que você adicione ao projeto. Quando
você adicionar uma plataforma a um projeto, uma nova configuração de projeto será
criada.
Criar
Especifica se o projeto será compilado pela configuração de solução atual. Projetos não
selecionados não são compilados, ainda que haja qualquer dependência de projeto
recaindo sobre eles. Projetos não selecionados para serem compilados são, ainda assim,
incluídos na depuração, execução, embalagem, e implantação da solução.
Implantar
Se ativado, especifica se o projeto será implantado quando os comandos Run ou Deploy

forem usados com a configuração selecionada de compilação da solução. Esta caixa de
seleção aparece somente para projetos implantáveis.
Depuração no Visual Studio

Você criou o seu aplicativo e resolveu os erros de compilação. Agora você deve corrigir esses
erros de lógica que evitam que seu aplicativo ou procedimentos armazenados sejam executados
corretamente. Você pode fazer isso com o desenvolvimento integrado de funções de depuração
do ambiente. Eles permitem que você se parar em locais de procedimento, inspecionar memória e
registrar valores, alterar variáveis, observar tráfego de mensagens, e obter uma visão de perto do
que seu código faz.
O que há de novo no depurador Visual Studio 2005

O depurador Visual Studio 2005 foi aprimorado pela adição dos seguintes recursos:
• Edit and Continue para Visual Basic e Visual C#.

Você pode alterar seu código do Visual Basic e C# durante a depuração de seu aplicativo, e
continuar a executar o aplicativo ao mesmo tempo. Este recurso aumenta sua produtividade,
permitindo-lhe a correção de erros rapidamente, testar novas funcionalidades, e modificar

funcionalidades existentes. Para obter mais informações, consulte Editar e continuar (Visual
Basic) e Edição e continuação (Visual C#).
• Depuração remota mais segura com configuração mais simples.
Configurar a depuração remota, copiando um único executável para o computador remoto sem
instruções de instalação complexas ou registro. A depuração remota é agora mais segura e
robusta. Além disso, agora você pode depurar aplicativos não gerenciados e gerenciados de
64-bit. Para obter mais informações, consulte Instalação de depuração remota.
• Visualizadores.
Ferramentas eficientes permitem você exibir dados em um formato natural e intuitivo. Você
pode iniciar um visualizador em uma janela Watch ou a partir do novo DataTips aprimorado.
Por exemplo, agora você pode exibir uma seqüência de caracteres como um documento HTML
ou XML. Você pode usar os visualizadores existentes ou escrever seus próprios. Para obter
mais informações, consulte Visualizadores.
• Depurador de DataTips aprimorado.
O depurador de DataTips foi aperfeiçoado. Você pode percorrer o conteúdo de estruturas de
dados complexas no editor de código-fonte. Você pode abrir um visualizador de um DataTip
para visualizar os dados em um formato intuitivo e natural. Para obter mais informações,
consulte HOW TO: Use DataTips.
• Depuração Just My Code
Esse recurso habilita você a focalizar apenas o código que você tenha escrito e ignorar código
no qual você não esteja interessado. Para obter mais informações, consulte Como: etapa INTO
apenas meu código.
• Tracepoints e pontos de interrupção UI aprimorados.
Pontos de interrupção não são mais para interromper apenas. Tracepoints são uma nova
maneira de usar pontos de interrupção para executar uma ação personalizada. Com
tracepoints, você pode imprimir uma mensagem ou executar uma macro de automação do
Visual Studio, e você determina se o depurador interrompe ou continua quando ele acerta um
tracepoint. A interface com o usuário é aprimorada para tornar a definição de todos os pontos
de interrupção mais fácil e rápida. Para obter mais informações, consulte Pontos de interrupção
e Tracepoints.
• Melhores ferramentas para depuração de multiprocessos.
A nova janela Processes mostra todos os processos aos quais você está conectado para
depuração. Filtros de ponto de interrupção permitem você anexar um ponto de interrupção a
processos, segmentos e computadores especificados. A caixa de diálogo Attach to Process é
simplificada para facilidade de uso, com informações de processos movidas a partir da caixa
de diálogo para a janela Processes. Para obter mais informações, consulte Como: Anexar a
um Processo em Execução: e Como: Usar Processes Window:.
• Assistente de Exceção para Visual Basic, C# e Visual J#.
A nova caixa de diálogo Exception Assistant fornece melhores informações quando ocorre
uma exceção em um programa do Visual Basic, C# ou Visual J#. Para obter mais informações,
consulte Assistente de exceção.
• Suporte aprimorado para gerenciar informações da depuração.
Melhor suporte para símbolo de servidor e mensagens de diagnóstico para solucionar
problemas de informações da depuração.
• Depuração do código em tempo de criação.
Você pode depurar seu aplicativo Visual Basic, C# ou Visual J# enquanto você está o criando.
Utilizando a janela Immediate, você pode testar e depurar suas funções e métodos sem ter
que executar o aplicativo.

• Suporte a novos recursos no SQL Server 2005, incluindo:
o Depuração de tipos de objetos de banco de dados gerenciado.
o Depuração de aplicativos multicamadas, passando entre as camadas do aplicativo
e do banco de dados SQL Server.
o Depuração para frente e para trás entre código gerenciado e T-SQL.
o Suporte para depuração em plataformas de 64 bits.
Alterações no Depurador do Visual Studio .NET 2003
O depurador do Visual Studio .NET 2003 foi aprimorado pela adição dos seguintes recursos:
• Aprimoramentos de segurança, incluindo uma nova restrição na depuração Just-In-Time,

que melhora a segurança impedindo a depuração Just-In-Time entre computadores. Para obter
mais informações, consulte Depuração Just-In-Time.
• Depuração remota usando pipes, uma nova alternativa para depuração TCP/IP que ajuda
e proporciona mais segurança. Para obter mais informações, consulte Depuração Remota
Usando Pipes.
• A capacidade de carregar despejos contendo informações gerenciadas. Despejos
gerenciados podem ser depurados usando a ferramenta SOS de depuração, que é executada
a partir da janela Command.
• Depuração automática em serviços XML da Web. Para obter mais informações, consulte
Depuração em Serviços XML da Web.
• Suporte para fazer o download automaticamente de símbolos de depuração a partir de um
símbolo de servidor. Para obter mais informações, consulte Servidor de Símbolo.
• Mensagens de erro aprimoradas especialmente para erros que ocorrem durante a
depuração de aplicativos da Web.
• Uma nova pseudovariável $exception para recuperar informações sobre exceções C#.
Alterações no Depurador do Visual Studio .NET 2002
O Visual Studio .NET 2002 fornecia um único depurador integrado para todas as linguagens do
Visual Studio. Uma nova e unificada interface combinou recursos de antigos depuradores do
Visual C++ e Visual Basic, bem como muitos novos recursos. As principais melhorias para
depuração incluem:
• Depuração de linguagens cruzadas do Visual Basic . NET, Visual C++ .NET, Visual C# .
NET, Managed Extensions for C++, script, e SQL.
• Depuração de aplicativos escritos para o Common Language Runtime do Microsoft .NET
Framework, bem como aplicativos nativos Win32.
• Anexar a um programa em execução, tanto no computador host ou remoto.
• Anexar automaticamente a processos do servidor para aplicativos ATL Server, aplicativos
ASP.NET da Web, e serviços ASP.NET da Web quando estiverem depurando.
• Depuração de vários programas diferentes, iniciando vários programas em uma única
solução do Visual Studio, ou anexando a outros programas que já estão sendo executados.
• Usar verificação de erros em tempo de execução no Visual C++ para detectar erros
comuns em tempo de execução, tais como corrupção do ponteiro da pilha, saturações de
matrizes locais, corrupção de pilha, dependências ao inicializar variáveis locais, e perda de
dados em uma atribuição a uma variável mais curta.
• Verificar a segurança de buffer dos aplicativos do Visual C++ com a opção /GS. Você pode
usar esta opção para detectar saturações de buffer, o que substitui o endereço do remetente

• Definir um ponto de interrupção em uma DLL que ainda não foi carregada. O ponto de
interrupção automaticamente tornar-se-a ativo quando a DLL carregar. Você não precisará
especificar DLLs que você deseja depurar em uma caixa de diálogo Additional DLLs, como
você fez no depurador do Visual C++.
• Depuração de clientes de serviços XML da Web aos serviços XML da Web, com um pilha
de chamadas integrada entre aplicativos cliente e servidor.
• Janelas não restritas substituíram caixas de diálogo restritas para pontos de interrupção e
segmentos, o que fornece maior flexibilidade no controle e acesso de recursos na sua área de
trabalho.
Segurança do Depurador
A capacidade de depurar um outro processo lhe concede poderes extremamente grandes que
você não teria de outro modo, especialmente quando estiver depurando remotamente. Um
depurador mal-intencionado poderia inflingir danos amplos no computador que está sendo
depurado. Devido a isso, há restrições sobre quem pode fazer a depuração. Para obter mais
informações, consulte Permissões de depuração remota.
Muitos desenvolvedores no entanto, não percebem que a ameaça de segurança também pode
fluir na direção oposta. É possível que o código mal-intencionado do processo de depuração
comprometa a segurança do computador de depuração: existe uma gama de vulnerabilidades de
segurança que devem ser protegidas.
Práticas Recomendadas de Segurança
Não há um relacionamento de confiança implícito entre o código que você está depurando, e o
depurador. Se você estiver disposto a depurar algo, você também deve estar disposto a executá-
lo. A linha inferior é que você deve ser capaz de confiar naquilo que você está depurando. Se
você não puder confiar, então você não deve depurar, ou você deve depurar a partir de um
computador que você possa se responsabilizar a se comprometer, e em um ambiente isolado.
Para reduzir a superfície do ataque em potencial, a depuração deve ser desativada em

computadores de produção. Pelo mesmo motivo, a depuração nunca deve ser ativada
indefinidamente.
Segurança de Depuração Gerenciada
Aqui estão algumas recomendações gerais que se aplicam a toda depuração gerenciada.
• Tenha cuidado ao se anexar a processo de um usuário não confiável: quando você fizer
isso, você assume que ele é confiável.Quando você tenta se anexar a um processo de usuário
não confiável, uma caixa de diálogo de aviso de confirmação, será exibida perguntando se
você deseja se anexar ao processo. " Usuários Confiáveis " incluem você, e um conjunto de
usuários padrão normalmente definidos em computadores que têm o .NET Framework
instalados, como aspnet, localsystem, networkservice, e localservice. Para obter mais
informações, consulte Aviso de Segurança: Attaching para um processo não confiáveis pode
ser Dangerous.
• Tenha cuidado ao fazer download de um projeto de fora da Internet e ao carregá-lo no
Visual Studio . Isso é muito arriscado para fazer mesmo sem depuração. Quando você fizer
isso, você está presumindo que o projeto e o código que ele contém são confiáveis.
Segurança em Depuração Remota
A depuração local é geralmente mais segura do que a depuração remota. A depuração remota
aumenta a área tatal de superfície que pode ser investigada.

O Monitor de Depuração Remota do Visual StudioMonitor (msvsmon.exe) é usado na depuração
remota, e há várias recomendações de segurança para configurá-lo. A maneira preferida para
configurar o modo de autenticação é a Autenticação do Windows, pois o modo No Authentication
(não-autenticação) não é seguro. Ao usar o modo de Autenticação do Windows, esteja ciente que
conceder uma permissão de usuário não confiável para se conectar ao msvsmon é perigoso,
conforme será indicado por um aviso de Caixa de Diálogo.
Não depure um processo desconhecido em um computador remoto: há possíveis vulnerabilidades

que podem afetar a máquina que encontra-se executando o depurador, ou que pode comprometer
msvsmon.exe, o Remote Monitor depuração Visual Studio. Se você deve depurar um processo
desconhecido de qualquer forma, tente depurá-lo localmente, e use um firewall para manter
quaisquer ameaças em potencial localizadas.
Segurança de Depuração de Serviços da Web
É mais seguro depurar localmente, mas uma vez que, provavelmente, você não tenha o Visual
Studio instalado no servidor da Web, a depuração local pode não ser prática. Geralmente, a
depuração de Serviços da Web é feita remotamente, exceto durante o desenvolvimento, portanto
as recomendações de segurança de depuração remota também se aplicam a depuração de
serviços da Web. Aqui estão algumas recomendações adicionais. Para obter mais informações,
consulte Depuração Serviços XML da Web.
• Não ative a depuração em um servidor da Web que foi comprometido.

• Certifique-se de que você sabe que o servidor Web é seguro antes de depurá-lo. Se você
não tiver certeza de que ele é seguro, não faça a depuração.
• Tome cuidado principalmente se você estiver depurando um serviço da Web que está
exposto na Internet.
Componentes Externos
Esteja ciente dos status de confiança de componentes externos com que o programa interage,
especialmente se você não tiver escrito o código. Também esteja ciente de componentes que o
Visual Studio ou o depurador possa usar.
Símbolos e Código Fonte
Duas ferramentas do Visual Studio que exigem preocupação com a segurança são as seguintes:
• Source Saver, que lhe fornece versões de código fonte provenientes de um repositório de
código fonte. Ele é útil quando você não tiver a versão atual do código fonte de um programa.
Para obter mais informações, consulte Como: Obter código fonte usando Source Server e
Aviso de Segurança: depurador deve executar comando não confiáveis.
• Symbol Server, que é usado para fornecer os símbolos necessários para depurar uma
falha durante um chamada do sistema. Para obter mais informações, consulte Como
especificar um caminho símbolo: e Como usar um servidor símbolo:.
Preparação e configurações de depuração

Esta seção descreve as configurações de propriedades relacionadas ao depurador, e a
preparação necessária para depurar o programa com o depurador do Visual Studio. Se você criar
seu programa no Visual Studio usando os modelos de projeto, essas configurações são definidas
corretamente para você na configuração Debug.
Para obter mais informações, consulte HOW TO: definir depuração e configurações de versão.

Configurações do Projeto do Depurador
Determinadas configurações do projeto também afetam a depuração. Essas configurações
determinam tais itens em quais diretórios o depurador examina o comando e argumentos de
comando usados para iniciar o programa e o tipo de informação da depuração criada para o
programa. Você pode alterar essas configurações na caixa de diálogo Property Pages.
Esta seção descreve quais opções estão disponíveis e como defini-las.
Requisitos de software depuração SQL

Este tópico se aplica a:
Edição do Visual Studio Visual Basic C# C++ J# Visual Web Developer
Express Não Não Não Não Não
Padrão Não Não Não Não Não
Pro / Team Sim Sim Sim Não Não
Esta seção descreve o software necessário para depurar o código em um banco de dados do SQL
Server. Há requisitos adicionais quando estiver depurando um aplicativo de múltiplas camadas do
SQL Server. Para obter mais informações, consulte Depuração de aplicação multi-camada de
banco de dados.
Requisitos de Softwares de Camadas de Banco de Dados
A depuração em SQL com o Microsoft Visual Studio 2005 requer o seguinte software no servidor:
• O Microsoft Windows 2000 ou posterior é recomendado.

• O SQL Server 2005 ou o SQL Server 2000 com o Service Pack 3 necessário.
Requisitos de Softwares de Camadas de Banco de Dados (somente CLR do SQL)
A depuração da CLR do SQL requer os seguintes softwares adicionais no servidor:
• O monitor de depuração remota (msvsmon) é necessário estar executando quando você

depurar. Se você estiver executando o SQL Server 2005, o programa de instalação que
instalará o msvsmon já está no servidor em in <sql server install dir>\ 90\Shared\rdbgsetup.exe.
Execute este programa para instalá-lo, e o SQL Server o iniciará sempre que você entrar em
ou atingir um ponto de interrupção.
• Todoos os outros requisitos desta página aplicam-se à CLR do SQL, bem como do TSQL.
Requisitos Adicionais de Softwares de Múltiplas Camadas
Com o Visual Studio 2005, você pode depurar aplicativos de várias camadas que façam conexões
com banco de dados do SQL Server e que executem procedimentos armazenados em SQL. Para
fazer isso, a camada do aplicativo deve conectar-se ao bancos de dados usando um dos
seguintes procedimentos:

• Cliente SQL
• OLE DB, ODBC, ou DBLIB.
• Uma tecnologia como ADO ou ADO.NET que foi construída a cima do OLE DB ou do
ODBC.
• O adaptador de dados gerenciado para o SQL Server.
Ambiente de Desenvolvimento
Para obter informações sobre requisitos de sistema do Visual Studio 2005 por favor consulte
Requisitos de hardware do Visual Studio.
Depuração em SQL com o Microsoft SQL Server 2005 requer uma das seguintes edições do
Visual Studio 2005 :
• Visual Studio 2005Pro

• Visual Studio 2005 Team Edition for Architects
• Visual Studio 2005 Team Edition for Developers
• Visual Studio 2005 Team Edition for Testers
• Visual Studio 2005 Team Suite
HOW TO: definir depuração e configurações de versão
Um projeto Visual Studio tem configurações separadas para liberação e depuração de versões do
seu programa. Como os nomes sugerem, você cria a Versão de depuração para depuração e a
versão de lançamento para a distribuição da versão final.
Se você criar seu programa no Visual Studio, Visual Studio automaticamente cria essas
configurações e define opções padrão apropriadas e outras configurações. Com as configurações
padrão:
• A configuração de depuração do seu programa é compilada com informação de depuração

toda simbólica e Sem otimização. Otimização complica a depuração, já que a relação entre
código fonte e instruções geradas é mais complexa.
• A configuração para lançamento do seu programa é totalmente otimizada e não contém
nenhuma informação da depuração simbólica. Informação sobre depuração pode ser gerada
em Arquivos PDB (C++) dependendo das opções do compilador usadas. (Criar Arquivos PDB
pode ser muito útil se você precisar depurar a versão de lançamento posteriormente.)
Você pode alternar entre versões de lançamento e de depuração usando a barra de ferramentas
padrão ou o Gerenciador de configuração. Para obter mais informações consulte COMO Criar e
Editar Configurações:.
Observação
Quando você instalou o Visual Studio, você é solicitado a escolher um conjunto de configurações
de desenvolvimento para a linguagem de programação primária. Se você escolher as
configurações de desenvolvimento do Visual Basic, a ferramenta para escolher a configuração de

depuração ou de lançamento não aparece na barra de ferramentas. Em vez disso, Visual Studio
escolhe automaticamente a configuração de depuração quando você escolhe Start a partir do
menu Debug e as configurações de lançamento quando você usa o menu Build. Se você desejar
alterar as configurações de desenvolvimento, consulte Como: Restaurar comandos ocultos do
depurador.
Procedimentos
Para alternar para a configuração de depuração ou de lançamento
• Na barra de ferramentas Standard, clique em Debug ou Release da caixa de listagem

Solution Configurations.
Você pode mudar as definições para uma configuração usando o <Project> Property Pages.
Dependendo do tipo de projeto, esta janela será uma caixa de diálogo contendo um controle de
árvore no canto esquerdo para Categorias de navegação — Visual C++ e sites da Web— ou uma
janela com guias no painel editor de texto do Visual Studio.
Para alterar as definições para a configuração de depuração ou de lançamento
1. No Solution Explorer, selecione o projeto.

2. No menu View, clique em Property Pages. Ou você pode clicar com o botão direito do
mouse no nome do projeto no Solution Explorer, e selecionar Property Pages.
3. Na página de propriedades <Project> , selecione se a guia Debug ou, se o tipo de projeto
é um site da Web, Start Options.
4. Na caixa de listagem Configuration, clique em Debug ou Release.
5. Edite o valor das configurações que você deseja alterar. Nem todas as propriedades
relacionadas ao depurador estão contidas na página Debug, há mais na página Build. A
exibição exata das guias irá variar de acordo com o tipo de projeto.
Configurações do projeto para um C++ depurar configuração

Você pode alterar as configurações de projeto para uma configuração de depuração C ou C++ na
caixa de diálogo Property Pages, conforme discutido em HOW TO: definir depuração e
configurações de versão. As tabelas a seguir mostram onde encontrar configurações relacionadas
de depurador na caixa de diálogo Property Pages.
Especifique qual depurador usar na caixa de listagem Debugger to launch. Sua escolha irá afetar
quais propriedades são visíveis.
Automaticamente cada configuração da propriedade de depuração serão gravadas e salvas para

o arquivo (.suo) "por usuário" para sua solução sempre que salvar sua solução.
Pasta de propriedades de configuração (categoria de depuração)

Pasta de configuração de propriedades (categoria de depuração)
Setting Description
Debugger to launch Especifica o depurador a ser executado, com as seguintes opções:
• Local Windows Debugger
• Remote Windows Debugger
• Web Service Debugger
• MPI Cluster Debugger

Command (Local Especifica o comando para iniciar o programa que você está
Windows Debugger) depurando na máquina local.
Remote Command O caminho para o .exe conforme ilustrado pelo computador remoto.
(Remote Windows
Debugger)
Application Command
(MPI Cluster Debugger)
Command Arguments • Especifica argumentos para o comando especificado acima.
(Local Windows Você pode usar os seguintes operadores de redirecionamento na
Debugger e Remote caixa:
Windows Debugger) < file
Application Arguments Lê stdin do arquivo.
(MPI Cluster Debugger) > file
Grava stdout em arquivo.
>> file
Anexa stdout ao arquivo.
2> file
Grava stderr em arquivo.
2>> file
Anexa stderr ao arquivo.
2> &1
Envia as saídas stderr (2) ao mesmo local que stdout (1).
1> &2
Envia saídas stdout (1) ao mesmo local que stderr (2).
Na maioria dos casos, esses operadores são aplicáveis somente a
aplicativos do console.
Working Directory Especifica a pasta de trabalho do programa que está sendo depurado,
relativo ao diretório do projeto onde o seu EXE está localizado. Se
você deixar isto em branco, a pasta de trabalho ficará o diretório do
projeto. Para depuração remota, o diretório do projeto será ativado no
servidor remoto.
Attach (Local Windows Especifica a iniciar ou anexar para o aplicativo. A Configuração padrão
Debugger and Remote é Não.
Windows Debugger)
Remote Server Name Especifica o nome de um computador (diferente do seu) no qual você
(Remote Windows deseja depurar um aplicativo ou um Nome do servidor Msvsmon. Você
Debugger and MPI também pode selecionar isso a partir da caixa de diálogo Processes
Cluster Debugger) (para obter mais informações, consulte Selecionando um computador
remoto). Se você especificar o nome da máquina aqui, também deverá
especificar o tipo de conexão em Connection.
O macro RemoteMachine Build é definido para o valor da propriedade;
para obter mais informações, consulte Macros para construir
comandos e propriedades.
Connection (Remote Permite que você alterne entre depuração local e remota. Especifique
Windows Debugger and um nome de computador remoto na caixa Remote Server Name.
MPI Cluster Debugger) Tipos de conexão incluem:
• Remote with Windows Authentication
• Remote with No Authentication (Native Only)
Observação A depuração remota com No Authentication pode deixar
o computador remoto vulnerável a violações de segurança. O Modo de
Autenticação do Windows é mais seguro.
Para obter mais informações, consulte Instalação de depuração

remota.
HTTP URL (Web Service Especifica a URL onde o projeto que você está depurando está
Debugger) localizado.
Debugger Type Especifica o tipo de depurador a ser usado: Native Only, Managed
Only, Mixed ou Auto (padrão).
• Native Only é para código C++ não gerenciado.
• Managed Only é para código que é executado com o
Common Language Runtime (código gerenciado).
• Mixed dispara depuradores para código gerenciado e não
gerenciado.
• Auto determina o tipo de depurador com base no compilador
e informações EXE.
Environment (Local Especifica variáveis de ambiente para o programa que você está
Windows Debugger) depurando. Essas variáveis substituem o ambiente do sistema ou são
mescladas com o ambiente do sistema, dependendo da configuração
Merge Environment. Quando você clica na coluna configurações, um
botão ( ) elipse aparece. Clique no botão ( ) elipse para editar
variáveis de ambiente.
Merge Environment Determina se as variáveis especificadas na caixa Environment serão
(Local Windows mescladas com o ambiente definido pelo sistema operado. A
Debugger) configuração padrão é Sim.
SQL Debugging (todos Ativa a depuração de procedimentos SQL de seu aplicativo Visual
menos MPI Cluster C++. A configuração padrão é Não.
Debugger)
Pasta C/C++ (Categoria geral)
Configuração Descrição
Debug Information Especifica o tipo de informações de depuração a serem criadas para o
Format (/Z7, /Zd, Zi, projeto.
/ZI) A opção padrão (/ZI) cria um banco de dados do programa (PDB) em
formato compatível Edição e Continuação. Para obter mais informações,
consulte /Z7, /Zd, /Zi, /ZI (formato de informações de depuração).
Para obter detalhes, consulte Arquivos PDB e Arquivos DBG
Pasta C/C++ (categoria de otimização)
Optimization Especifica se o compilador deve otimizar o código que ele produz. A otimização
altera o código que é executado. O código otimizado não corresponde mais ao
código fonte, portanto a depuração é difícil.
A opção padrão (Disabled (/0d) suprime a otimização. Você pode desenvolver
com otimização suprimida, e em seguida, ativá-la ao criar a versão de produção
do seu código.
Pasta vinculadora (Categoria de depuração)
Generate Debug Info Informa o vinculador para incluir informações da depuração, que
(/DEBUG) terão o formato especificado por /Z7, /Zd, Zi, ou /ZI.
Generate Program Especifique o nome de um arquivo PDB nesta caixa. Você deve

Database File (/PDB:nome) selecionar ZI ou /Zi para formato de informações de depuração.
Strip Private Symbols Especifique o nome de um arquivo PDB nesta caixa se você não
(/PDBSTRIPPED:filename) desejar incluir símbolos particulares no arquivo PDB. Esta opção
cria um segundo arquivo (PDB) de banco de dados de programa
quando você cria sua imagem de programa com qualquer uma das
opções de compilador ou vinculador que geram um arquivo PDB
(/DEBUG, /Z7, /Zd, ou /Zi). Esse segundo arquivo PDB omite
símbolos que você não desejaria enviar para seus clientes. Para
obter mais informações consulte /PDBSTRIPPED (símbolos Private
Faixa).
Generate Map File (/MAP) Informa o vinculador para gerar um arquivo de mapa durante a
vinculação. A configuração padrão é Não. Para obter mais
informações consulte /MAP (Gerar Mapfile).
Map File Name Se você escolher gerar arquivo de mapa, você pode especificar o
(/MAP:nome) arquivo de mapa nesta caixa. Para obter mais informações consulte
/MAP (Gerar Mapfile).
Map Exports Inclui funções exportadas no arquivo de mapa. A configuração
(/MAPINFO:EXPORTS) padrão é Não. Para obter mais informações consulte /MAPINFO
(inclui informações em Mapfile).
Debuggable Assembly Especifica configurações para a opção Linker /ASSEMBLYDEBUG.
(/ASSEMBLYDEBUG) Possíveis valores são:
• No debuggable attribute emitted.
• Runtime tracking and disable optimizations
(/ASSEMBLYDEBUG); esta é a configuração padrão,
• No runtime tracking and enable
optimizations(/ASSEMBLYDEBUG:DISABLE).
• <inherit from parent or project defaults>.
• Para obter mais informações consulte /ASSEMBLYDEBUG
(Adicionar DebuggableAttribute).
Você pode alterar essas configurações na pasta Configuration Properties (categoria de

depuração) programaticamente usando a interface
Microsoft.VisualStudio.VCProjectEngine.VCDebugSettings. Para obter mais informações, consulte
VCDebugSettings.
Como definir permissões SQL Server para depuração:

Standard Não Não Não Não Não
Pro/Team Sim Sim Sim Não Não
Esta seção descreve as permissões necessárias para depuração SQL. Essas permissões são
apenas aqueles impostas pela depuração do SQL; não pode ser outra permissão necessária em

outro lugar. Por exemplo, para depurar um processo em execução como um usuário diferente do
que sua conta de logon do Windows, a conta deve ser de um membro do grupo de
administradores do sistema para o computador. Para obter mais informações, consulte
Permissões de depuração remota.
Há duas contas de usuário que você necessita considerar
• A conta do aplicativo é a conta de usuário que Visual Studio ou o aplicativo cliente que
estiver executando sob. Esta conta é uma conta de usuário do Windows e deve ser um
membro do grupo sysadmin no SQL Server que está sendo depurado.
• A conta de conexão é a identidade usada para fazer a conexão ao SQL Server. Esta é a
conta que você insere quando define a conexão no Server Explorer ou que você especifica na
seqüência de conexão quando o aplicativo se conecta a um banco de dados. Esta conta pode
ser uma conta de usuário do Windows, usando a autenticação do Windows, nesse caso, é a
mesma conta como a conta do Windows na qual Visual Studio está sendo executado. Ou a
conta de conexão pode ser uma conta de logon do SQL Server. Para depuração SQL Server
2005, a conta de conexão deve ser um membro da função sysadmin.
Para adicionar uma conta de logon do Windows como sysAdmin
• Um usuário que já tenha privilégios SysAdmin deve executar o seguinte:
sp_addsrvrolemember 'Domain\Name', 'sysadmin'
onde Domain\Name representa a conta de logon do Windows.
Observação
Por padrão, os administradores do Windows em um computador que executam o SQL Server são
SQL Server sysadmins nessa máquina.
Configurações do projeto para uma configuração de depuração

no Visual Basic
Você pode alterar as configurações do projeto para uma configuração de depuração do Visual
Basic na janela Property Pages, conforme discutido em Configurações de depuração e de
lençamento. As tabelas a seguir mostram onde localizar configurações relacionadas a depurador
sna janela Property Pages.
Guia Depuração
Configuration Define o modo para compilar o aplicativo. Escolha entre Active (Debug),
Debug, Release, All Configurations.
Start Action Este grupo de controles especifica a ação que irá ocorrer quando você
escolher iniciar no menu Depurar.
• Start project é o padrão e inicia o projeto de inicialização para
depuração. Para obter mais informações, consulte Escolhendo o projeto
de inicialização.
• Start external program permite a você iniciar e anexar a um
programa que não faz parte de um projeto Visual Studio. Para obter
mais informações, consulte Anexar a um programa em execução.
• Start browser in URL permite a você depurar um aplicativo da
Web.

Argumentos da Especifica argumentos de linha de comando para o programa a ser
linha de comando depurado. O nome do comando é o nome do programa especificado no
programa externo Iniciar. Se a Ação Iniciar é definida para iniciar URL,
argumentos de linha de comando serão ignorados.
Diretório de Especifica a pasta de trabalho do programa que está sendo depurado. No
trabalho Visual Basic, a pasta de trabalho é o diretório de que aplicativo é iniciado,
\bin, por padrão.
Usar máquina Quando a caixa de seleção estiver marcada, a depuração remota é ativado.
remota Na caixa de texto, você pode digitar nome de um computador remoto onde o
aplicativo será executado para fins de depuração ou um Nome do servidor
Msvsmon. O local do EXE no computador remoto é especificado pela
propriedade Output Path na guia construir. O local deve ser um diretório
compartilhável no computador remoto.
Depuração de Permite a você depurar chamadas para código nativo (não gerenciado) de
código não Win32 de seu aplicativo gerenciado. Isso tem o mesmo efeito de que
gerenciado selecionar misto para tipo de depurador em um projeto Visual C++.
Depuração do Permite a depuração de objetos de banco de dados do SQL Server.
SQL Server
Guia Compilar: Pressione botão Opções avançadas de compilação
Ativar Esta opção deve ser desmarcada. Otimização faz com que o código que é
otimizações realmente executado seja diferente do código fonte visto no Visual Studio, e
assim torna difícil depuração. Se o código é otimizado, símbolos não são
carregados por padrão quando estiver depurando com Just My Code.
Gerar Definidos por padrão nas versões de lançamento e de depuração, esta
informações de configuração (equivalente a opção do compilador /debug) cria informações da
depuração depuração ao tempo de compilação. O depurador usa essas informações
para mostrar nomes de variáveis e outras informações em um formulário útil
quando você está depurando. Se você compila seu programa sem essas
informações, a funcionalidade do Depurador será limitada. Para obter mais
informações, consulte /Debug.
Definir constante Definir esse símbolo permite compilação condicional das funções de saída da
DEBUG classe de depuração. Com esse símbolo definido, métodos de classe de
depuração geram a saída para a Janela de saída. Sem esse símbolo,
métodos da classe de depuração não são compilados e nenhuma saída é
gerada. Este símbolo deve ser definido na Versão de depuração e não
definido na versão de lançamento. Definir esse símbolo em uma versão de
lançamento cria desnecessário código que torna o programa lento.
Definir constante Definir esse símbolo permite a compilação condicional das funções de saída
Trace da classe Rastrear. Com esse símbolo definido, os métodos de classe de
rastreamento geram a saída para a Janela de saída. Sem esse símbolo,
métodos de classe de rastreamento não são compilados e nenhuma saída de
rastreamento é gerada. Esse símbolo é definido por padrão para as versões
de depuração e de lançamento.

Arquivos PDB (C++)
Um arquivo (PDB) de banco de dados de programa contém informações de estado que permite
vinculação incremental de uma configuração de seu programa de depuração. Um arquivo PDB é
criado quando você cria com /ZI ou /Zi (para C/C++).
No Visual C++, a opção /Fd nomeia o arquivo PDB criado pelo compilador. Quando você cria um
projeto em Visual Studio usando assistentes, a opção /Fd é definida para criar um PDB chamado
project.PDB.
Se você criar seu aplicativo C/C++ usando um makefile, e você especificar /ZI ou /Zi sem /Fd,
você finaliza com dois arquivos PDB:
• VC80.PDB (Mais geralmente, VC x 0.PDB onde x representa a versão do Visual C++).

Esse arquivo armazena todas as informações de depuração para os arquivos OBJ individuais e
reside no mesmo diretório que o project makefile.
• Esse arquivo armazena todas as informações da depuração para o arquivo .exe. Para
C/C++, ele reside na subpasta \debug.
Sempre que ele cria um arquivo OBJ, o compilador C/C++ mescla informações da depuração no
VC x 0.PDB. As informações inseridas incluem informações de tipo mas não inclui informações
símbolo, como definições de função. Então, mesmo que todos os arquivos de origem incluam
arquivos de cabeçalho como <windows.h>, os typedefs daqueles cabeçalhos são armazenados
apenas uma vez, especialmente estando em todo arquivo OBJ.
O vinculador cria project.PDB, que contém informações da depuração para o arquivo EXE do
projeto. O arquivo do project.PDB contém informações completas da depuração, incluindo
protótipos de função, não apenas as informações encontradas em VC x 0.PDB Os dois arquivos
PDB permitem atualizações incrementais. O vinculador também incorpora o caminho para o
arquivo .pdb no arquivo .exe ou .dll que ele cria.
O depurador Visual Studio usa o caminho para o PDB no arquivo EXE ou DLL para localizar o
arquivo do project.PDB. Se o depurador não pode localizar o arquivo PDB naquele local ou se o
caminho for inválido (por exemplo, se o projeto foi movido para outro computador), o depurador
pesquisa o caminho que contém o EXE, os caminhos símbolo especificados na caixa de diálogo
Options (pasta Debugging, nó Symbols). O depurador não carregará um PDB que não coincide
com o binário que está sendo depurado.
Arquivos DBG
Visual Studio Visual Basic C# C++ J# Dev Web
Express Não Não Sim Não Não
Padrão Não Não Sim Não Não
Pro / Team Não Não Sim Não Não

Os arquivos DBG são formatos de arquivos executáveis portáveis (PE) que contêm informações
da depuração no formato Codeview para o depurador no Visual Studio (e possivelmente outros
formatos, dependendo de como o DBG foi criado). Quando você não tem origem para
determinados códigos, tais como bibliotecas ou APIs do Windows, os arquivos DBG permitem a
depuração. Os arquivos DBG também permitem à você para fazer depuração do OLE RPC.
Arquivos DBG podem ter sido substituídos por arquivos PDB, que agora são mais comumente
usados na depuração.
Você pode usar o utilitário REBASE.EXE para tirar informações da depuração de um executável
no formato PE e armazená-lo em um arquivo DBG. O campo de característica do arquivo
IMAGE_FILE_DEBUG_STRIPPED no cabeçalho do arquivo PE informa o depurador que as
informações do Codeview foram extraídas para um arquivo DBG separado.
Você pode baixar e instalar arquivos DBG que contêm símbolos de depuração de chamadas para
as APIs Windows do sistema. Para obter mais informações, consulte Instalar símbolos de
depuração do sistema.
Quando você depurar utilizando símbolos de um arquivo DBG, você deve usar os nomes
totalmente decorados. Por exemplo, para definir um ponto de interrupção em uma chamada para
a função sndPlaySound do Windows, você precisará especificar o _sndPlaySoundA@8.
O depurador do Visual Studio não foi criado para depuração no modo protegido do código no
Kernel, mesmo com símbolos DBG.
Para modo de depuração do usuário, o Visual Studio requer os seguintes arquivos:
• Uma máquina Windows 2000, e os arquivos DBG e PDB no diretório

\winNT\SYMBOLS\DLL.
• Um computador Windows XP, e os arquivos PDB no diretório \Windows\SYMBOLS\DLL.
Para obter mais informações sobre arquivos DBG, consulte o artigo no KB a seguir:
• Q121366, INFO: Arquivos PDB e DBG - O que são e como eles funcionam
Você pode encontrar artigos do KB na Biblioteca do MSDN.
Instalando símbolos para sistema de depuração chamada

Crashes
Para depurar uma falha que ocorre durante uma chamada para uma DLL de sistema ou biblioteca
de terceiros, você geralmente precisará dos arquivos DBG ou PDB do sistema, que contêm
símbolos para DLLs Windows, EXEs, e drivers de dispositivo. Você pode obter esses símbolos de
diversos lugares:
• O CD-ROM do Visual Studio contém arquivos de símbolos para versões do Windows

selecionadas.
• O CD-ROM de ferramentas de suporte do sistema operacional contém arquivos de
símbolos para Windows 2000 e Windows XP.
• Você pode baixar os símbolos mais recentes para sua versão do Windows em
http://www.microsoft.com/whdc/ddk/debugging/symbolpkg.mspx#Windows symbol packages.

• Você pode baixar símbolos automaticamente a partir do Microsoft symbol server em
http://msdl.microsoft.com/download/symbols ou de um servidor local de símbolos que esteja
configurado em sua intranet.
(http://msdl.microsoft.com/download/symbols é para download de símbolos somente. Não é
navegável.)
Para obter detalhes, consulte Usando um servidor de símbolos.
• O fornecedor de terceiros pode tornar os símbolos disponíveis.
Depuração de projetos DLL

Vários modelos de projeto do Visual Studio criam DLLs, que são depurados de forma diferente de
aplicativos autônomos. A depuração de DLLs é muito semelhante a depuração de aplicativos
autônomos.
Os seguintes modelos criam DLLs:
• (C++): MFC ActiveX Control

Controles ActiveX são controles que podem ser baixados através da Internet para um
computador cliente, e exibidos e ativados em páginas da Web.
A depuração deles é semelhante a depuração de outros tipos de controles em que não é
possível executar como autônomo, mas devem ser incorporados em uma página da Web em
HTML. Para obter mais informações, consulte Como depurar um controle ActiveX:.
• (C++): MFC DLL
Para obter mais informações, consulte Técnicas de depuração MFC.
• (C++): MFC ISAPI Extension DLL
• (C++): ATL Project
Para obter mais informações, consulte Técnicas de depuração atl.
• (C++): Class Library
• (C++): Windows Control Library
A depuração de uma biblioteca de controles do Windows é semelhante a depuração de um
projeto de biblioteca de classes. Na maioria dos casos, você chamará o controle do Windows a
partir de outro projeto. Quando você depurar o projeto de chamada, você pode entrar em
código do seu controle do Windows, definir pontos de interrupção, e realizar outras operações
de depuração. Para obter mais informações, consulte Controles de Formulários Windows.
• (C#, J#, and Visual Basic): Class Library
• (C#, J#, and Visual Basic): Windows Control Library
• (C#, J#, and Visual Basic): Web Control Library
Para obter mais informações, consulte Web Control Library (Código Gerenciado).
Esta seção também contém informações sobre os seguintes tópicos:
• Como depurar do um Project DLL:

• HOW TO: Depurar no modo misto
Este tópico contém as seções a seguir, que fornecem considerações sobre a preparação para
depurar bibliotecas de classes:

• Building a Debug Version
• Mixed-Mode Debugging
• Changing Default Configurations
• Ways to Debug the DLL
• The Calling Application
• Controls on a Web Page
• The Immediate Window
Criando uma versão de depuração
Não importa como você inicie a depuração, certifique-se de criar a versão de depuração da DLL
primeiro e certifique-se que a versão de depuração está no local onde o aplicativo espera localizá-
lo. Isso pode parecer óbvio, mas se você esquecer desta etapa, o aplicativo pode localizar uma
versão diferente da DLL e carregá-la. O programa então continuará a ser executado, enquanto
você fica imaginando por que o ponto de interrupção nunca foi atingido. Quando você estiver
depurando, você pode verificar quais DLLs seu programa carregou abrindo o depurador na janela
Modules. A janela Modules lista cada DLL ou EXE carregados no processo que você está
depurando. Para obter mais informações, consulte Como: Usar a Janela Módules (Módulos).
Para o depurador anexar a códigos escritos em C++, o código precisa emitir

DebuggableAttribute. Você pode adicionar isso ao seu código automaticamente por meio da
vinculação com a opção de linker /ASSEMBLYDEBUG.
Modo misto de depuração
O aplicativo que chama sua DLL pode ser escrito em código gerenciado ou código nativo. Se a
DLL gerenciada é chamado pelo código nativo e você precisar depurar ambos, os depuradores
gerenciado e nativo devem ambos estar habilitados. Você pode verificar isso na caixa de diálogo
ou janela <Project> Property Pages. Como fazer isso depende de como você iniciou a
depuração do projeto de DLL ou o projeto do aplicativo que chama. Para obter mais informações,
consulte HOW TO: Depurar no modo misto.
Alterando configurações padrão
Quando você cria um projeto de aplicativo console com o modelo de projeto, o Visual Studio cria
automaticamente as configurações necessárias para as configurações Debug e Release. Se
necessário, você pode alterar essas configurações. Para obter mais informações, veja
Configurações do projeto para uma configuração de depuração no Visual Basic, Configurações do
projeto para um C++ depurar configuração, Configurações de projeto para depurar C# e J# e
HOW TO: definir depuração e configurações de versão.
Maneiras de depurar a DLL
Cada um dos projetos nesta seção cria uma DLL. Não é possível executar uma DLL diretamente;
ela deve ser chamada por um aplicativo (geralmente um EXE). Para obter mais informações,
consulte Criando e gerenciando projetos Visual C++. O aplicativo de chamada pode:
• Ser criado em outro projeto na mesma solução Visual Studio que contém a biblioteca de
classes.
• Um programa existente já implantado em um computador de teste ou produção.
• Ser localizado na Web e acessado através de um URL.
• Ser um aplicativo da Web que contém uma página da Web que incorpore a DLL.

Depurando o aplicativo de chamada
Para depurar uma DLL, inicie depurando o aplicativo de chamada, geralmente um executável ou
um aplicativo da Web. Há várias maneiras para depurar.
• Se você tiver um projeto para o aplicativo de chamada, você pode abrir esse projeto e
começar a execução a partir do menu Debug. Para obter mais informações, consulte Como
iniciar execução:.
• Se o aplicativo de chamada é um programa existente já implantado em um computador de
teste ou produção e já está sendo executado você pode anexar a ele. Use este método se a
DLL for um controle hospedado pelo Internet Explorer, ou um controle em uma página da Web.
Para obter mais informações, consulte Como: Anexar a um Processo em Execução:.
• Você pode depurá-la a partir do projeto de DLL. Para obter mais informações, consulte
Como depurar do um Project DLL:.
• Você pode depurá-la a partir da janela Visual Studio Immediate: neste caso a janela
Immediate atua no papel de aplicativo.
Antes de iniciar a depuração do aplicativo de chamada, você geralmente desejará definir um

ponto de interrupção na biblioteca de classes. Para obter mais informações, consulte Pontos de
interrupção e Tracepoints. Quando o ponto de interrupção é alcançado, você pode depurar o
código, observando a ação em cada linha, até que você isole o problema. Para obter mais
informações, consulte Código Overview Stepping.
Controles em uma página da Web
Para depurar um controle de página da Web, crie uma página ASP.NET que o incorpore, se essa
página já não existir. Você então coloca pontos de interrupção no código da página da Web, bem
como no código do controle. Você então chama a página da Web do Visual Studio.
Antes de iniciar a depuração do aplicativo de chamada, você geralmente desejará definir um

ponto de interrupção na DLL. Quando o ponto de interrupção é alcançado, você pode depurar o
código, observando a ação em cada linha, até que você isole o problema. Para obter mais
informações, consulte Pontos de interrupção e Tracepoints e Código Overview Stepping.
A janela Immediate
Você pode avaliar funções ou métodos na DLL sem ter um aplicativo de chamada, fazendo
depuração em tempo de design utilizando a janela Immediate. Para depurar dessa forma, faça o
seguinte enquanto o projeto DLL está aberto:
1. Abra a janela Immediate do depurador.

2. Para testar um método denominado Test na classe Class1, instancie um objeto do tipo
Class1, digitando o código C# a seguir na janela Immediate, esse procedimento funciona
para outras linguagens gerenciadas (C++, VB, J#,) com alterações de sintaxe apropriadas:
Class1 obj = new Class1();
Em C#, todos os nomes devem ser totalmente qualificados. Além disso, quaisquer métodos
ou variáveis devem estar no escopo atual e no contexto da sessão de depuração.
3. Supondo que Test usa um parâmetro int, avalie Test utilizando a janela Immediate:
?obj.Test(10)
O resultado será impresso na janela Immediate.

4. Você pode continuar a depuração de Test colocando um ponto de interrupção dentro dele e
depois avaliando a função novamente:
?obj.Test(10);
O ponto de interrupção será atingido e você poderá andar pelo código Test. Depois da
execução deixar Test, o depurador estará novamente no modo de design.
Preparação da depuração: Projetos de console

A preparação para depurar um projeto de console é semelhante a preparação para depurar um
projeto do Windows, com algumas considerações adicionais. Para obter mais informações, veja
Depuração preparação: Applications formulários Windows (.NET) e Preparação para depuração:
Aplicativos de Windows Forms. Devido à semelhança de todos os aplicativos de console, este
tópico aborda os seguintes tipos de projeto:
• Aplicativo de console do C#
• Aplicativo de console do Visual Basic
• Aplicativo de console do J#
• Aplicativo de console do C++ (.NET)
• Aplicativo de console do C++ (Win32)
Você talvez precisará especificar os argumentos para seu aplicativo de console na linha de
comando. Para obter mais informações, consulte Configurações do projeto para um C++ depurar
configuração, Configurações do projeto para depurar a configuração no Visual Basic , ou
Configurações de projeto para depurar C# e J#.
Como todas as propriedades do projeto, esses argumentos persistem entre as sessões de

depuração e entre as sessões do Visual Studio. Então, se o console da aplicação foi debugado
anteriormente, lembre-se que talvez alguns argumentos de sessões anteriores foram adicionados
na caixa de diálogo <Project> Property Pages.
Um aplicativo de console usa a janela Console para aceitar uma entrada e para exibir mensagens
de saída. Para escrever na janela Console, o aplicativo deve usar o objeto Console em vez do
objeto Debug. Para escrever na janela Visual Studio Output, use o objeto Debug como de
costume. Verifique se você sabe onde o aplicativo está gravando ou você pode estar procurando
por mensagens no lugar errado. Para obter mais informações, consulte Classe console, Depurar a
classe e Janela de saída.
Quando estiver depurando um aplicativo de console, convém iniciar o aplicativo do prompt de

comando e não da Visual Studio. Nesse caso, você pode iniciar o aplicativo do prompt de
comando e conectar o depurador do Visual Studio a ele. Para obter mais informações, consulte
Anexando a processos em execução.
Quando você inicia um aplicativo do Visual Studio, a janela Console às vezes aparece por trás da
janela Visual Studio. Se você tentar de iniciar seu aplicativo de console do Visual Studio, e nada
parece acontecer, tente mover a janela Visual Studio.
Preparação de Depuração: Tipos de Projeto do Visual C++

Esta seção descreve como depurar os tipos de projeto básico criados pelos modelos de projeto
Visual C++.

Observe que esses tipos de projeto que criam DLLs como sua saída estão sendo agrupados em
Depuração de projetos DLL devido aos recursos comuns que eles compartilham.
Dois tipos de projeto do Visual C++ (ATL Server Web Service e ATL Server Projects) estão
incluídos na Aplicativos da Web depuração preparação: porque as técnicas de depuração usadas
com eles têm mais em comum com aplicativos da Web.
Preparação da Depuração: Configurações de Propriedades

Recomendáveis
Certas propriedades devem ser definidas da mesma maneira para todos os cenários de
depuração não gerenciados.
As tabelas a seguir exibem configurações de propriedades recomendadas.
Configurações não listadas aqui podem variar entre os tipos diferentes de projetos não
gerenciados.
Propriedades de Configuração | C/C++ | Nó de Otimização
Property
Name Setting
Optimization Defina como Disabled (/0d). O código otimizado é mais difícil para depurar,
porque as instruções geradas não correspondem diretamente ao seu código fonte.
Se você encontrar o programa que possui um erro que aparece somente no
código otimizado, você pode ativar esta configuração, mas lembre que o código
mostrado na janela Disassembly é gerado de fonte otimizada que pode não
corresponder ao que você vê nas suas janelas de origem. Outros recursos, como
depuração, podem não se comportar conforme o esperado.
Propriedades de Configuração | Vinculador |Nó de Depuração
Property Name Setting
Generate Você deve sempre definir esta opção para Yes (/DEBUG) para criar arquivos
debugging necessários para depuração e símbolos de depuração. Quando o aplicativo
information entra em produção, você pode definir ela como off.
Depuração preparação: Applications formulários Windows

(.NET)
O modelo de aplicativo Windows Forms (.NET) cria um aplicativo Visual C++ de Windows Forms.
Para obter mais informações, consulte How to: Create a Windows Application Project.
A depuração desse tipo de aplicativo no Visual Studio é semelhante ao de aplicativos gerenciados

Windows Forms.
Quando você cria um projeto Windows Forms com o modelo de projeto, o Visual Studio cria
automaticamente as configurações necessárias para Debug e Release. Se necessário, você pode
alterar essas configurações na caixa de diálogo <project name> Property Pages. Para obter
mais informações, consulte Configurações para Debug e Release.
Para obter mais informações, consulte Alterando as configurações de projeto para depuração C
ou C++.
Outra maneira de depurar um aplicativo de Windows Forms consiste em iniciar o aplicativo fora do
Visual Studio e anexar a ele. Para obter mais informações, consulte Anexando a um programa em
execução ou a vários programas.
Para configurações de projeto recomendadas, consulte Preparação da Depuração: Configurações

de Propriedades Recomendáveis.
Para depurar um aplicativo de Windows Forms do Visual C++

1. Abra o projeto no Visual Studio.
2. No menu Debug, clique em Start.
3. Depure usando as técnicas discutidas em Usando o depurador.
Projetos Win32 depuração preparação:

Aplicativos Win32 são programas tradicionais Windows escritos em C ou C++. A Depuração desse
tipo de aplicativo no Visual Studio é simples.
Aplicativos Win32 incluem aplicativos MFC e projetos ATL. Eles usam APIs Windows e podem
usar MFC ou ATL, mas não usam Common Language Runtime (CLR). No entanto, eles podem,
chamar código gerenciado que usa o CLR.
O procedimento a seguir explica como depurar um projeto Win32 a partir do Visual Studio. Outra
maneira para depurar um aplicativo Win32 consiste em iniciar o aplicativo fora do Visual Studio e
anexá-lo. Para obter mais informações, consulte Anexando a processos em execução.
Para depurar um aplicativo C ou C++ Win32

2. No menu Debug, escolha Start.
3. Depuração usando as técnicas discutidas no Explicação detalhada sobre o depurador.
Quando você cria um projeto do Windows Application com o assistente, o Visual Studio cria
automaticamente configurações necessárias para as configurações Debug e Release. Se
necessário, você pode alterar essas configurações. Para obter mais informações, consulte
HOW TO: definir depuração e configurações de versão.
Para definir uma configuração Debug manualmente
1. No menu View, clique em Property Pages.
2. Clique no nó Configuration Properties para abri-lo se ele não estiver aberto.
3. Selecione General, e defina o valor da linha Output para Debug.
4. Abra o nó C/C++, e selecione General.
Na linha Debug você especifica o tipo de informações de depuração a ser gerado pelo
compilador. Você pode escolher os valores que incluem Program Database (/Zi) ou
Program Database for Edit & Continue (/ZI).
5. Selecione Optimization, e na linha Optimization, selecione Disabled (/0d) da lista
suspensa.
Código otimizado é mais difícil de depurar, desde que as instruções geradas não
correspondam diretamente às de seu código fonte. Se você encontrar um erro no seu
programa que aparece somente no código otimizado, você pode ativar esta configuração,

mas lembrar que o código mostrado na janela Disassembly foi gerado de fonte otimizada
que pode não corresponder ao que você vê nas suas janelas de origem. Recursos, tal como
depuração provavelmente mostram pontos de interrupção e ponto de execução
incorretamente.
6. Abra o nó Linker, e selecione Debugging. Na primeira linha Generate, selecione Yes
(/DEBUG) na lista drop-down. Sempre defina isto quando você estiver depurando.
Para obter mais informações, consulte Configurações do projeto para um C++ depurar
configuração.
Preparação da Depuração: Web Services XML (C++)

Quando você cria um serviço XML da Web com o Visual C++, Visual Studio cria o padrão de
configurações do projeto para depuração. Quando você escolhe o Start a partir do menu Debug
essas configurações podem causar que o Visual Studio inicie o navegador selecionado na
<Project> Properties Pages e gere dinamicamente uma página de teste. Na página de teste,
você pode digitar comandos e observar os dados que são retornados pelo serviço XML da Web
Observação
Para o depurador anexar o código C++ compilado com o /clr, o código precisa emitir
DebuggableAttribute. Você pode adicionar isso para que seu código automaticamente por meio
da vinculação com a opção /ASSEMBLYDEBUG do vinculador.
Depuração de uma chamada para o serviço XML da Web de um aplicativo cliente
Quando um aplicativo cliente chama um serviço XML da Web, o depurador se anexa ao aplicativo
cliente e o processo ASP.NET, Aspnet_wp.exe, e o controle de chamadas SOAP, após a cadeia
da pilha de chamadas para o processo do serviço XML da Web.
Para obter mais informações, consulte Serviços XML da Web no código gerenciado.
Alterando as configurações padrão
Quando você cria um projeto Serviço XML da Web com o modelo de projeto, o Visual Studio cria
automaticamente as configurações necessárias para as configurações de Debug e Release. Se
necessário, você pode alterar essas configurações. Para obter mais informações, consulte
Alterando as Configurações do Projeto para configurações de debug no C ou C++ e
Configurações de Debug e Release.
Preparação para depuração: tipos de projeto C#, J# e Visual

Basic
Os tópicos nesta seção descrevem como depurar os tipos de projeto C# e Visual Basic criados
pelos modelos de projeto do Visual Studio.
Observe que aqueles tipos de projeto que criam DLLs como saída são agrupados em Depuração
de projetos DLL devido aos recursos comuns que eles compartilham.
Aplicativos da Web depuração preparação:

Esta seção descreve como depurar os tipos de projeto básicos criados pelos modelos de projeto
paras sites da Web.
Dois dos tipos de projeto (ATL Server Web Service e ATL Server Projects) são na verdade tipos
Visual C++, mas são incluídas aqui porque as técnicas de depuração usadas com eles têm mais
em comum com aplicativos da Web.
Preparação para depuração : Aplicativos ASP.NET da Web

O modelo ASP.NET de Site da Web cria um aplicativo de formulário da Web. Quando você cria
um site da Web usando esse modelo, Visual Studio cria as configurações padrão para depuração.
Na caixa de diálogo Project Properties, você pode especificar se deseja que página da Web seja
uma página de inicialização. Quando você inicia a depuração um ASP.NET site da Web com
essas configurações padrão, Visual Studio inicia o Internet Explorer e anexa o depurador ao
processo ASP.NET de trabalho (Aspnet_wp.exe ou W3wp.exe). Para obter mais informações,
consulte Requisitos do sistema ASP.NET depuração:.
Para criar um aplicativo de formulários da Web

1. No menu File, escolha New Web Site.
2. Na caixa de diálogo New Web Site, selecione ASP.NET Web Site.
3. Clique em OK.
Para depurar o seu formulário da Web
1. Defina um ou mais pontos de interrupção nas suas funções e manipuladores de eventos.
Para obter mais informações, consulte Pontos de interrupção e Tracepoints.
2. Quando um ponto de interrupção é pressionado, depure código dentro a função,
observando a execução do seu código até que você isole o problema.
Para obter mais informações, consulte Código Overview Stepping e Depurar aplicativos da
Web.
Alterando configurações padrão
Caso você precise alterar a depuração padrão e configurações de versão criadas por Visual
Studio, poderá fazer isso. Para obter mais informações, consulte HOW TO: definir depuração e
configurações de versão.
Para alterar a configuração de depuração padrão
1. Clique com o botão direito do mouse no site da web no Solution Explorer, e selecione
Property Pages para abrir a caixa de diálogo Property Pages.
2. Clique em Start Options.
3. Defina Start Action como a página da Web que primeiro deve ser exibida.
4. Em Debuggers, certifique-se de que ASP.NET debugging é verificada.
Para obter mais informações, consulte Configurações de Property Pages para Projetos da
Web.
Projetos Serviço da Web XML depuração preparação:

O modelo de projeto de XML Web Services cria as configurações de projeto padrão para a
depuração. Para obter mais informações, consulte COMO: Criar Projetos de Serviço da Web
ASP.NET.

Também é necessário configurar o arquivo web.config para ativar a depuração. Isso pode ser
configurado manualmente ou automaticamente. Para obter mais informações, consulte Como
ativar depuração para aplicativos ASP.NET:.
Para iniciar a depuração, escolha Start no menu Debug. Se você não ativou manualmente a
depuração, a caixa de diálogo Debugging Not Enabled será exibida, o que lhe dará a opção de
ter um arquivo web.config automaticamente criado com depuração ativada, ou executando sem
depuração. Depois de esta caixa de diálogo fechar, as configurações de projeto fazem com que o
Visual Studio inicie o navegador selecionado em <Project> Properties Pages e gere
dinamicamente uma página de teste. Na página de teste, você pode digitar comandos e observar
os dados que são retornados pelo seu XML Web Services.
Depuração de um XML Web Services de um aplicativo cliente
Há dois métodos para depurar um XML Web Services de um aplicativo cliente.
Para depurar por um aplicativo cliente e servidor Web XML (método 1)
1. No Visual Studio, crie um novo projeto de XML Web Services.

Para obter mais informações, consulte COMO: Criar Projetos de Serviço da Web ASP.NET.
2. No menu Debug, clique em Start para executar o XML Web Services.
Esta etapa não somente permite que você teste se o serviço da Web está funcionando,
como também cria o arquivo web.config, que é necessário para a depuração.
3. No menu Debug, clique em Stop Debugging.
4. Crie um projeto de aplicativo cliente na mesma solução que seu projeto de XML Web
Services. Para fazer isso, no menu Debug, clique em Add New Project.
5. No Solution Explorer, clique com o botão direito do mouse no projeto do cliente e clique
em Properties no menu de atalho.
6. Na janela Solution <Name> Properties, abra o nó Common Properties e selecione
Startup Project.
7. Clique em Multiple Startup Projects.
8. Em Multiple Startup Projects, vá para a coluna Action e defina a ação como Start para
ambos os projetos.
9. Clique em OK para fechar a janela Solution <Name> Properties.
10. No menu Debug, clique em Start para depurar o aplicativo cliente e o servidor Web XML.
Para depurar passando de um aplicativo cliente para um servidor Web XML
1. No Visual Studio, crie um novo projeto de XML Web Services.

Para obter mais informações, consulte COMO: Criar Projetos de Serviço da Web ASP.NET.
2. No menu Debug, clique em Start para executar o XML Web Services.
Esta etapa não somente permite que você teste se o serviço da Web está funcionando,
como também cria o arquivo web.config, que é necessário para a depuração.
4. Crie um projeto de aplicativo cliente, na mesma solução que seu projeto de XML Web
Services ou em uma solução diferente.
5. Em seu projeto do cliente, adicione uma referência da Web e uma chamada síncrona para
o serviço da Web.

6. No Solution Explorer, clique com o botão direito do mouse no projeto do cliente e clique
em Set As Startup Project no menu de atalho.
7. No menu Debug, clique em Start para executar o aplicativo cliente.
Quando o aplicativo cliente chama o XML Web Services, o depurador automaticamente
entra e inicia a depuração do XML Web Services.
Preparação para depuração: Serviços da Web ATL Server

O projeto ATL Server Web Services oferece uma maneira fácil de gerar aplicativos XML Web
services que usam ATL Server, um conjunto de classes não gerenciadas de C++ projetadas para
tais aplicativos.
A depuração de um aplicativo de serviços da Web ATL Server é muito semelhante à depuração de

um aplicativo Win32, com alguns fatores adicionais a serem considerados.
Serviços da Web ATL Server são implementados como extensões ISAPI.
Preparação para depuração: Projetos ATL Server

O Projeto ATL Server oferece uma maneira fácil de gerar aplicativos da Web que usam ATL
Server, um conjunto de classes C++ projetadas para tais aplicativos não gerenciados.
Depurando um aplicativo ATL Server é muito semelhante a depurar um aplicativo Win32, com
alguns fatores adicionais a serem considerados.
Aplicativos ATL Server são implementados como extensões ISAPI. Para obter mais informações,
consulte Técnicas de depuração atl.
Como depurar uma parte de uma solução Visual Studio não executável:
Às vezes, convém depurar um executável que não faz parte de um projeto Visual Studio . Pode
ser um executável criado por você fora do Visual Studio ou um executável que você recebeu de
outra pessoa.
A resposta normal para este problema é iniciar o executável fora do Visual Studio e anexar a ele
usando o depurador Visual Studio. Para obter mais informações, consulte Anexando a processos
em execução.
Anexar a um aplicativo requer algumas etapas manuais, portanto leva alguns segundos. Esse
pequeno atraso significa que anexar não ajudará se você estiver tentando depurar um problema
que ocorre durante a inicialização. Além disso, se você estiver depurando um programa que não
espera uma entrada de usuário e termina rapidamente, você pode não ter tempo para anexar a
ele. Se você tiver o Visual C++ instalado, você pode criar um projeto EXE para esse programa.
Para criar um projeto EXE para um executável existente

1. No menu Open, clique em File e selecione Project.
2. Na caixa de diálogo Open Project, clique na seta Files of type, e selecione Executable
Files.
3. Localize o executável, e clique em OK.
Isso cria uma solução temporária que contém o executável.
Como alternativa, você pode importar um executável para uma solução Visual Studio
existente.

Para importar um executável para uma solução Visual Studio
1. No menu File, clique em Add Project e, em seguida, clique em Existing Project.
2. Na caixa de diálogo Add Existing Project, localize e selecione o executável.
3. Clique em OK.
4. Inicie o executável, escolhendo um comando de execução, como Start, no menu Debug.
Observação
Nem todas as linguagens de programação oferecem suporte a projetos EXE. Instale o Visual C++
se você precisar usar este recurso.
5. Quando você estiver depurando um executável sem o código fonte, os recursos de

depuração disponíveis são limitados, anexando a um executável em execução ou
adicionando o executável a uma solução Visual Studio. Se o executável foi criado sem
informações de depuração em um formato compatível, os recursos disponíveis serão mais
limitados. Se você tiver o código fonte, a melhor abordagem é importar o código-fonte no
Visual Studio e criar um compilação para depuração do executável no Visual Studio.
Instalação de depuração remota

Visual Studio Edition Visual Basic C# C++ J# Web Dev
Express Edition Não Não Não Não Não
Standard Edition Não Não Não Não Não
Pro/Team Edition Sim Sim Sim Sim Sim
Visual Studio oferece suporte remoto de depuração de uma máquina para outra. Quando você
estiver realizando depuração remota, o computador host pode ser qualquer plataforma que
oferece suporte Visual Studio. O computador remoto pode ser uma plataforma 32 bits (Windows
98/Me, Windows 2000, Windows XP ou Windows Server 2003) ou 64 bit (IA64, IA64 modo WOW,
x64 ou x64 modo WOW).
Como: Depurar com Fonte Premium do Centro do Código
Com o depurador do Visual Studio, você pode depurar fonte compartilhada segura do Microsoft
MSDN Code Center Premium.
Este tópico explica como configurar e depurar o código fonte Code Center Premium no Visual
Studio.
Para configurar o centro de código premium

1. Insira seu cartão Code Center Premium no leitor SmartCard conectado ao seu
computador.
2. Insira o Code Center Premium Welcome Kit CD na unidade de CD-ROM.

3. Se o disco não Autorun, localize e execute o arquivo de instalação:
Bem-vindo Kit CD\Source Code\CDROM_FILES\install.exe
4. Para procurar fonte Code Center Premium, inicie o Internet Explorer e digite:
https://codepremium.msdn.microsoft.com
5. Navegue até localizar o código fonte que deseja.
Para depurar a fonte do código central premium
1. Especifique um diretório local para a fonte compartilhada segura Code Center Premium,
conforme descrito abaixo.
2. Inicie o Visual Studio.
3. A partir do menu Tools, escolha Options.
4. Na caixa de diálogo Options, abra o nó Debugging e selecione Symbols.
5. Na caixa Symbol File Locations, adicione o seguinte local:
https://codepremium.msdn.microsoft.com/symbols
6. Na caixa Cache symbols from symbol servers in this directory, digite um local onde
Code Center Premium pode armazenar símbolos. Por exemplo:
c:\symbols
Se você anteriormente tiver armazenado símbolos no mesmo local, talvez não precise
limpar o cache, o qual pode conter versões mais antigas dos símbolos sem informações
Code Center Premium.
8. No Solution Explorer, clique com o botão direito do mouse no nome da solução e escolha
Properties a partir do menu de atalho.
9. Na caixa de diálogo Solution Property Pages, abra o nó de propriedades comuns e
selecione Debug Source Files.
10. Entre na caixa Directories containing source code, digite o local do código fonte Code
Center Premium. Você pode localizar a origem por navegação
https://codepremium.msdn.microsoft.com no Internet Explorer, copiando o local de sua barra
de endereços do Internet Explorer.
O local que você digita deve ser como este:
https://codepremium.msdn.microsoft.com/Source/windows XP/SP1
(Este exemplo é para código fonte Windows XP SP1.)
11. Clique em OK.
12. Quando você começar a depuração fonte Code Center Premium e o depurador inserir o
modo de interrupção, uma caixa de diálogo solicita que você digite o número SmartCard
PIN.
13. Digite o número PIN que você recebeu com o Code Center Premium Welcome Kit.
O depurador baixa a fonte Code Center Premium.
Especificando o Diretório Local para Code Center Premium Source
Antes que você possa depurar a Code Center Premium secure shared source, você deve
especificar um diretório local para a fonte em sua máquina. Você pode alterar este local, editando
uma chave do registro.
Para alterar o diretório local padrão para code center premium source

1. Saia do Visual Studio, se ele estiver sendo executado.
2. No prompt de comando do Windows, digite:
regedt32
3. Na janela Registry Editor , abra:

HKEY_CURRENT_USER\Software\MSFT\VisualStudio\8.0\Debugger
4. Na coluna Name, clique duas vezes em SecureSourceLocalDirectory.
5. Edite a Value data (inicialmente uma seqüência vazia) para o local desejado para usar
como um diretório local.
Se você alterar as configurações IDE do Visual Studio, você pode precisar repetir este
processo.
Como: Depurar um aplicativo de confiança parcial
Visual Studio Edition Visual Basic C# C++ J#
Express Sim Sim Não Sim
Padrão Sim Sim Não Não
Pro / Team Sim Sim Não Sim
Se aplica a aplicações Windows e de console. Não é válido para dispositivos inteligentes.
Implantação de ClickOnce torna fácil de implantar aplicativos parcialmente confiáveis que se

beneficiam de Code Access Security para limitar o acesso a recursos em uma máquina.
Depurar um aplicativo confiança parcial-pode ser um desafio, aplicativos de confiança parcial tem
diferentes permissões de segurança (e portanto tem um comportamento diferente) dependendo da
onde eles estão instalados. Se instalado a partir da Internet, um aplicativo com confiança parcial
terá algumas permissões. Se instalado de uma intranet local, terá mais permissões, e se instalado
no computador local, ela terá permissões totais. Você também pode ter personalizado zonas, com
permissões personalizadas. Convém depurar um aplicativo com confiança parcial em qualquer ou
todas essas condições. Felizmente, Visual Studio facilita isso também.
Antes de iniciar uma sessão de depuração no Visual Studio, você pode escolher a zona que você
deseja simular um aplicativo instalado. Quando você iniciar a depuração, o aplicativo terá
permissões apropriadas para um aplicativo com confiança parcial instalado a partir dessa zona.
Isso permite que você veja o comportamento do aplicativo como ele apareceria a um usuário que
baixou ele da zona.
Se o aplicativo tenta executar uma ação que não tem permissão, ocorrerá uma exceção. Nesse
momento, o assistente de exceção oferece a oportunidade de adicionar uma permissão extra que
permite você reiniciar a sessão de depuração com permissões suficientes para evitar o problema.
Posteriormente, você poderá voltar atrás e consultar quais permissões você adicionou durante a
depuração. Se você teve que adicionar uma permissão durante a depuração, provavelmente isso
indica que você precisará adicionar um User Consent Prompt nesse ponto no seu código.

Observação
Visualizadores do depurador exigem maior privilégios que são permitidos por um aplicativo
parcialmente confiável. Visualizadores não serão carregados quando você está parado no código
com confiança parcial. Para depurar usando um visualizador, você deve executar o código com
confiança total.
Para escolher uma zona para seu aplicativo com confiança parcial
1. No menu Project escolha Projectname Properties.
2. Nas páginas da propriedade Projectnameclique na página Security.
3. Selecione Enable ClickOnce Security Settings.
4. Em Zone your application will be installed from, clique na caixa de listagem e escolha a
zona que você deseja simular o aplicativo que está sendo instalado.
A grade Permissions required by the application mostra todas as permissões
disponíveis. A marca de seleção indica permissões concedidas ao seu aplicativo
5. Se a zona que você escolher for (Custom), selecione correto as configurações
personalizadas na coluna Setting da grade Permissions.
6. Clique OK para fechar as páginas de propriedades.
Para adicionar uma permissão extra quando uma exceção de segurança ocorre
1. A caixa de diálogo Exception Assistant será exibida com a mensagem: SecurityException
was unhandled.
2. Na caixa de diálogo Exception Assistant em Actions, clique em Add Permission to the
Project.
3. A caixa de diálogo Restart Debug será exibida.
o Se você desejar reiniciar a sessão de depuração com a nova permissão, clique em
Yes.
o Se você não desejar reiniciar ainda, clique em No.
Para exibir as permissões adicionadas durante a depuração extra
1. No menu Project escolha Projectname Properties.
2. Nas páginas de propriedades Projectname clique na página Security.
3. Procure na grade Permissions required by the application. Qualquer permissão extra
que você adicionou possui dois ícones na coluna Included: a marca de seleção normal, que
todas permissões incluídas possuem e um ícone adicional que parece com um balão
contendo a letra " i ".
4. Use a barra de rolagem vertical para exibir a grade inteira Permissions required by the
application.
Como: depurar um aplicativo de cluster remoto

Pro / Team Não Não Sim Não Não
O Visual Studio agora oferece suporte a depuração de cluster MPI. Esse recurso permite que você
depure programas paralelos executados em um cluster de computadores que se comunicam
através da Message Passing Interface (MPI).
Pré-requisitos para depuração MPI
• A MPI deve ser instalada e configurada em cada máquina no cluster. A MPI está incluída
no Windows Server 2003, Compute Cluster Edition. Outras implementações da MPI estão
disponíveis.
• O MPIShim.exe deve ser instalado em cada máquina no cluster. MPIShim está incluído no
Visual Studio 2005 e é instalado com os componentes de depuração remota para ativar a
depuração paralela. O MPIShim pode ser instalado em qualquer diretório, mas deve estar no
mesmo diretório em cada máquina no cluster. Um caminho possível é:
c:\windows\system32\mpishim
Como alternativa, ele pode ser instalado em um diretório local ao alvo de depuração.
• O Remote Debugging Monitor (msvsmon) deve estar em cada máquina no cluster.
Consulte Como: executar o monitor de depuração remota:.
• O hospedeiro do Visual Studio (o computador de onde você está depurando) deve ser
configurado com uma conta que tenha os privilégios apropriados para depurar os
computadores do cluster. (Consulte Permissões de depuração remota.)
Para preparar um projeto do Visual Studio para depuração MPI
1. Abra a solução que contém o aplicativo paralelo no Visual Studio.
2. No Solution Explorer, clique com o botão direito do mouse no projeto e escolha
Properties a partir do menu de atalho.
3. Na caixa de diálogo Project Properties , selecione Debugging.
4. Na caixa de listagem Debugger to Launch, escolha MPI Cluster Debugging.
5. Na caixa MPIRun command, digite a localização do MPIRun ou MPIExec (que inicia o
aplicativo MPI) na máquina do cluster. Por exemplo:
c:\windows\system32\mpiexec.exe
6. Na caixa MPIRun arguments, digite os argumentos que você deseja passar para MPIRun
ou MPIExec. Por exemplo:
-np 2
7. Na caixa MPIRun working directory, digite a pasta de trabalho para MPIRun ou MPIExec.
Por exemplo:
c:\temp
8. Na caixa Application Command, digite o caminho para o aplicativo que o MPI irá executar
em cada máquina cluster (que é também o aplicativo cujo projeto está aberto no Visual
Studio). O caminho pode ser um compartilhamento ou um caminho local em cada máquina
no cluster. Se ele for um caminho local, o caminho deve ser idêntico em cada máquina. Por
exemplo:
$(TargetPath)

9. Na caixa Application Arguments, digite quaisquer argumentos que você deseja passar
para o aplicativo.
10. Na caixa MPIShim location, digite o caminho para o MPIShim.exe. Por exemplo:
c:\windows\system32\mpishim
11. Você pode deixar a caixa de listagem Debugger Type definida como auto (o padrão) e o
depurador irá escolher o tipo de depurador correto para o código que está executando.
Como alternativa, você pode escolher o tipo correto (native, managed ou mixed code)
para seu aplicativo.
12. Feche a caixa de diálogo Project Properties.
14. Na caixa de diálogo Options, selecione o nó Debugging, categoria General.
15. Localize a caixa de seleção When one process breaks, break all other processes.
Marque ou desmarque a caixa de seleção de acordo com o comportamento desejado
durante a sessão de depuração. (Como essa é uma opção de Tools, essa configuração
permanecerá em vigor para todos os projetos até você alterá-la.) Para obter mais
informações, consulte Como interromper a execução:.
16. Clique OK para fechar a caixa de diálogo Options.
Para depurar o aplicativo paralelo
1. No menu Debug, clique em Start para iniciar a depuração.
Se você tiver configurado o projeto corretamente, o aplicativo começará executando em
todos os computadores no cluster.
Se você tiver definido pontos de interrupção no seu código, a execução interromperá no
primeiro ponto de interrupção.
2. No menu Debug, clique Windows, e clique em Processes.
A janela Processes. Você pode usar esta janela para definir um processo ativo. Para
passar somente pelo único processo ativo, use os botões na parte superior da janela.
Você pode usar DataTips para obter valores de variáveis enquanto estiver depurando um
aplicativo paralelo. Os valores de variáveis que você vê nas DataTips serão baseados no
processo ativo atual definido na janela Processes.
Como: Depurar Aplicativos de 64 bits:
Edição do Visual Studio Visual Basic C# C++ J#
Express Sim Sim Sim Não
Standard Sim Sim Sim Não
Pro / Team Sim Sim Sim Não
Você pode depurar um aplicativo de 64 bits que esteja executando no computador local ou em um
computador remoto com oVisual Studio 2005.

Se você estiver depurando localmente, o Visual Studio 2005 é executado no WOW64, o emulador
de 32 bits x86 que permite que que aplicativos de 32 bits do Windows sejam executados no
Windows 64-Bits.A depuração local no WOW64 é suportada somente no x64 .
Se você estiver depurando remotamente, o Visual Studio 2005 pode ser executado no WOW64 ou
em uma máquina de 32 bits. Você pode depurar tanto aplicativos do IA64 e do x64, bem como
aplicativos de 32 bits em execução no modo WOW do x64 ou em plataformas de 32 bits.
Para depurar um aplicativo de 64 bits que esteja executando em um computador remoto, você
precisará instalar o depurador remoto de 64 bits no computador remoto. O depurador remoto de
64 bits está disponível no último disco do seu conjunto instalação do Visual Studio 2005.
Se você depurar um aplicativo de 64 bits na máquina local, o Visual Studio 2005 usa depuração
remota para realizar a conexão entre o WOW64 e o aplicativo de 64 bits na mesma máquina. Para
obter mais informações, consulte Depuração na uma plataforma de 64 bits. Os componentes de
depuração remota serão instalados automaticamente quando você instalar o Visual Studio 2005
no computador.
Em ambos os casos, a instalação da depuração remota em uma máquina de 64 bits instala as

versões de 32 bits e 64 bits do Monitor de Depuração Remota. Para depurar um aplicativo de 64
bits, use a versão correta, que é Remote Debugger (x64) no menu Start.
A depuração do código de 64 bits é quase idêntica a depuração do código de 32-bits. No entanto,

existem duas diferenças:
• Editar e Continuar não estão disponíveis para a depuração de 64 bits.

• Você não pode depurar no modo misto, realizar chamadas de código nativo para código
gerenciado, ou vice-versa, no código de 64 bits.
Para iniciar o Monitor de Depuração Remota de 64 bits
1. Clique em Start, aponte para All Programs, aponte para Microsoft Visual Studio 2005,
aponte para Visual Studio Tools, e clique em Remote Debugger (x64) ou Remote
Debugger (IA64)
Ou-
No Command Prompt do Windows, execute o comando Install path\Microsoft Visual Studio
8\Common7\IDE\Remote Debugger\x64 ou o comando Install path\Microsoft Visual Studio
8\Common7\IDE\Remote Debugger\ia64.
2. Configure a Remote Debugging Monitor para depuração remota
o Para configurar a depuração remota no Windows Authentication mode, consulte
Como configurar modo Autenticação do Windows:.
o Para configurar a depuração remota, somente para código nativo, no No
Authentication mode, consulte Como: Configurar " sem autenticação " modo. O modo No
Authentication mode permite uma depuração mais rápida em redes lentas, mas ele não é
seguro e deve ser usado somente em redes seguras.
Depuração na uma plataforma de 64 bits


Express Sim Sim Sim Não
Standard Sim Sim Sim Não
Pro/Team Sim Sim Sim Não
O Visual Studio 2005 pode ser executado em uma plataforma de 64 bits x64 no WOW64, que é o
emulador de 32 bits x86 que permite que aplicativos do Windows de 32 bits sejam executados no
Windows de 64 bits. O Visual Studio 2005 não dá suporte a IA64 WOW. Você pode depurar um
aplicativo IA64, mas deve fazê-lo remotamente. (Consulte Como: Depurar Aplicativos de 64 bits:.)
Quando você executa o Visual Studio 2005 no modo WOW para depurar um aplicativo de 64 bits
na mesma máquina, o Visual Studio 2005 parece fazer depuração local normal. No entanto, o
Visual Studio 2005 está realmente usando o mecanismo de depuração remota para conectar-se
do WOW para o aplicativo de 64 bits. Portanto, todas as considerações que se aplicam à
depuração remota também se aplicam à depuração local em uma plataforma de 64 bits. Isso
significa que a janela do console externo não funciona em uma plataforma de 64 bits.
Para obter mais informações sobre como depurar aplicativos de 64 bits, consulte Como depurar
um despejo de aplicativos de 64 bits:.
Depuração e o processo Hosting

O processo de hospedagem do Visual Studio melhora o desempenho do depurador e permite
novos recursos do depurador, como depuração de confiança parcial e avaliação de expressões
em tempo de design. Você pode desativar o processo de hospedagem, caso você precise. Para
obter mais informações, consulte Como: Desativar o processo de hospedagem. As seções a
seguir descrevem algumas diferenças entre a depuração com e sem o processo de hospedagem.
Depuração de Confiança Parcial e Segurança de Click-Once
A depuração de confiança parcial requer o processo de hospedagem. Se você desativar o

processo de hospedagem, a depuração de confiança parcial não irá funcionar mesmo que esteja
ativada na página Security de Project Properties. Para obter mais informações, consulte Como:
Desativar o processo de hospedagem e Como: Depurar um aplicativo de confiança parcial.
Avaliação de Expressões em Tempo de Design
As expressões em tempo de design sempre utilizam o processo de hospedagem. Desativar o

processo de hospedagem na Project Properties desativa a avaliação de expressões em tempo
de design para projetos da Class Library. Para outros tipos de projeto, a avaliação de expressões
em tempo de design não é desativada. Em vez disso, o Visual Studio inicia o executável real e
utiliza a avaliação em tempo de design sem o processo de hospedagem. Essa diferença pode
produzir resultados diferentes.
Diferenças no AppDomain.CurrentDomain.FriendlyName
AppDomain.CurrentDomain.FriendlyName retorna resultados diferentes, dependendo se o processo

de hospedagem estiver ativado ou não. Se você chamar AppDomain.CurrentDomain.FriendlyName
com o processo de hospedagem ativado, ele retorna app_name.vhost.exe. Se você o chamar com
o processo de hospedagem desativado, será retornado app_name.exe.

Diferenças no Assembly.GetCallingAssembly().FullName
Assembly.GetCallingAssembly().FullName retorna resultados diferentes, dependendo se o processo

de hospedagem estiver ativado ou não. Se você chamar Assembly.GetCallingAssembly().FullName
com o processo de hospedagem ativado, ele retorna mscorlib. Se você chamar
Assembly.GetCallingAssembly().FullName com o processo de hospedagem desativado, será
retornado o nome do aplicativo.
Como: Especificar uma versão do .NET Framework para depuração
O depurador Visual Studio 2005 oferece suporte a depuração de versões mais antigas do .NET
Framework, bem como a versão 2.0 atual. Se você iniciar um aplicativo no Visual Studio, o
depurador sempre poderá identificar a versão correta do .NET Framework para o aplicativo que
você está depurando. Se o aplicativo já está sendo executado e você usar Attach to, o depurador
pode não ser capaz de identificar uma versão mais antiga do .NET Framework. Se isso acontecer,
você receberá uma mensagem de erro que diz,
O depurador fez uma suposição incorreta sobre a versão do Microsoft .NET Framework que seu
aplicativo estará usando.
Nesses casos raros, você pode definir uma chave do registro para indicar ao depurador a versão a
ser usada.
Para especificar uma versão do .NET Framework para depuração

1. Examine a pasta Windows\Microsoft .NET\Framework para localizar as versões do .NET
Framework instaladas no computador. O aspecto dos números de versão é algo assim:
V1.1.4322
Identifique o número da versão correta e tome nota dele.
2. Iniciar o Registry Editor (Regedit).
3. Na Registry Editor, abra a pasta HKEY_LOCAL_MACHINE.
4. Navegue até:
HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\8.0\AD7Metrics\Engine\{449EC4
CC-30D2-4032-9256-EE18EB41B62B
Se a chave não existir, clique com botão direito mouse
HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\8.0\AD7Metrics\Engine, e clique
em New Key no menu de atalho. Nomeie a nova chave {449EC4CC-30D2-4032-9256-
EE18EB41B62B}.
5. Após navegar até {449EC4CC-30D2-4032-9256-EE18EB41B62B}, procure na coluna
Name, e encontre a chave CLRVersionForDebugging.
1. Se a chave não existir, clique com o botão direito do mouse em {449EC4CC-30D2-
4032-9256-EE18EB41B62B}, e clique New String Value no menu de atalho. Então
clique o botão direito do mouse no novo valor, clique Rename, e digite
CLRVersionForDebugging.
6. Clique duas vezes em CLRVersionForDebugging.
7. Na caixa Edit String, digite o número de versão do .NET Framework na caixa Value. Por
exemplo: V1.1.4322
8. Clique em OK.
9. Feche o Registry Editor.
Se você ainda receber uma mensagem de erro quando você iniciar a depuração, verifique se
você inseriu o número da versão corretamente no registro. Também verifique se você está

usando uma versão do .NET Framework suportada pelo Visual Studio. O depurador é
compatível com o .NET Framework versão 2.0 e versões anteriores, mas pode não ser
diretamente compatível com versões futuras.
Explicação detalhada sobre o depurador

O depurador do Visual Studio é uma ferramenta poderosa que permite a você observar o
comportamento em tempo de execução do seu programa e localizar erros de lógica. O depurador
funciona com todas as linguagens de programação do Visual Studio e suas bibliotecas
associadas. Com o depurador você pode interromper, ou suspender, a execução do seu programa
para examinar seu código, avaliar e editar variáveis no seu programa, exibir registros, consultar as
instruções criadas no seu código fonte, e exibir espaço de memória usado pelo seu aplicativo.
Com a Edição e Continuação, você pode fazer alterações em seu código durante a depuração, e
depois continuar a execução.
O depurador do Visual Studio fornece um menu Debug para acesso a ferramentas do depurador.
As janelas e caixas de diálogo do depurador exibem informações sobre o programa e permitem a
você inserir informações adicionais. Você pode obter ajuda sobre qualquer janela ou caixa de
diálogo pressionando F1.
Depurando o código gerenciado

Esta seção aborda problemas comuns de depuração e técnicas para aplicativos gerenciados ou
aplicativos escritos em linguagens que visam Common Language Runtime, como Visual Basic,
C#, J#, e C++. As técnicas descritas aqui são técnicas de alto nível. Para obter mais informações,
consulte Visão geral sobre Common Language Runtime ou Usando o depurador.
Diagnóstico de mensagens na janela de saída

Você pode escrever mensagens em tempo de execução para a janela Output usando a classe
Debug ou a classe de Trace, que fazem parte da biblioteca de classes System.Diagnostics. Use a
classe Debug se você quiser mensagens apenas na versão de depuração do seu programa. Use
a classe Trace se você quiser mensagens nas versões de depuração e de publicação.
Métodos de saída
As classes Trace e Debug fornecem os seguintes métodos de saída:
• Vários métodos Write, que fornecem saída de informações sem interromper a execução.
Esses métodos substituem o método Debug.Print usado nas versões anteriores do Visual
Basic.
• Os métodos System.Diagnostics.Debug.Assert(System.Boolean) e
System.Diagnostics.Trace.Assert(System.Boolean) que interrompem a execução e fornecem
saída de informações se uma condição especificada falhar. Por padrão, o método Assert exibe
as informações em uma caixa de diálogo. Para obter mais informações, consulte Assertivas em
código gerenciado.
• Os métodos System.Diagnostics.Debug.Fail(System.String) e
System.Diagnostics.Trace.Fail(System.String) os quais sempre interrompem a execução e
fornecem saída de informações. Por padrão, os métodos Fail exibem as informações em uma
caixa de diálogo.
Além de informações partindo do seu aplicativo, a janela Output pode exibir informações sobre:
• Os módulos que depurador tenha carregado ou descarregado.

• Exceções que são lançadas.
• Processos que terminam.
• Threads que terminam.
Asserção no código gerenciado

Uma asserção, ou instrução Assert, testa uma condição, que você especifica como um
argumento para a instrução Assert. Se a condição for avaliada como True, nenhuma ação ocorre.
Se a condição for avaliada como False, a declaração falhará. Se você estiver executando com
uma compilação para depuração, seu programa insere modo de interrupção.
No Visual Basic e Visual C#, use o método Assert do Debug ou do Trace, que estão no
namespace System.Diagnostics. Métodos de classe Debug não são incluídos em uma versão de
lançamento do seu programa, para que eles não aumentem o tamanho ou reduzam a velocidade
do seu código de entrega.
C++ não dá suporte a métodos de classe Debug. Você pode obter o mesmo efeito, usando a
classe Trace com compilação condicional, tais como #ifdef DEBUG... #endif.
O método Debug.Assert
Use o método System.Diagnostics.Debug.Assert(System.Boolean) livremente para testar

condições que deve permanecer True se o código está correto. Por exemplo, suponha que você
tenha escrito uma função de divisão de inteiros. Pelas regras de matemática, o divisor nunca pode
ser zero. Você pode testar isso usando uma declaração:
[C#]
int IntegerDivide ( int dividend , int divisor ) { Debug.Assert ( divisor != 0 ); return ( dividend / divisor ); }
Quando você executar este código no depurador, a instrução de asserção é avaliada, mas na
versão de lançamento, a comparação não é feita, portanto, não existirá nenhuma sobrecarga
adicional.
Veja outro exemplo. Você tem uma classe que implementa uma conta checking, da seguinte
forma:
[C#]
float balance = savingsAccount.Balance; Debug.Assert ( amount <= balance ); savingsAccount.Withdraw (

amount );
Antes que retirar dinheiro da conta, você deseja verificar se o saldo da conta é suficiente para
cobrir a quantidade que você está preparando para saque. Você pode escrever uma asserção
para verificar o saldo:
[C#]
float balance = savingsAccount.Balance; Trace.Assert ( amount <= balance ); savingsAccount.Withdraw (

amount );
Observe que chamadas ao método System.Diagnostics.Debug.Assert(System.Boolean)

desaparecem quando você cria uma versão de lançamento do seu código. Isso significa que a

chamada que verifica o saldo desaparece na versão de lançamento. Para solucionar esse
problema, você deve substituir System.Diagnostics.Debug.Assert(System.Boolean) por
System.Diagnostics.Trace.Assert(System.Boolean), que não desaparece na versão de
lançamento:
Chamadas para System.Diagnostics.Trace.Assert(System.Boolean) Adicionam sobrecarga a

sua versão de lançamento, diferentemente de chamadas para
System.Diagnostics.Debug.Assert(System.Boolean).
Efeitos colaterais de Debug.Assert
Quando você usar System.Diagnostics.Debug.Assert(System.Boolean), certifique-se de que

qualquer código dentro do Assert não altera os resultados do programa se Assert for removido.
Caso contrário, você pode introduzir um erro que aparece somente na versão de lançamento do
seu programa acidentalmente. Tome cuidado principalmente com asserções que contêm
chamadas de função ou procedimento, como o exemplo a seguir:
[C#]
// unsafe code Debug.Assert (meas(i) != 0 );
Este uso de System.Diagnostics.Debug.Assert(System.Boolean) pode parecer seguro a

princípio, mas suponha que a meas da função atualiza um contador sempre que ela é chamada.
Quando você cria a versão de lançamento, esta chamada para meas é eliminada, para o contador
não ser atualizado. Este é um exemplo de uma função com um efeito colateral. Eliminar uma
chamada para uma função que tem efeitos colaterais pode resultar em um erro que aparece
apenas na versão de lançamento. Para evitar esses problemas, não posicione chamadas de
função em uma instrução System.Diagnostics.Debug.Assert(System.Boolean). Use uma
variável temporária:
[C#]
temp = meas( i ); Debug.Assert ( temp != 0 );
Mesmo quando você usa System.Diagnostics.Trace.Assert(System.Boolean), ainda convém

evitar fazer chamadas de função dentro de uma instrução Assert. Essas chamadas deverão ser
seguro, pois instruções System.Diagnostics.Trace.Assert(System.Boolean) não são eliminados
em uma criação para lançamento. No entanto, se você evitar tais construções como uma questão
de hábito, é menos provável que você cometa um erro quando você usa
Requisitos de Depuração e Rastreamento
Se você criar o projeto usando os assistentes Visual Studio, o símbolo Trace é definido por padrão
em Configurações de lançamento e de depuração. O símbolo Debug é definido por padrão
somente na compilação de depuração.
Caso contrário, para métodos Trace funcionarem, o programa deve ter uma das opções a seguir
na parte superior do arquivo de origem:
• #Const TRACE = True no Visual Basic

• #define TRACE Em Visual C++ e C#
Ou o programa deve ser criado com a opção Trace:

• /d:TRACE=True No Visual Basic
• /d:TRACE Em Visual C# e C++
Se você precisa usar os métodos de depuração em uma criação de versão C# ou Visual Basic,
você deverá definir o símbolo Debug em sua configuração de lançamento.
C++ não dá suporte a métodos de classe Debug. Você pode obter o mesmo efeito, usando a
classe Trace com compilação condicional, tais como #ifdef DEBUG... #endif Você pode definir
esses símbolos na caixa de diálogo <Project> Property Pages. Para obter mais informações,
consulte Alterando configurações do projeto para configuração de depuração no Visual Basic ou
Alterando Configurações do projeto para configuração de depuração em C ou C++.
Declarar argumentos
System.Diagnostics.Trace.Assert(System.Boolean) e
System.Diagnostics.Debug.Assert(System.Boolean) levam até três argumentos. O primeiro
argumento, que é obrigatório, é a condição que deseja verificar. Se você chamar
System.Diagnostics.Trace.Assert(System.Boolean) ou
System.Diagnostics.Debug.Assert(System.Boolean) com apenas um argumento, o método
Assert verificará a condição e, se o resultado é False, mostra o conteúdo da pilha de chamadas
na janela Output. O exemplo a seguir Mostra
System.Diagnostics.Trace.Assert(System.Boolean) e
System.Diagnostics.Debug.Assert(System.Boolean):
[C#]
Debug.Assert ( stacksize > 0 ); Trace.Assert ( stacksize > 0 );
Os argumentos segundo e terceiro, se houver, devem ser seqüências. Se você chamar

System.Diagnostics.Trace.Assert(System.Boolean) ou
System.Diagnostics.Debug.Assert(System.Boolean) com dois ou três argumentos, o primeiro
argumento é uma condição. O método verifica a condição e, se o resultado for FALSO, mostra a
segunda e terceira seqüências. O exemplo a seguir mostra
System.Diagnostics.Debug.Assert(System.Boolean,System.String) e
System.Diagnostics.Trace.Assert(System.Boolean,System.String) usado com dois argumentos:
[C#]
Debug.Assert ( stacksize > 0, "Out of stack space" ); Trace.Assert ( stacksize > 0, "Out of stack space" );
O exemplo a seguir Mostra Assert e Assert:
[C#]
Debug.Assert ( stacksize > 100, "Out of stack space" , "Failed in inctemp" ); Trace.Assert ( stacksize > 0, "Out
of stack space", "Failed in inctemp" );
Personalizando comportamento de declaração
Se você executar o aplicativo no modo de interface do usuário, o método Assert exibe a caixa de
diálogo Assertion Failed quando a condição falhar. As ações que ocorrem quando uma
declaração falha são controladas pela propriedade Listeners ou Listeners.
Você pode personalizar o comportamento de saída adicionando um objeto TraceListener à

coleção Listeners, removendo um TraceListener da coleção Listeners, ou substituindo o método

System.Diagnostics.TraceListener.Fail(System.String) de um TraceListener existente para fazê-lo
comportar-se de maneira diferente.
Por exemplo, você pode substituir o método

System.Diagnostics.TraceListener.Fail(System.String) para gravar em um log de eventos em
vez de exibir a caixa de diálogo Assertion Failed.
Para personalizar a saída dessa forma, o programa deve conter uma escuta, e você deve herdar
de TraceListener e substituir seu método
System.Diagnostics.TraceListener.Fail(System.String).
Para mais informações, consulte Rastrear Listeners.
Definindo asserções em arquivos de configuração
Você pode definir itens em seu arquivo de configuração de programa, bem como em seu código.
Para obter mais informações, consulte System.Diagnostics.Trace.Assert(System.Boolean) ou
Parar instruções no Visual Basic

A instrução Stop do Visual Basic fornece uma alternativa de código para definir um ponto de
interrupção. Quando o depurador encontrar uma instrução Stop, ele interrompe a execução do
programa (entra modo de interrupção). Os programadores C# podem obter o mesmo efeito
usando uma chamada para System.Diagnostics.Debugger.BREAK.
Você define ou remove uma instrução Stop editando seu código fonte. Você não pode definir ou
limpar instruções Stop usando comandos do depurador, como você faria com um ponto de
interrupção.
Diferentemente de uma instrução End, a instrução Stop não redefine variáveis ou retorna você ao
modo de design. Você pode escolher Continue no menu Debug para continuar executando o
aplicativo.
Quando você executar um aplicativo do Visual Basic fora do depurador, uma instrução Stop
iniciará o depurador se a depuração Just-in-Time estiver ativada. Se a depuração Just-in-Time
não estiver ativada, a instrução Stop se comporta como se fosse uma instrução End, encerrando a
execução. Nenhum evento QueryUnload ou Unload ocorrerá, portanto você deve remover todas
as instruções de Stop da versão final do seu aplicativo Visual Basic. Para obter mais informações,
consulte Depuração Just-in-Time.
Para evitar a necessidade de remover instruções Stop, você pode usar compilação condicional:
#If DEBUG Then Stop #Else ' Don't stop #End If
Outra alternativa é usar uma instrução Assert em vez da instrução Stop. Uma instrução
Debug.Assert interrompe a execução somente quando uma condição especificada não for
atendida e é removida automaticamente quando você criar uma versão Release. Para obter mais
informações, consulte Itens no código gerenciado. Se você desejar que uma instrução Assert
sempre interrompa a execução na versão de depuração, você pode fazer isso:
Debug.Assert(false)
Ainda outra alternativa é usar o método DEBUG.Fail:

Debug.Fail("a clever output string goes here")
Passo-a-passo: Depuração de um formulário do Windows
Um formulário do Windows é uma das mais comuns aplicativos gerenciados. Um formulário do

Windows cria um aplicativo do Windows padrão. Você pode concluir essa explicação passo a
passo usando Visual Basic, C#, J#, ou C++.
Primeiro, você deve fechar quaisquer soluções abertas.
Para preparar para essa explicação passo a passo

• Se você já tiver uma solução aberta, feche-a. (No menu File, selecione Close Solution.)
Criar um novo formulário do Windows
Em seguida, você criará um novo formulário do Windows.
Para criar o formulário do Windows para essa explicação passo a passo

1. No menu File, escolha New e clique Project.
A caixa de diálogo New Project será exibida.
2. No painel tipos de projeto, abra o nó Visual C#Visual Basic, Visual J# ou Visual C++, em
seguida,
1. Para Visual Basic, Visual C# ou Visual J#, selecione a Windows., em seguida,
marque Windows Application no painel Templates.
2. Para Visual C++, selecione o CLR.
3. No painel Templates, selecione Windows Application.
4. Na caixa Name, dê ao projeto um nome exclusivo (por exemplo,
Walkthrough_SimpleDebug).
5. Clique em OK.
Visual Studio cria um novo projeto e exibe um novo formulário no Windows Forms .
PaDesignerra obter mais informações, consulte Windows Forms Designer.
6. No menu View, selecione Toolbox.
Abre a caixa de ferramentas. Para obter mais informações, consulte Caixa de ferramentas.
7. Na caixa de ferramentas, clique sobre o controle Button e arraste o controle para a
superfície de projeto de formulário. Solte o botão no formulário.
8. Na caixa de ferramentas, clique sobre o controle TextBox e arraste o controle para a
superfície de projeto de formulário. Solte a TextBox no formulário.
9. Na superfície de projeto de formulário, clique duas vezes no botão.
Isso leva você para a página de código. O cursor deve estar no button1_Click.
10. Na função button1_Click., adicione o seguinte código:
' Visual Basic textBox1.Text = "Button was clicked!" // C# textBox1.Text = "Button was clicked!"; // J#
textBox1.set_Text("Button was clicked!"); // C++ textBox1->Text = "Button was clicked!";
11. No menu Build, selecione Build Solution.

O projeto deve criar-se com erros.
Depurar seu formulário

Agora, você está pronto para iniciar a depuração.
Para depurar o formulário do Windows criado para essa explicação passo a passo
1. Na janela de origem, clique na margem esquerda na mesma linha quo o texto foi
adicionado:
Um ponto vermelho aparece e o texto na linha é realçado em vermelho. O ponto vermelho

representa um ponto de interrupção. Para obter mais informações, consulte Pontos de
interrupção. Quando você executa o aplicativo sob o depurador, o depurador interromperá a
execução nesse local quando o código é controntado. Você pode exibir o estado do seu
aplicativo e depurá-lo.
2. A partir do menu Debug, escolha Start.
O formulário do Windows começa a ser executado.
3. No formulário do Windows, clique no botão que você adicionou.
No Visual Studio, isso leva você para a linha onde você define o ponto de interrupção na
página de código. Esta linha deve ser realçada em amarelo. Agora você pode exibir as
variáveis no seu aplicativo e controlar sua execução. Agora o aplicativo foi interrompido
quando executava, aguardando uma ação de você.
Observação
Se você tiver definido a Active Solution Configuration como Release, a execução não será
paralisada no ponto de interrupção. Isso simula o comportamento de um programa na versão real.
O círculo que marca o ponto de interrupção irá conter um ponto de interrogação branco. Se
necessário, use a caixa de diálogo Configuration Manager para alterar essa configuração
novamente para Debug.
4. No menu Debug, escolha Windows, em seguida Watch, e clique em Watch1.

5. Na janela Watch1, clique em um linha em branco. Na coluna Name, digite textBox1.Text (se
você estiver usando Visual Basic, Visual C#, ou J#) ou textBox1->Text (se você estiver
usando C++), pressione ENTER.
A janela Watch1 mostra o valor dessa variável entre aspas como:
""
6. A partir do Menu Debug, escolha Step Into.

O valor de textBox1.Text muda na janela Watch1 para:
Button was clicked!
7. A partir do Menu Debug, escolha Continue para continuar a depuração do programa.

8. No formulário do Windows, clique no botão novamente.
Visual Studio quebra a execução novamente.
9. Clique no ponto vermelho que representa o ponto de interrupção.
Isso remove o ponto de interrupção do seu código.
10. A partir do Menu Debug, escolha Stop Debugging.
Anexar ao seu formulário para depuração

No Visual Studio 2005, você pode anexar o depurador a um processo em execução. Se você
estiver usando um Edition Express, não há suporte para este recurso.
Para anexar ao formulário do Windows para depuração

1. No projeto criado acima, clique Na margem esquerda para definir mais uma vez um ponto
de interrupção na linha que você adicionou:
' Visual Basic textBox1.Text = "Button was clicked!" // C# textBox1.Text = "Button was clicked!" // J#
2. No menu Debug, selecione Start Without Debugging.

O formulário do Windows inicia executando sob Windows, como se você tivesse clicado
duas vezes seu executável. O depurador não está anexado.
3. No menu Debug, selecione Attach to Process. (Este comando também está disponível a
partir do menuTools.)
A caixa de diálogo Attach to Process será exibida.
4. No painel Available Processes, localize o nome do processo
(Walkthrough_SimpleDebug.exe) na coluna Process e clique nele.
5. Clique no botão Attach.
6. No seu formulário do Windows, clique em um e somente um botão.
O depurador quebra a execução do formulário do Windows no ponto de interrupção.
Depurar o método OnStart como:

Você pode depurar o construtor do Windows Service, depurando em uma instância do serviço.
Você pode depurar o próprio Windows Service iniciando o serviço e anexando o depurador ao
processo do serviço. No entanto, para depurar o método OnStart de um Windows Service, você
deve adicionar algumas linhas de código para simular o serviço. Para obter mais informações,
consulte System.ServiceProcess.ServiceBase.OnStart(System.String[]).
Para depurar um problema no método OnStart

• Crie uma simulação do serviço (um aplicativo de console, por exemplo) para determinar
onde o problema está.
Por exemplo, suponha que você tenha um Visual C# Windows Service parecido com este:
public class ManagedWindowsService : System.ServiceProcess.ServiceBase { // // designer and user
generated methods and properties // public static int main(String[] args) { ServiceBase.Run( new
ManagedWindowsService() ); } }
Adicione as linhas de código a seguir para depurar o método OnStart:

public static int main(String[] args) { (new ManagedWindowsService()).OnStart(); // allows easy
debugging of OnStart() ServiceBase.Run( new ManagedWindowsService() ); }
O serviço não poderá executar nesse modo, mas você pode depurar o método OnStart e
verificar se ele está se comportando conforme esperado.
Para obter mais informações, consulte Depurando Aplicativos do Windows Service.
Como: Depurar Aplicativos de Modo Misto

Um aplicativo de modo misto é qualquer aplicativo que combine código nativo (C++) com código
gerenciado (como Visual Basic, Visual C# ou C++ que é executado no Common Language
Runtime). Depuração de aplicativos de modo misto é amplamente transparente no Visual Studio;
ela é não muito diferente da depuração de um aplicativo de modo único. Há algumas
considerações especiais, entretanto.
Observação
Visual Studio não dá suporte de depuração de modo misto no Windows 95, Windows 98 ou
Windows Millennium Edition.
Avaliação da Propriedade em Aplicativos de Modo Misto
Em um aplicativo de modo misto, a avaliação das propriedades pelo depurador é uma operação
cara. Como um resultado, operações de depuração, como uma etapa poderá parecer lenta. Para
obter mais informações, consulte Stepping. Se você tiver um desempenho ruim em depuração de
modo misto, convém desativar a avaliação da propriedade nas janelas do depurador.
Observação
As caixas de diálogo e comandos de menu que você vê podem diferir daquelas descritas na Ajuda
dependendo da sua configuração ativa ou edição. Para alterar as configurações, escolha Import
and Export Settings no menu Tools. Para obter mais informações, consulte Configurações
Visual Studio.
Para desativar a avaliação da propriedade

2. Na caixa Options de diálogo, abra a pasta Debugging e selecione a categoria General.
3. Desmarque a caixa de seleção Enable property evaluation and other implicit function
calls.
Como pilha de chamadas nativas e pilha de chamadas gerenciadas diferem, o depurador não
pode sempre fornecer pilha de chamadas completa para código misto. Quando código nativo
chama código gerenciado, você pode observar algumas discrepâncias. Para obter detalhes,
consulte Código Misto e Informações Perdidas na Janela de Pilha de Chamada.
ERRO: depuração Isn't possíveis como um depurador do núcleo estiver ativada no sistema
Quando estiver depurando código gerenciado, você pode receber a seguinte mensagem de erro:
Debugging isn't possible because a kernel debugger is enabled on the system
Essa mensagem ocorre quando você tenta depurar código gerenciado em um sistema executando
Windows NT, Windows 2000 ou Windows XP que tiver sido iniciado no modo de depuração.
Solução
Para corrigir esse problema
• Desative a depuração de núcleo e depure no Visual Studio.

- ou -
• Depure usando o Kernel Debugger do Visual Studio.
Para desativar depuração de núcleo
1. Localizar boot.ini na sua unidade do sistema (geralmente C:\). O arquivo boot.ini pode
estar oculto e somente-leitura, portanto você precisa usar o comando a seguir para vê-lo:
dir /ASH
2. Abra boot.ini usando o bloco de notas e remova as seguintes opções:

/debug /debugport /baudrate
3. Reinicialize o computador.
4. Reinicie o Visual Studio e depuração.
Para depurar com o Kernel Debugger
1. Se o Kernel Debugger é conectado, você verá uma mensagem perguntando se você
deseja para continuar a depuração. Clique no botão para continuar.
2. Você pode obter um User break exception(Int 3) Se isso acontecer, digite o seguinte
comando KD para continuar a depuração:
gn
Depuração de código nativo

Express Não Não Nativo Não
Padrão Não Não Nativo Não
Pro / Team Não Não Nativo Não
A seção aborda alguns problemas comuns de depuração e técnicas para aplicativos nativos. As
técnicas abordadas nesta seção são técnicas de alto nível. Para a mecânica de usar o depurador
Visual Studio, consulte O depurador esquema obter.
Como debug otimizado código:


Observação
Quando o compilador otimiza código, ele reposiciona e reorganiza os instruções, resultando em

mais eficiente código compilado. Devido a essa rearrangement, o depurador sempre não pode
identificar o código fonte que corresponde a um conjunto de instruções.
Otimização pode afetar:
• Locais variáveis, que podem ser removido pelo otimizador ou movido para o depurador
não compreende locais.
• Posições dentro uma função, que são alteradas quando o otimizador mescla blocos de
código.
• Função nomes de quadros no pilha de chamadas, que podem ser incorreto se o otimizador
mescla duas funções.
Quase sempre os quadros que você vê na pilha de chamadas são direito, no entanto, supondo
que você tenha símbolos para todos os quadros. Os quadros no pilha de chamadas poderão ser
incorreto se você tiver corrupção de pilha, se você tiver escrito em linguagem conjunto, funções ou
se não houver quadros sistema operacional sem correspondência símbolos no pilha de
chamadas.
Variáveis globais e estático sempre são exibidas corretamente. Portanto, é layout estrutura. Se
você tiver um ponteiro para uma estrutura e o valor do ponteiro esteja correto, cada variável de
membro da estrutura mostrará o valor correto.
Devido a essas limitações, você deve fazer a depuração usando uma versão do seu programa
unoptimized se possível. Por padrão, a otimização é desativado na configuração de depuração de
um programa Visual C++ e ativado na configuração Release.
Às vezes, entretanto, um erro pode aparecem somente em uma versão de um programa

otimizado. Nesse caso, você deve depurar o código otimizado.
Para ativar otimização de um Debug criar configuração

1. Quando você cria um novo projeto, selecionar o Win32 Debug destino. Use o Win32
Debug destino até que seu programa estiver totalmente depurado e você estiver pronto para
criar um Win32 Release destino. O compilador não Não otimizar o Win32 Debug destino.
2. Selecione o projeto no Solution Explorer.
3. No menu View, clique em Property Pages.
4. Na caixa Property Pages de diálogo, certifique-se Debug estará marcada na caixa
Configuration de listagem drop-down.
5. No modo de exibição Pasta no lado esquerdo, selecione a C/C pasta.
6. Sob a pasta C++, selecione Optimization.

7. Na lista Propriedades à direita, localize Optimization. A configuração lado para ele
provavelmente diz Disabled (/Od). Escolha uma das outras opções (Minimum Size (/O1),
Maximum Speed (/O2) ou Custom)., Full Optimization (/Ox)
8. Se você escolheu a Custom opção para Optimization, agora você pode definir opções
para qualquer uma das outras propriedades mostradas na lista Propriedades
Ao depurar o código otimizado, aspecto na Disassembly janela para ver quais instruções
realmente criado e executado. Ao definir pontos de interrupção, você precisará estar ciente que o
ponto de interrupção poderá mover junto com uma instrução. Por exemplo, considere o código a
seguir:
for (x=0; x<10; x++)
Suponha que você definir um ponto de interrupção nesta linha. Você pode esperar o ponto de
interrupção para ser atingido 10 vezes, mas se o código é otimizado, ponto de interrupção
somente é acertado uma vez. Que é porque a primeira instrução define o valor da x como 0. O
compilador reconhece que isso só tem que ser feito uma vez e move-fora do loop. Move o ponto
de interrupção a ele.
As instruções que comparar e incrementar x permanecer dentro do loop. Quando você exibe a
Disassembly janela é automaticamente definida como instrução para maior controle, que é útil
quando depuração através de código otimizado. o Unidade etapa
DebugBreak e __debugbreak
Você pode chamar a DebugBreak função Win32 ou __debugbreak. intrínsecas em qualquer ponto
no seu código e DebugBreak__debugbreak ter o mesmo efeito que configurar um ponto de
interrupção nesse local.
Porque DebugBreak é uma chamada para uma função do sistema, depuração do sistema
símbolos devem ser instalados para garantir a informação correta pilha de chamadas é exibida
após quebra. Caso contrário, as informações exibidas pelo depurador pilha de chamadas podem
estar fora por um quadro. Não se você usar __debugbreak, símbolos são necessários.
Declarações

Express Edition Não Não Nativo Não
Standard Edition Não Não Nativo Não
Pro / Team Edition Não Não Nativo Não
Uma instrução de declaração Especifica uma condição que você espera para manter verdadeira
em algum momento específico em seu programa. Se essa condição não tem verdadeira, a
declaração falhar, execução de seu programa for interrompida, aparece. e Caixa de diálogo Falha
de declaração
Visual C++ oferece suporte instruções de declaração com base nas seguintes construções:
• Para Declarações MFC Programa MFC.

• Para ATLASSERT programas que utilizam ATL.
• Para Declarações CRT programas que utilizam a biblioteca de tempo de execução C.
• O ANSI Declarar função para outros programas C/C.
Você pode usar declarações para:
• Capturar erros de lógica. Para obter mais informações, consulte Erro Catching de lógica.
• Verificar resultados de uma operação. Para obter mais informações, consulte Resultado de
verificação.
• Teste as condições de erro que devem ter sido tratadas. Para obter mais informações,
consulte Teste condição de erro.
MFC e Assertions C Run-Time Library
Quando o depurador pára devido a uma declaração Biblioteca de tempo de execução MFC ou C,
ele navega até o ponto no arquivo de origem onde a declaração ocorreu (se a fonte estiver
disponível). A mensagem de declaração aparece na caixa de diálogo, bem como Janela de saída
o Assertion Failed. Você pode copiar a mensagem de declaração da janela Output para uma
janela de texto se você desejar salvá-lo para referência futura. A Output janela pode conter outras
mensagens de erro, bem. Examinar essas mensagens com cuidado, pois fornecem pistas para a
causa da falha de declaração.
Através do uso liberal de declarações em seu código, você pode capturar muitos erros durante o
desenvolvimento. Uma boa regra é para escrever uma declaração para cada suposição você
fazer. Se você assumir que um argumento não é NULL, por exemplo, usar uma instrução de
declaração para verificar essa suposição.
_DEBUG
Instruções de declaração compilar somente quando _DEBUG for definida. Quando _DEBUG não
for definido, o compilador trata declarações como instruções nulas. Assim, instruções de
declaração ter zero sobrecarga no seu programa versão final; você pode usá-los liberally em seu
código, sem afetar o desempenho da sua versão release e sem que seja necessário usar #ifdef
as diretivas.
Efeitos lado do uso Assertions

Quando você adicionar declarações a seu código, certifique-se que as declarações não tem
efeitos colaterais. Por exemplo, considere a declaração a seguir:
ASSERT(nM++ > 0); // Don't do this!
Porque a ASSERT expressão não é avaliada com a versão release do seu programa, nM terá que
valores diferentes nas versões Debug e Release. Em MFC, você pode usar a VERIFY macro em
vez de ASSERT. Avaliará VERIFY a expressão mas não verifica o resultado na versão Release.
Tenha cuidado usando chamadas de função em instruções de declaração, especialmente como

avaliar uma função pode ter efeitos colaterais inesperados.
ASSERT ( myFnctn(0)==1 ) // unsafe if myFnctn has side effects VERIFY ( myFnctn(0)==1 ) // safe
Chama VERIFYmyFnctn em versões Debug e Release, portanto é aceitável para usar. Você ainda
terá a sobrecarga de um chamada de função desnecessária na versão Release, entretanto.
Detecção vazamento de memória e isolamento

A capacidade de dinamicamente alocar e Desalocar memória é um dos recursos de programação

C/C, mais seguro mas o maior nível também pode ser a deficiência maior. Isso é certamente
verdadeiro de aplicativos C/C, onde problemas tratamento memória estão entre os erros mais
comuns.
Uma dos erros mais sutil e difíceis de detectar é o vazamento — de memória a falha para
Desalocar memória que foi anteriormente alocada corretamente. Um vazamento de memória
pequeno que ocorre somente uma vez não pode ser percebido, mas programas que leak grandes
quantidades de memória, ou leak progressivamente, podem exibir sintomas, variando entre
desempenho deficiente (e gradualmente decrescente) e em execução fora de memória totalmente.
Worse, um programa leaking pode usar Backup para que ele faz com outro programa a falhar,
quantidade de memória deixar o usuário com nenhum pista para onde o problema está realmente.
Além disso, vazamentos de memória mesmo inofensivo podem ser symptomatic de outros
problemas.
Felizmente, as depurador Visual Studio e C bibliotecas (CRT) de tempo de execução fornecem

você com eficaz meio para detectando e identificando vazamentos de memória. Para entender
como detectar memória leaks usando as instalações de depuração CRT, leia os seguintes tópicos:
• Ativando detecção vazamento de memória

• Interpretar tipos do bloco de memória
• Definir um ponto de interrupção em um número de alocação de memória

• Comparando unidos memória
MFC fornece seu próprio conjunto de recursos para detectar vazamentos de memória em
programas MFC. Para obter mais informações, consulte Detectar Leaks de memória no MFC.
Consulte também
Conceitos
Outros recursos
HOW TO: depurar código assembly embutido
Observação
O depurador fornece duas janelas para depurar código de montagem embutido, a Disassembly
janela e a Registers janela.
Procedimento
Para depurar código de montagem embutido
1. Usar a Disassembly janela para exibir as instruções do conjunto.

2. Use a Registers janela para exibir registrar conteúdo.
Técnicas de depuração atl


Se você está depurando um programa ATL, essas técnicas depuração podem ser de uso para
você.
Nesta seção
Como componentes Debug com + 1.0:
Descreve como para depurar um projeto 1.0 componente COM + no Visual Studio.
HOW TO: Debug chamadas QueryInterface
Mostra a definição você deve adicionar ao seu código para depurar QueryInterface
chamadas em ATL e os resultados.
Como contagens de referência faixa:
Mostra a definição você deve adicionar ao seu código para referência de rastreamento
contagens nas ATL e os resultados.
Depuração e Error Reporting funções global
Lista funções na biblioteca ATL que fornecem útil depuração e recursos de rastreamento.
Macros depuração e relatório de erros
Lista macros na Biblioteca ATL que fornecem útil depuração e recursos de rastreamento.
Aborda alguns problemas comuns de depuração e técnicas para aplicativos C e C++.
Descreve as práticas recomendadas para segurança depuração.
Técnicas de depuração MFC


Se você está depurando um programa MFC, essas técnicas de depuração podem ser útil.
Nesta seção
AfxDebugBreak
Descreve a AfxDebugBreak função, que você pode usar para pontos de interrupção
hardcode no código fonte.
A macro Trace
Descreve e fornece exemplos das macros ATLTRACE e Trace MFC, que permitem que
você se exibir mensagens do seu programa na janela de saída do depurador.
Detectar Leaks de memória no MFC
Fornece links para as classes da MFC e funções que detectar memória que é alocada mas
nunca desalocadas. Incluir links: controlar alocações de memória, ativando Diagnóstico de
Memória, levando instantâneos de memória, exibindo estatísticas de memória, e objeto
despejos.
Reduzindo o tamanho de um construir Debug MFC
Fornece soluções para grande quantidade de espaço em disco usado pelo informações da
depuração quando você cria um Versão de depuração de um aplicativo MFC.
Assertions MFC
Descreve e fornece código de exemplo para usar a ASSERT macro para verificar para
falhas de declaração.
Depuração Visual C++
Fornece recomendações para depuração mais seguro.
Técnicas de depuração CRT


Se você está depurando um programa que usa a biblioteca de tempo de execução C, essas
técnicas de depuração podem ser útil.
Nesta seção
Usar da biblioteca Debug CRT
Descreve o suporte de depuração fornecido pela biblioteca do C Run-Time e fornece

instruções para acessar as ferramentas.
Macros do relatório
Do _RPTn fornece informações sobre e _RPTFn macros (definidas em CRTDBG.H), que

substitui o uso de printf instruções para depuração.
Depurar versões de funções de alocação da pilha
Discute as versões Debug especiais de funções de alocação da pilha, incluindo: como a

CRT relaciona chamadas, os benefícios da chamada-las explicitamente,. Como evitar a
conversão, controlar os tipos separados de alocações em blocos do cliente, e os
resultados de não definição _DEBUG
A pilha Debug CRT
Fornece links para gerenciamento de memória e a pilha de depuração, tipos de blocos

sobre a pilha de depuração, usando a pilha de depuração, estado da pilha relatório
funções, e controlar solicitações de alocação da pilha.
Depurar escrita da função gancho
Links listas para Bloco do cliente conectar funções, funções do gancho de alocação,
ganchos de alocação e CRT alocações de memória, e funções do gancho de relatório.
Fornece recomendações para depuração mais seguro.
Depuração Native FAQs do código


Os tópicos a seguir contém respostas a algumas perguntas mais freqüentes:
• Como pode eu Debug Violations Access quando executando meu autônomo do programa?
• Como eu eu depurar uma violação de acesso?
• Como pode eu localizar sem se meus ponteiros são Corrupting um endereço de memória?
• Como eu eu localizar saída quem É Passing um valor do parâmetro Wrong?
• Quando chamada uma função Hundreds de Times, quais chamada falha?
• Onde procurar por erros de código Win32?
• Como pode eu manter foco ao nível através de meu programa?
• Como pode usar Windows Debugger durante depuração um programa primeiro plano?
• Se Halted na MFC, como posso obter voltar para a função que chamado MFC?
COM e depurando ActiveX

Express Edition Não Não Nativo Não
Standard Edition Não Não Nativo Não
Pro / Team Edition Não Não Nativo Não
Esta seção fornece dicas sobre depuração aplicativos COM e controles ActiveX.
Como: Depurar DLLs

Observação
Quando você depurar uma DLL, você pode iniciar a depuração de:
• O projeto usado para criar o executável que chama a DLL.
Ou-
• O projeto usado para criar a DLL próprio.
Se você tiver o projeto usado para criar o executável, iniciar depuração desse projeto. Você pode
abrir um arquivo de fonte para a DLL e definir pontos de interrupção nesse arquivo, mesmo que
ele seja não fizer parte do projeto usado para criar o executável. Para obter mais informações,
consulte Pontos de interrupção.
Se você iniciar a depuração do projeto que cria a DLL, você deve especificar o executável que
deseja usar na depuração a DLL
Para especificar um executável para a sessão de depuração

1. No Solution Explorer, selecione o projeto que cria a DLL.
2. Partir do View menu, escolha Property Pages.
3. Na caixa Property Pages de diálogo, abra a Configuration Properties pasta e selecione
a Debugging Categoria.
4. Na caixa Command, especifique o nome de caminho para o contêiner. Por exemplo,
Files\MyApplication\MYAPP.EXE C:\Program.
5. Na caixa Command Arguments, especificar os argumentos necessários para o
executável.
Se você não especificar o executável na caixa Project Property Pages de diálogo aparece
quando você inicia a depuração. o Executável para depuração caixa de diálogo de sessões
Como: Depurar código inserido

Observação
Muito usando atributos pode simplificar programação C++. Para obter mais informações, consulte
Atribuído programação conceitos.Alguns atributos são interpretados diretamente pelo compilador.
Outros atributos injetar código em fonte de programa, que então compila o compilador. Esse
código injected torna programação fácil, reduzindo a quantidade de código você deve escrever. Às
vezes, no entanto, um erro pode causar seu aplicativo para falhar durante sua execução código
injected. Quando isso acontece, provavelmente desejará para aspecto no código injected. O
Visual Studio fornece duas maneiras para que você possa ver injected código:
• Você pode exibir código injected na janela Disassembly.

• Usando /FX, você pode criar um arquivo de origem mesclado que contém código original e
injected.
A Disassembly janela mostra instruções idioma conjunto-que correspondem ao código-fonte e o

código injetado pelos atributos. Além disso, a Disassembly janela pode mostrar a anotação
código fonte-.
Para ativar anotação fonte

• Clique com o botão direito do mouse na Disassembly janela, e escolha Show Source
Code No menu de atalho.
Se souber o local de um atributo em uma janela de origem, você pode usar o menu de atalho
para localizar o código injected na janela Disassembly
Para exibir código injected
1. O depurador deve estar no modo de interrupção.
2. Em um janela de código de origem, coloque o cursor na frente do atributo cujo código
injected você deseja exibir.
3. Clique com o botão direito do mouse, e selecione Go To Disassembly a partir do menu de
atalho
Caso o local de atributo esteja próximo o ponto de execução atual, você pode selecionar a
Disassembly janela a partir do Debug menu
Para exibir a código de desmontagem no ponto de execução atual
1. O depurador deve estar no modo de interrupção.
2. No menu Debug, escolha Windows, e clique em Disassembly.
Depurar aplicativos da Web

Esta seção descreve técnicas comuns de depuração para aplicativos da Web. Para obter mais
informações, consulte Explicação detalhada sobre o depurador.
Nesta seção
Depurar aplicativos da Web ASP.NET

Fornece instruções e requisitos sobre depuração de um aplicativo ASP.NET no momento
de desenvolvimento ou quando o aplicativo já estiver implantado e em execução.
Depuração aplicativos Web ATL Server
Fornece links de informações sobre a depuração de aplicativos da Web ou de serviços

XML da Web criados com o ATL Server.
Depurando aplicativos da Web: Erros e solução de problemas
Lista erros que você pode encontrar durante a depuração de aplicativos da Web e sugere
correções.
Preparação da Depuração: Web Services XML (C++)
Descreve as configurações e comportamentos padrão dos projetos de Serviços da Web do

ASP.NET e das chamadas de depuração para serviços XML da Web a partir de aplicativos
do cliente.
Preparação para depuração : Aplicativos ASP.NET da Web

ASP.NET etapas para a depuração, e de como alterar a configuração de depuração
padrão.
Projetos Serviço da Web XML depuração preparação:

ASP.NET , ativando a depuração do ASP.NET, e de como alterar a configuração de
depuração padrão.
Depuração no Visual Studio
Fornece links para as seções maiores da documentação de depuração. Informações

incluem : novidades do depurador, definições e preparações , pontos de interrupção ,
tratamento de exceções, editar e continuar, código gerenciado de depuração, depuração
de projetos Visual C++ , depurando COM e ActiveX, depurando DLLs, depurando SQL, e
as referências a interfaces de usuários.
Como depurar aplicativos da Web em um servidor remoto:
Descreve requisitos de instalação para depuração remota de aplicativos da Web do

ASP.NET.
Depuração SQL
Visual Studio Edition Visual Basic C# C++ J# Visual Web Developer

Pro / Team Sim Sim Sim Sim Sim
Com o depurador Visual Studio 2005, você pode depurar conjuntos de módulos do commom
language runtime (CLR) gerenciados executando executando dentro do processo SQL Server
2005 em grande parte da mesma maneira que você tem depurado stored procedures, funções,
disparadores e outros tipos de objetos de banco de dados.
Para obter mais informações, consulte O que há de novo no depurador Visual Studio 2005.
Nesta seção
Limitações depuração SQL
Descreve restrições e limitações sobre o uso dos recursos de depuração SQL.
Configurando O SQL Debugging
Lista requisitos de software para depuração SQL, para o servidor e estação de trabalho,
instruções para ativar depuração SQL, instalar, configurar e solucionar problemas de
instalação.
Depuração objetos de banco de dados SQL
Fornece instruções detalhadas e exemplos para cada tipo de objeto de banco de dados
SQL Server que pode ser depurado.
Depuração de aplicação multi-camada de banco de dados
Descreve como depurar aplicativos cujos componentes estão localizados em várias

máquinas.
Visão geral sobre Ferramentas Visual Database
Descreve e fornece links para tópicos em Microsoft Visual Database Tools e conexões de
banco de dados e referências.
Criando objetos SQL Server 2005 em Código Gerenciado
Descreve como criar objetos de banco de dados SQL CLR em Visual Studio usando o tipo
do projeto SQL Server.
Depuração referência Interface de usuário

Você pode encontrar as seguintes caixas de diálogo à medida que você depura seu aplicativo.
Você pode automatizar vários recursos do depurador, usando o modelo de extensibilidade do

Visual Studio. Para obter mais informações, consulte o Visual Studio Debugging SDK.
• Caixa de diálogo Choose Breakpoints

• Debug Source Files, Common Properties, caixa de diálogo Solution Property Pages
• Debugging, caixa de diálogo Options
• Caixa de diálogo Edit and Continue
• Caixa de diálogo Stop Debugging In Progress
• Caixas de diálogo Debugging Errors e Warning
COMO: Adicionar instruções de rastreamento ao código da aplicação
Os métodos usados com mais freqüência para rastreamento são os métodos para gravar saída no
escutas: Write., Assert, WriteIf, WriteLineIfWriteLine e Fail Esses métodos podem ser divididos
em duas categorias: Write. e Fail todos Emitir saída incondicionalmente, enquanto WriteIf,
WriteLine, WriteLineIf e Assert Testar uma Boolean condição, e escrever ou não gravar com
base no valor da condição e WriteIfWriteLineIf Emitir saída da condição é true, e Assert emite
saída se a condição for false.
Ao criar o Rastreamento e depuração estratégia, você deve pensar sobre a saída para ver como
você deseja. Várias Write instruções preenchidas com informações não relacionadas criará um
log que é difícil de ler. Por outro lado, usando WriteLine para colocar instruções relacionadas em
linhas separadas pode dificultar a distinguir quais informações pertence juntos. Em geral, use
várias Write instruções quando você deseja combinar informações de várias fontes para criar uma
única mensagem informativa, e a WriteLine instrução quando você desejar criar uma mensagem
única e completa.
Para gravar uma linha completa

• Do WriteLine Chamar ou WriteLineIf método.
Um retorno de carro é acrescentado ao final da mensagem esse método retorna, para que a
mensagem seguinte retornado pela Write, WriteIf, WriteLine, ou WriteLineIf será iniciada na
linha a seguir:
Visual Basic
Dim errorFlag As Boolean = False Trace.WriteLine("Error in AppendData procedure.")

Trace.WriteLineIf(errorFlag, "Error in AppendData procedure.")
C#
bool errorFlag = false; System.Diagnostics.Trace.WriteLine ("Error in AppendData procedure.");

System.Diagnostics.Trace.WriteLineIf(errorFlag, "Error in AppendData procedure.");
J#
boolean errorFlag = false; System.Diagnostics.Trace.WriteLine("Error in AppendData procedure.");

System.Diagnostics.Trace.WriteLineIf(errorFlag, "Error in AppendData procedure.");
Para gravar uma linha parcial

• Do Gravar Chamar ou WriteIf método.
A mensagem seguinte colocar out pela Write, WriteIf, WriteLine,: ou WriteLineIf será iniciada
na mesma linha que a mensagem colocar Out por ou WriteIf instrução o Write
C#

bool errorFlag = false; System.Diagnostics.Trace.WriteIf(errorFlag, "Error in AppendData procedure.");
System.Diagnostics.Debug.WriteIf(errorFlag, "Transaction abandoned."); Trace.Write("Invalid value for
data request");
Para verificar que determinadas condições existir antes ou após você executar um método
• Chame o Declarar método.
C#
int I = 4; System.Diagnostics.Trace.Assert(I == 5, "I is not equal to 5.");
C#
int I = 4; System.Diagnostics.Trace.Assert(I == 5, "I is not equal to 5.");
Observação
Você pode usar Assert com o rastreamento e depuração. Este exemplo envia a pilha de
chamadas para qualquer escuta na coleção Listeners. Para obter mais informações, consulte
Declarações em código gerenciado e Método Debug.Assert.
COMO: Criar e inicializar Listeners (escutas) de rastreamento
O Debug e Trace Classes enviar mensagens para objetos chamados escutas que receber e
processar essas mensagens. Um tal escuta para obter mais informações, consulte Rastrear
Listeners., o DefaultTraceListener, é criado e inicializado quando o rastreamento ou depuração é
ativada; automaticamente Se você desejar Trace ou Debug Saída para ser direcionado a
qualquer fontes adicionais, você deve criar e inicializar escutas de rastreamento adicionais
Os ouvintes você criar devem refletir suas necessidades individuais. Por exemplo, convém um
registro de texto de toda a saída de rastreamento. Nesse caso, você deve criar uma escuta que
escreveu todas as saídas para um novo arquivo de texto quando ativado Por outro lado, você
pode deseja exibir saída durante a execução do aplicativo somente Nesse caso, você pode criar
uma escuta que direcionado toda a saída para uma janela do console. O EventLogTraceListener
pode direcionar a saída de rastreamento para um log de eventos, e o TextWriterTraceListener
pode gravar a saída de rastreamento em um fluxo.
Para criar e inicializar o ouvinte de rastreamento

1. Declare o ouvinte de rastreamento. Se você está criando o ouvinte determinado exigir
qualquer outro objeto, declare-los também. O exemplo a seguir mostra como criar uma
escuta que grave em um arquivo de texto:
C#
// Creates the text file that the trace listener will write to. System.IO.FileStream myTraceLog = new
System.IO.FileStream("C:\\myTraceLog.txt", System.IO.FileMode.OpenOrCreate); // Creates the new
trace listener. System.Diagnostics.TextWriterTraceListener myListener = new
System.Diagnostics.TextWriterTraceListener(myTraceLog);
2. Emitir a saída de rastreamento.

o Se você desejar a escuta para receber toda saída de rastreamento, adicione o
ouvinte de rastreamento para a Listeners coleção.
O exemplo a seguir mostra como adicionar a escuta para a Listeners coleção:
C#

System.Diagnostics.Trace.Listeners.Add(myListener);
- ou -
o Se você não desejar a escuta para receber a saída de rastreamento, não adicione-
lo à coleção Listeners. Você pode emitir saída através uma escuta independente da coleção
Listeners chamando os métodos de saída de escuta na própria. O exemplo a seguir mostra
como gravar uma linha em uma escuta que não esteja na coleção Listeners :
C#
myListener.WriteLine( "This output will not go to the Listeners collection");
3. Se a escuta não for um membro da coleção Listeners, talvez seja necessário para chamar
o Flush método para registrar a saída.
C#
// Flushes the buffers of all listeners in the Listeners collection. System.Diagnostics.Trace.Flush(); //
Flushes only the buffer of myListener. myListener.Flush();
COMO: Usar TraceSource e filtros com Listeners de rastreamento
Um dos novos recursos do .NET Framework versão 2.0 é um sistema de rastreamento avançada.
O premise básico é inalterada: mensagens de rastreamento são enviadas através de opções para
escuta, que informou os dados para uma mídia de saída associados. Uma diferença principal para
versão 2.0 é rastreamentos que podem ser iniciados a instâncias da classe TraceSource. Destina
TraceSource a funcionar como um sistema de rastreamento avançada e pode ser usada em vez
do estáticos métodos do antigos Trace e Debug Classes de rastreamento.. O familiar Trace e
Debug Classes ainda existir, mas a prática recomendada é para usar a TraceSource classe para
rastreamento.
Este tópico descreve o uso de junto com um arquivo de configuração do aplicativo. um

TraceSource É possível, embora não recomendado, a usar de rastreamento sem o uso de um
arquivo de configuração. um TraceSource Para obter informações sobre rastreamento sem um
arquivo de configuração, consulte COMO: Criar e inicializar fontes de rastreamento.
Para criar e inicializar a fonte de rastreamento

• A primeira etapa para instrumenting um aplicativo com o rastreamento é para criar uma
fonte de rastreamento. Em grandes projetos com vários componentes, você pode criar uma
fonte de rastreamento separada para cada componente. A prática recomendada consiste em
usar o nome do aplicativo para o nome da fonte de rastreamento. Isso facilitará para manter os
rastreamentos diferentes separadas. O código a seguir cria uma nova fonte de rastreamento
(mySource). (Activity1 e chama um método que rastreia eventos) As mensagens de rastreamento
são gravadas pelo ouvinte de rastreamento padrão.
using System; using System.Diagnostics; using System.Threading; namespace TraceSourceApp { class
Program { private static TraceSource mySource = new TraceSource("TraceSourceApp"); static void
Main(string[] args) { Activity1(); mySource.Close(); return; } static void Activity1() {
mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
mySource.TraceEvent(TraceEventType.Warning, 2, "Warning message."); } } }
Para criar e inicializar escutas de rastreamento e filtros

• Não programaticamente o código no primeiro procedimento não identificar qualquer
escutas de rastreamento ou filtros. O código sozinho resulta nas mensagens de rastreamento
sendo gravadas no ouvinte de rastreamento padrão. Para configurar escutas de rastreamento
específico e seus filtros associados, edite o arquivo de configuração que corresponde ao nome
do seu aplicativo. Contidas nesse arquivo, você pode adicionar ou remover uma escuta, defina

a propriedades e filtro para uma escuta, ou remover ouvintes. O exemplo de arquivo de
configuração a seguir mostra como inicializar uma escuta de rastreamento Console e uma
escuta de rastreamento do gravador de texto para a fonte de rastreamento que é criado no
procedimento anterior. Além de configurar os ouvintes de rastreamento, o arquivo de
configuração cria filtros para ambos os ouvintes de e cria uma opção de origem para a fonte de
rastreamento. Duas técnicas são mostradas para adicionar escutas de rastreamento:
adicionando o ouvinte diretamente para a fonte de rastreamento e adicionando uma escuta à
coleção compartilhada escutas e depois adicioná-lo pelo nome à fonte de rastreamento. Os
filtros identificados para os dois ouvintes são inicializados com níveis de origem diferentes. Isso
resulta em algumas mensagens sendo escrito por apenas um dos dois os ouvintes.
<configuration> <system.diagnostics> <sources> <source name="TraceSourceApp"
switchName="sourceSwitch" switchType="System.Diagnostics.SourceSwitch"> <listeners> <add
name="console" type="System.Diagnostics.ConsoleTraceListener"> <filter
type="System.Diagnostics.EventTypeFilter" initializeData="Warning"/> </add> <add
name="myListener"/> <remove name="Default"/> </listeners> </source> </sources> <switches> <add
name="sourceSwitch" value="Warning"/> </switches> <sharedListeners> <add name="myListener"
type="System.Diagnostics.TextWriterTraceListener" initializeData="myListener.log"> <filter
type="System.Diagnostics.EventTypeFilter" initializeData="Error"/> </add> </sharedListeners>
</system.diagnostics> </configuration>
Para alterar o nível no qual uma escuta grava uma mensagem de rastreamento
• O arquivo de configuração inicializa as configurações para a fonte de rastreamento no
momento o aplicativo é inicializado. Para alterar essas configurações Você deve alterar o
arquivo de configuração e reiniciar o aplicativo ou programaticamente atualizar o aplicativo
usando o System.Diagnostics.Trace.Refresh método. O aplicativo pode alterar propriedades
definidas pelo arquivo de configuração para substituir as configurações especificadas pelo
usuário dinamicamente. Por exemplo, convém garantir que mensagens importantes sempre
são enviadas em um arquivo de texto, independentemente das configurações atuais.
Main(string[] args) { Activity1(); // Change the event type for which tracing occurs. // The console trace
listener must be specified // in the configuration file. First, save the original // settings from the
configuration file. EventTypeFilter configFilter = (EventTypeFilter)mySource.Listeners["console"].Filter;
// Then create a new event type filter that ensures // critical messages will be written.
mySource.Listeners["console"].Filter = new EventTypeFilter(SourceLevels.Critical); Activity2(); // Allow
the trace source to send messages to listeners // for all event types. This statement will override // any
settings in the configuration file. mySource.Switch.Level = SourceLevels.All; // Restore the original filter
settings. mySource.Listeners["console"].Filter = configFilter; Activity3(); mySource.Close(); return; }
static void Activity1() { mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
mySource.TraceEvent(TraceEventType.Warning, 2, "Warning message."); } static void Activity2() {
mySource.TraceEvent(TraceEventType.Critical, 3, "Critical message.");
mySource.TraceInformation("Informational message."); } static void Activity3() {
mySource.TraceInformation("Informational message."); } } }
COMO: Criar e inicializar opção de rastreamento
Para usar opções de rastreamento, você deve primeiro criá-los e colocá-los em seu código Não há
duas classes predefinidas do qual você pode criar objetos Opção: a BooleanSwitch classe e a
TraceSwitch classe. Você deve usar BooleanSwitch se você cuidado somente sobre se ou não
aparece uma mensagem de rastreamento; você usaria TraceSwitch se é necessário para
discriminate entre níveis de rastreamento. Se você pode definir suas próprias mensagens de
depuração e associá-los com níveis de rastreamento diferente. é usado um TraceSwitch Você
pode usar os dois tipos de opção com rastreamento ou depuração. Por padrão, e a TraceSwitch.
está desativado estiver definido como nível TraceLevel.Off um BooleanSwitch Opções de
rastreamento podem ser criado e colocada em qualquer parte do seu código que pode utilizem.
Embora você possa definir níveis de rastreamento e outras opções de configuração no código, é
recomendável que você usar o arquivo de configuração para gerenciar o estado de seu opções.
Isso ocorre porque permite gerenciar a configuração do comutações no sistema de configuração
que você maior flexibilidade — Você pode ativar e desativar várias opções e alterar níveis sem
recompilar o aplicativo. Para obter mais informações, consulte Configurando opções de
rastreamento.
Para criar e inicializar uma opção de rastreamento

1. Defina uma opção como o tipo BooleanSwitch ou tipo TraceSwitch e definir o nome e
descrição da opção.
2. Configure o comutador de rastreamento. Para obter mais informações, consulte
Configurando opções de rastreamento.
O código a seguir cria duas opções, um dos cada tipo:
C#
System.Diagnostics.BooleanSwitch dataSwitch = new System.Diagnostics.BooleanSwitch("Data",
"DataAccess module"); System.Diagnostics.TraceSwitch generalSwitch = new
System.Diagnostics.TraceSwitch("General", "Entire application");
COMO: Compilar condicionalmente com rastreamento e depuração
Enquanto você está depurando um aplicativo durante o desenvolvimento, o rastreamento e

depuração de saída Ir para a janela de saída no Visual Studio. No entanto, para incluir recursos
de rastreamento em um aplicativo implantado, você deve compilar os aplicativos disponíveis com
a TRACE diretiva compilador ativada. Isso permite que código de rastreamento para ser
compilado na versão de lançamento do seu aplicativo. Se você não ativar a TRACE diretiva, todo
código de rastreamento será ignorado durante a compilação e não está incluída no código
executável que você irá implantar.
O Rastreamento e depuração métodos têm associados atributos condicionais. Por exemplo, se o

atributo condicional para rastreamento for true, todas as instruções de rastreamento são incluídas
dentro um conjunto (um arquivo compilado.exe ou.dll); se o Trace atributo condicional for false, as
instruções de rastreamento não estão incluídas.
Você pode ter um ou Debug atributo condicional ativada para uma criação, ou ambos, ou
nenhum. o Trace Assim, existem quatro tipos de compilação: Debug, Trace, dois, ou nenhum.
Alguns compilações de versão para implantação de produção podem conter nenhum; compilações
de depuração mais conter ambos.
Você pode especificar as configurações do compilador do seu aplicativo de várias maneiras:
• As páginas de propriedades
• A linha de comando
• (#CONST para Visual Basic e #define (para C#))
Para alterar as configurações de compilação da caixa de diálogo páginas Propriedade

1. Clique com o botão direito do mouse no nó no Solution Explorer projeto.
2. Escolha Properties no menu de atalho.
3. Na caixa Property Page de diálogo que aparece, clique na Configuration Properties guia
no painel esquerdo e escolha a Build opção.
4. Escolha as configurações do compilador desejado.
o No Visual Basic, marque as caixas de seleção para as configurações do compilador
você deseja ativar. Desmarque as caixas de seleção para configurações você deseja
desativar.
o Em C#, no campo Conditional Compilation Constants, digite o nome da
configuração você deseja ativar.
Visual C# Observação
Para habilitar o Debug e rastreamento, digite DEBUG;TRACE (ou TRACE;DEBUG). Excluir o

nome de qualquer configuração você deseja desativar. C# diferenciar maiúsculas de minúsculas,
e os nomes Configuração deverão ser maiúsculos.
Para compilar disponíveis código usando a linha de comando

• Definir uma opção de compilador condicional na linha de comando. O compilador irá incluir
rastreamento ou depurar código no executável.
Por exemplo, a seguinte instrução do compilador inserida na linha de comando incluiria seu
código de rastreamento em um executável compilado:
Para Visual Basic: vbc /r:System.dll /d:TRACE=TRUE /d:DEBUG=FALSE MyApplication.vb
No C#: csc /r:System.dll /d:TRACE /d:DEBUG=FALSE MyApplication.cs
Dica
Para compilar mais de um arquivo do aplicativo, deixe um espaço em branco entre os nomes de
arquivo, por exemplo, MyApplication1.vb MyApplication2.vb MyApplication3.vb ou
MyApplication1.cs MyApplication2.cs MyApplication3.cs.
O significado das diretivas compilation Conditional-usado nos exemplos acima é a seguinte:
Diretiva Significado
vbc Compilador do Visual Basic
csc Compilador C#
/r: Referencia um conjunto externo (exe ou dll)
/d: Define um símbolo de compilação condicional
Observação
Você deverá soletrar Trace ou Debug com letras maiúsculas. Para obter mais informações sobre
os comandos de compilação condicional, digite vbc /? (para Visual Basic) ou csc /? (no C#). No
prompt de comando Para obter mais informações, consulte Criando a partir da linha de comando
(C#) ou Chamar o Compiler de linha de comando (Visual Basic).
Para executar usando # de compilação condicional CONST ou # definir

• Digite a instrução apropriada para a linguagem de programação na parte superior do
arquivo de código de fonte.

Idioma Instrução Resultado
Visual Basic Trace #CONST = True Ativa o rastreamento
Trace #CONST = False Desativa o rastreamento
Debug #CONST = True Ativa a depuração
Debug #CONST = False Desativa depuração
C# # Definir Trace Ativa o rastreamento
# undefine Trace Desativa o rastreamento
# Defina debug Ativa a depuração
# undefine Debug Desativa depuração
Para desativar o rastreamento ou depuração

1. Excluir a diretiva Compilador do seu código fonte.
- ou -
2. Comentário fora a diretiva compilador.
Observação
Do d: quando você está pronto para compilar, ou pode escolher Build do menu ou Build use o
método de linha de comando mas sem digitar para definir símbolos de compilação condicional.
COMO: Criar e inicializar fontes de rastreamento
Fontes de rastreamento podem ser criado e inicializado com ou sem o uso de arquivos de
configuração. A abordagem recomendada consiste em usar arquivos de configuração para facilitar
a reconfiguração dos rastreamentos produzido pelo rastreamento fontes em tempo de execução.
Para criar e inicializar uma fonte de rastreamento usando um arquivo de configuração

1. O código de exemplo a seguir tem finalidade a executados em conjunto com um arquivo de
configuração do aplicativo (mostrado na etapa 2). O arquivo de configuração inicializa as
configurações para a fonte de rastreamento no momento o aplicativo é inicializado. O
aplicativo pode alterar propriedades definidas pelo arquivo de configuração para substituir as
configurações especificadas pelo usuário dinamicamente. Por exemplo, convém garantir que
mensagens importantes sempre são enviadas em um arquivo de texto, independentemente
das configurações atuais. O código de exemplo a seguir demonstra a substituição das
configurações de arquivo para assegurar mensagens críticas são saída para os ouvintes de
rastreamento. Alterar as configurações de arquivo durante a execução do aplicativo não
altera as configurações iniciais. Para fazer que você deve reiniciar o aplicativo ou
programaticamente atualizar o aplicativo usando o Refresh método.
Main(string[] args) { Activity1(); // Change the event type for which tracing occurs. // The console
trace listener must be specified // in the configuration file. First, save the original // settings from the
configuration file. EventTypeFilter configFilter =
(EventTypeFilter)mySource.Listeners["console"].Filter; // Then create a new event type filter that
ensures // critical messages will be written. mySource.Listeners["console"].Filter = new
EventTypeFilter(SourceLevels.Critical); Activity2(); // Allow the trace source to send messages to

listeners // for all event types. This statement will override // any settings in the configuration file.
mySource.Switch.Level = SourceLevels.All; // Restore the original filter settings.
mySource.Listeners["console"].Filter = configFilter; Activity3(); mySource.Close(); return; } static void
Activity1() { mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
2. Do TraceSource TraceSourceApp criar o arquivo de configuração a seguir ao inicializar no

exemplo de código. O arquivo de configuração para um aplicativo hospedado pelo host
executável é no mesmo diretório como o aplicativo. O nome do arquivo de configuração é o
nome do aplicativo com uma extensão.config. Para nosso exemplo, TraceSourceApp.exe
pode ser associado com um arquivo de configuração denominado
TraceSourceApp.exe.config. O exemplo de arquivo de configuração a seguir mostra como
inicializar uma escuta de rastreamento Console e uma escuta de rastreamento do gravador
de texto para a fonte de rastreamento que é criado na etapa anterior. Além de configurar os
ouvintes de rastreamento, o arquivo de configuração cria filtros para ambos os ouvintes de e
cria uma opção de origem para a fonte de rastreamento. Duas técnicas são mostradas para
adicionar escutas de rastreamento: adicionando o ouvinte diretamente para a fonte de
rastreamento e adicionando uma escuta à coleção compartilhada escutas e depois adicioná-
lo pelo nome à fonte de rastreamento. Os filtros identificados para os dois ouvintes são
inicializados com níveis de origem diferentes. Isso resulta em algumas mensagens sendo
escrito por apenas um dos dois os ouvintes.
<configuration> <system.diagnostics> <sources> <source name="TraceSourceApp"
switchName="sourceSwitch" switchType="System.Diagnostics.SourceSwitch"> <listeners> <add
name="console" type="System.Diagnostics.ConsoleTraceListener"> <filter
type="System.Diagnostics.EventTypeFilter" initializeData="Warning"/> </add> <add
name="myListener"/> <remove name="Default"/> </listeners> </source> </sources> <switches>
<add name="sourceSwitch" value="Warning"/> </switches> <sharedListeners> <add
name="myListener" type="System.Diagnostics.TextWriterTraceListener"
initializeData="myListener.log"> <filter type="System.Diagnostics.EventTypeFilter"
initializeData="Error"/> </add> </sharedListeners> </system.diagnostics> </configuration>
Ao inicializar fontes de rastreamento, escuta, e filtros sem um arquivo de configuração

• Você pode instrumento rastreamento por uma fonte de rastreamento completamente
embora código sem o uso de um arquivo de configuração. Isso não é recomendável prática,
mas não pode ser circunstâncias em que você não desejam dependem do arquivos de
configuração para garantir o rastreamento.
Main(string[] args) { mySource.Switch = new SourceSwitch("sourceSwitch", "Error");
mySource.Listeners.Remove("Default"); TextWriterTraceListener textListener = new
TextWriterTraceListener("myListener.log"); ConsoleTraceListener console = new
ConsoleTraceListener(false); console.Filter = new EventTypeFilter(SourceLevels.Information);
console.Name = "console"; textListener.Filter = new EventTypeFilter(SourceLevels.Error);
mySource.Listeners.Add(console); mySource.Listeners.Add(textListener); Activity1(); // Set the filter
settings for the // console trace listener. mySource.Listeners["console"].Filter = new
EventTypeFilter(SourceLevels.Critical); Activity2(); // Allow the trace source to send messages to //

listeners for all event types. mySource.Switch.Level = SourceLevels.All; // Change the filter settings for
the console trace listener. mySource.Listeners["console"].Filter = new
EventTypeFilter(SourceLevels.Information); Activity3(); mySource.Close(); return; } static void
Activity1() { mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
Aperfeiçoando a depuração com o atributo de exibição do

depurador
Atributos de exibição depurador permitir que o desenvolvedor do tipo, que especifica e melhor
entende o comportamento em tempo de execução desse tipo, para especificar o que também
desse tipo aparência da quando ele for exibido em um depurador. Além disso, depurador atributos
de exibição que fornecem uma Target propriedade podem ser aplicados no nível do conjunto por
usuários sem conhecimento do código-fonte. O DebuggerDisplayAttribute atributo controla como
um tipo ou membro é exibido nas janelas variável depurador. O DebuggerBrowsableAttribute
atributo determina se e como um campo ou propriedade é exibida nas janelas variável depurador.
O DebuggerTypeProxyAttribute atributo especifica um tipo substituto, ou um proxy, para um tipo e
alterações a maneira como o tipo é exibido em janelas depurador. Quando você exibir uma
variável que possui um proxy, ou tipo substituto, o proxy significa em para o tipo original na janela
. de exibição depurador A janela variável depurador exibe somente os membros do tipo proxy
públicos. Membros particulares não são exibidos.
Usando o DebuggerDisplayAttribute
O DebuggerDisplayAttribute Construtor tem um argumento único: uma seqüência para ser exibido
na coluna Valor para. instâncias do tipo This string can contain braces ({ and }). O texto contido
em um par de chaves é avaliado como uma expressão. Por exemplo, faz com o seguinte código
C# ". Count = 4 " a ser exibida ao sinal de mais (+) está selecionado para expandir a exibição
depurador para uma instância de MyHashtable
[DebuggerDisplay("Count = {count}")] class MyHashtable { public int count = 4; }
Atributos aplicados às propriedades mencionadas na expressão não serão processados. Para o

compilador C#, uma expressão geral é permitido que tenha apenas acesso implícito referente à
instância atual do tipo de destino a essa referência. A expressão é limitada; não é nenhum acesso
a aliases, locais, ou ponteiros. No código C#, você pode usar uma expressão geral entre as
chaves que tenha acesso implícito ao this ponteiro para a instância atual do apenas o tipo de
destino.
Por exemplo, se um objeto C# tem um substituído ToString(), será chamada a substituição e

mostrar seu resultado o depurador em vez do Thus Padrão {<typeName>}., se você tiver
substituído ToString(), você não precisa usar DebuggerDisplayAttribute. Se você usar ambos, o
DebuggerDisplayAttribute atributo prevalece sobre a ToString() substituição.
Usando o DebuggerBrowsableAttribute
Do DebuggerBrowsableAttribute Aplicar a um campo ou propriedade para especificar como o

campo ou propriedade deve ser exibida na janela do depurador. O construtor para este atributo

tem um dos valores DebuggerBrowsableState de enumeração, que especifica um dos seguintes
estados:
• indica Never que o membro não é exibido na janela de dados. Por exemplo, usar esse
valor para um campo remove o campo de hierarquia; o campo não é exibido quando você
expande o tipo delimitador, clicando no sinal de mais (+) para a instância Tipo. na
DebuggerBrowsableAttribute
• indica Collapsed que o membro é exibido mas não expandidos por padrão. Esse é o
comportamento padrão.
• indica RootHidden que o membro próprio não é exibido, mas seus objetos constituintes
serão exibidos se ele é uma matriz ou coleção.
Observação
O DebuggerBrowsableAttribute não oferece suporte ao Visual Basic no .NET Framework versão

2.0.
Do DebuggerBrowsableAttribute o exemplo de código a seguir mostra o uso de para impedir

que a propriedade após ele seja exibido na janela de depuração para a classe.
[DebuggerBrowsable(DebuggerBrowsableState.Never)] public static string y = "Test String";
Usando o DebuggerTypeProxy
Use o DebuggerTypeProxyAttribute atributo quando você precisa para significativamente e

fundamentalmente altera o modo de exibição de depuração de um tipo, mas não alterar o tipo
próprio. O DebuggerTypeProxyAttribute atributo é usado para especificar um proxy de exibição
para um tipo, permitindo que um desenvolvedor para adaptar o modo de exibição para o tipo.
Esse atributo, como o DebuggerDisplayAttribute, pode ser usado no nível do conjunto, no qual a
Target propriedade caso especifica o tipo para que o proxy será usado. O uso recomendado é que
este atributo especifica um tipo aninhado particular que ocorre dentro do tipo ao qual o atributo é
aplicado. Um avaliador expressão que oferece suporte digite visualizadores verifica para este
atributo quando um tipo é exibido. Se o atributo for encontrado, o avaliador expressão substituirá o
tipo de proxy para o tipo do atributo é aplicado a exibição.
Quando a janela variável depurador exibe somente os membros do tipo proxy públicos. estiver
presente, o DebuggerTypeProxyAttribute Membros particulares não são exibidos. O
comportamento da janela de dados não é alterado por modos de exibição avançada atributo-.
Para evitar criminais de desempenho desnecessários, atributos do proxy de exibição não serão
processados até que o objeto estiver expandido, através o usuário clica em sinal de mais (+) ao
lado do tipo em uma janela de dados, ou através do aplicativo do atributo
DebuggerBrowsableAttribute. Portanto, é recomendável que nenhum atributo seja aplicada ao
tipo de exibição. Atributos podem e devem ser aplicadas dentro do corpo do tipo de exibição.
Do DebuggerTypeProxyAttribute o exemplo de código a seguir mostra o uso de para especificar

um tipo a ser usado como um proxy de exibição depurador.
[DebuggerTypeProxy(typeof(HashtableDebugView))] class MyHashtable : Hashtable { private const string

TestString = "This should not appear in the debug window."; internal class HashtableDebugView { private
Hashtable hashtable; public const string TestStringProxy = "This should appear in the debug window."; //
The constructor for the type proxy class must have a // constructor that takes the target type as a parameter.
public HashtableDebugView(Hashtable hashtable) { this.hashtable = hashtable; } } }

Exemplo
Descrição
O exemplo de código a seguir pode ser exibido em Visual Studio 2005 Para ver os resultados da
aplicação o DebuggerDisplayAttribute, DebuggerBrowsableAttribute., e
DebuggerTypeProxyAttribute atributos
Código
C#
using System; using System.Collections; using System.Diagnostics; using System.Reflection; //[assembly:
DebuggerTypeProxy("MyHashtable.HashtableDebugView",TargetTypeName="MyHashtable")] class
DebugViewTest { // The following constant will appear in the debug window for DebugViewTest. const string
TabString = " "; // The following DebuggerBrowsableAttribute prevents the property following it // from
appearing in the debug window for the class. [DebuggerBrowsable(DebuggerBrowsableState.Never)] public
static string y = "Test String"; static void Main(string[] args) { MyHashtable myHashTable = new
MyHashtable(); myHashTable.Add("one", 1); myHashTable.Add("two", 2);
Console.WriteLine(myHashTable.ToString()); Console.WriteLine("In Main."); } }
[DebuggerDisplay("{value}", Name = "{key}")] internal class KeyValuePairs { private IDictionary dictionary;
private object key; private object value; public KeyValuePairs(IDictionary dictionary, object key, object value)
{ this.value = value; this.key = key; this.dictionary = dictionary; } } [DebuggerDisplay("Count = {Count}")]
[DebuggerTypeProxy(typeof(HashtableDebugView))] class MyHashtable : Hashtable { private const string
TestString = "This should not appear in the debug window."; internal class HashtableDebugView { private
Hashtable hashtable; public const string TestString = "This should appear in the debug window."; public
HashtableDebugView(Hashtable hashtable) { this.hashtable = hashtable; }
[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] public KeyValuePairs[] Keys { get {
KeyValuePairs[] keys = new KeyValuePairs[hashtable.Count]; int i = 0; foreach(object key in hashtable.Keys)
{ keys[i] = new KeyValuePairs(hashtable, key, hashtable[key]); i++; } return keys; } } } }
Como: Rastrear código em um aplicativo
A Trace classe permite-lhe instrumento seu aplicativo. Você pode receber mensagens
informativas do aplicativo em execução que pode ajudar a diagnosticar problemas ou analisar o
desempenho. Esta é uma visão geral das etapas principais normalmente envolvidas na Usar
rastreamento para analisar e corrigir possíveis problemas em aplicativos implantados. Para obter
mais informações sobre como executar essas etapas, consulte o link apropriado.
Para usar o rastreamento em um aplicativo

1. Considere qual rastreamento saída será você deseja que receba onsite após você ter
implantou o aplicativo.
2. Criar um conjunto de opções. Para obter mais informações, consulte Criando e ao
inicializar opções de rastreamento.
3. Adicionar as instruções de rastreamento ao código do aplicativo.
4. Determinar onde você deseja a saída de rastreamento para aparecem e adicionar os
ouvintes apropriados. Para obter mais informações, consulte Criando e ao inicializar
Listeners do rastreamento.
5. Testar e depurar seu aplicativo e o código de rastreamento que ele contém.
6. Compilar o aplicativo em código executável usando um dos seguintes procedimentos:

o Use o Build menu juntamente com a Debug página da caixa Property Pages de
diálogo no Solution Explorer. Use isso quando compilar no Visual Studio.
- ou -
o Do Trace uso e Debug diretivas de compilador para o método de linha de comando
de compilação. Para obter mais informações, consulte Compilando condicionalmente com
Rastreamento e depuração. Use isso quando compilar a partir da linha de comando.
7. Se ocorrer um problema durante o tempo de execução, ative a opção de rastreamento
apropriada. Para obter mais informações, consulte Configurando opções de rastreamento.
O código de rastreamento grava Rastrear mensagens para um destino especificado, por
exemplo, uma tela, um arquivo de texto, ou um log de eventos. O tipo de escuta é incluído
na coleção Trace.Listeners determina o destino.
8. Analisar as mensagens de rastreamento para identificar e entender o problema no
aplicativo.
COMO: Configurar opções de rastreamento
Pode após tem o aplicativo foi distribuído, você ainda ativar ou desativar a saída de rastreamento
ao configurar as opções de rastreamento em seu aplicativo. Configurar uma opção significa
alteração seu valor de uma fonte externa depois ele foi inicializado. Você pode alterar os valores
dos objetos opção usando o arquivo de configuração. Você configurar uma opção de
rastreamento para ativá-lo logon e logoff, ou para definir seu nível, determinar a quantidade e
digite de mensagens-passa junto para escuta.
Comutações são configuradas usando o arquivo.config. Para um aplicativo da Web, este é o

arquivo web.config associado ao projeto. Em um aplicativo do Windows, este arquivo é nomeado
(nome do aplicativo). exe.config. Em um aplicativo implantado, esse arquivo deve residir na
mesma pasta como executável.
Quando o aplicativo executa o código que cria uma instância de uma opção para a primeira vez,
ele verifica o arquivo de configuração para nível rastreamento-informações sobre a opção
nomeada. O sistema de rastreamento examina o arquivo de configuração apenas uma vez para
qualquer opção — específica na primeira vez seu aplicativo cria a opção.
Em um aplicativo implantado, você Ativar código de rastreamento por reconfigurando objetos

opção quando seu aplicativo está sendo executado. Isso normalmente envolve os objetos opção
Ativar e desativar ou, alterando os níveis de rastreamento, e reiniciando o aplicativo.
Quando você cria uma instância de uma opção, você também inicializá-lo, especificando dois
argumentos: um displayName argumento e um description argumento. O displayName argumento
do construtor define a Switch.DisplayName propriedade da instância Opção de classe. O
displayName é o nome que é usado para configurar a opção no arquivo.config, e o description
argumento deve retornar uma breve descrição da opção e que mensagens ele controles..
Em além para Especifica o nome de uma opção para configurar, você também deve especificar
um valor para a opção. Esse valor é um Integer. Para BooleanSwitch um valor de 0 corresponde
a Off, e corresponde a On qualquer valor diferente de zero. Para TraceSwitch, 0,1,2,3, e 4
corresponde Off, Error e Verbose, respectivamente., Warning, Info Qualquer número maior que
4 é tratada como Verbose, e qualquer número menor que zero é tratado como Off.
Para que os usuários para que seja possível para configurar opções de rastreamento de um
aplicativo, você deve fornecer documentação detalhada sobre as opções em seu aplicativo. Você
deve detalhes quais opções controlam o que e como eles ativar e desativar. Você também deve
fornecer o usuário final com um arquivo.config que tenha ajuda apropriada nos comentários.

Alterna para criar e configurar rastreamento
1. Criar comutações no código. Para obter mais informações, consulte Criando e ao inicializar
opções de rastreamento.
2. Se o projeto não contém um arquivo de configuração (App.config ou Web.config), seguida,
no menu Project, selecione Add New Item.
o Na Visual Basic: caixa Add New Item de diálogo, escolha Application
Configuration File.
O arquivo de configuração do aplicativo é criada e aberta. Isso é um documento XML cujo
elemento raiz é <configuration>.
o Na Visual C#: caixa Add New Item de diálogo, escolha XML File. Nome este
arquivo app.config. No editor XML, após a declaração XML, adicionar XML a seguir:
<configuration> </configuration>
Quando seu projeto é compilado, o arquivo App.config é copiado para a pasta de saída do
projeto e é renomeado applicationname. exe.config... exe.config
3. Após a <configuration> marca, mas antes da </configuration> marca, adicione o XML
apropriado para configurar comutações. Os exemplos a seguir demonstram com uma
DisplayName propriedade de TraceLevelSwitch. com uma DisplayName propriedade de
DataMessageSwitch e a TraceSwitch uma BooleanSwitch
<system.diagnostics> <switches> <add name="DataMessagesSwitch" value="0" /> <add
name="TraceLevelSwitch" value="0" /> </switches> </system.diagnostics>
Nessa configuração, as duas opções são logoff.

4. Caso você precise ativar como qualquer inteiro diferente de 0. a BooleanSwitch, como
DataMessagesSwitch mostrado no exemplo anterior, alterar o Value
5. Caso você precise ativar com a configuração Nível apropriada (1 a 4). a TraceSwitch,
como TraceLevelSwitch mostrado no exemplo anterior, alterar o Value
6. Adicionar comentários ao arquivo.config para que o usuário final tenha uma compreensão
clara de quais valores para alterar para configurar as opções adequadamente.
O exemplo a seguir mostra o código final, inclusive comentários, a aparência:
<system.diagnostics> <switches>  <add name="DataMessagesSwitch" value="0" />
 <add
name="TraceLevelSwitch" value="0" /> </switches> </system.diagnostics>
Passo-a-passo: Depuração de um serviço XML da Web
As etapas nessa explicação passo a passo mostrarão como depurar um XML Web service. Elas
lhe mostrarão como iniciar e parar a execução e definir pontos de interrupção.
Observação
Por padrão, o processo do ASP.NET, usando o Aspnet_wp.exe ou o W3wp.exe, executa sob a

conta doASP.NET. Por esse motivo, você deve ter privilégios de administrador no computador
onde o ASP.NET será executado para depurá-lo. Para obter mais informações consulte Requisitos

do sistema ASP.NET depuração:.
Observação
As caixas de diálogo e comandos de menu você vê podem diferir daquelas descritas na ajuda
dependendo de sua configuração ou edição ativa . Para alterar as configurações, escolha Import
and Export Settings no menu Tools. Para obter mais informações, consulte Configurações
Visual Studio.
Para se preparar para essa explicação passo a passo

• Se você já tiver uma solução aberta, feche-a.
Para criar e depurar um XML Web service
1. A partir do menuFile, clique em New, e clique em Web Site.
A caixa de diálogo New Web Site será exibida.
2. No painel Templates, selecione ASP.NET Web Service. Agora você pode especificar uma
pasta em sua máquina local, ou uma URL para um computador remoto.
3. Na lista drop-down Location , selecione File System, e na caixa de texto digite o diretório
em sua máquina local onde o XML Web Service será localizado, e especifique um nome de
diretório exclusivo, como Website1. O XML Web service terá o mesmo nome que o diretório.
Se você quisesse, você poderia colocar o diretório em um servidor remoto, ou explorar
outras opções, clicando no botão Browse.
4. Na lista drop-down Language , selecione a linguagem que será usada.
5. Clique em OK.
O Visual Studio cria um novo projeto e Exibe código para o Service.cs, um modelo.
6. Clique na margem próxima à linha:
' Visual Basic Return "Hello World"
-ou-
// C# return "Hello World";
Um ponto vermelho aparecerá e o texto na linha é realçado em vermelho. O ponto vermelho

representa um ponto de interrupção. Quando você executa o aplicativo com o depurador, o
depurador interromperá a execução nesse local quando o código for atingido. Você pode
então ver o estado do seu aplicativo e depurá-lo. Para obter mais informações, consulte
Pontos de interrupção.
7. Verifique se a Active Configuration é a configuração do Debug.
8. No menu Debug, selecione Start ou pressione F5.
9. A caixa de diálogo Debugging Not Enabled será exibida. Selecione a opção Add a new
Web.config file with debugging enabled, e clique em OK.
10. O Internet Explorer abrirá, e exibirá o link Hello World.
11. Clique no link Hello World.
Uma nova página é aberta no Internet Explorer.
12. Na nova página, clique no botão Invoke.
Neste ponto, você atingirá o ponto de interrupção no Visual Studio. Agora você poderá
avaliar variáveis na janela Watch, ver variáveis locais, e avançar através de seu código.

Para anexar-se ao XML Web service para depuração
1. No Visual Studio, você pode anexar o depurador a um processo em execução. O
procedimento a seguir mostra como fazer isso.
2. No projeto atual, clique na margem próxima a linha que contém o seguinte código:
' Visual Basic Return "Hello World" // C# return "Hello World";
Isso define um ponto de interrupção. Você deverá ver um ponto vermelho aparecendo na
margem e um realce vermelho na linha de código.
O XML Web service inicia a execução no Internet Explorer, mas o depurador não está
conectado.
4. No menu Debug, selecione Attach to Process. Você também pode clicar emAttach to
Process no menu Tools.
5. Clique em Show processes from all users.
Observação
Se você estiver através de uma sessão de serviço de terminal ou de área de trabalho remota,
você também deve selecionar Show processes in all sessions.
6. No painel Available Processes, localize WebDev.WebServer.EXE na coluna Process, e

clique nele.
O processo WebDev.WebServer.EXE carrega seu código e exibe-o no Internet Explorer.
Você tiver anexado o depurador ao seu serviço da Web em execução.
8. No Internet Explorer, clique na linha que diz " Hello World ".
Abre uma nova página.
9. Na nova página, clique no botão Invoke.
Nesse ponto, você atingiu o ponto de interrupção no Visual Studio. Agora você pode avaliar
variáveis na janela Watch , ver locais, e avançar através do seu código.
Passo-a-passo: Depuração de um formulário do Windows
Um formulário do Windows é uma das mais comuns aplicativos gerenciados. Um formulário do

Windows cria um aplicativo do Windows padrão. Você pode concluir essa explicação passo a
passo usando Visual Basic, C#, J#, ou C++.
Primeiro, você deve fechar quaisquer soluções abertas.
Para preparar para essa explicação passo a passo

• Se você já tiver uma solução aberta, feche-a. (No menu File, selecione Close Solution.)
Criar um novo formulário do Windows
Em seguida, você criará um novo formulário do Windows.
Para criar o formulário do Windows para essa explicação passo a passo

1. No menu File, escolha New e clique Project.

A caixa de diálogo New Project será exibida.
2. No painel tipos de projeto, abra o nó Visual C#Visual Basic, Visual J# ou Visual C++, em
seguida,
1. Para Visual Basic, Visual C# ou Visual J#, selecione a Windows., em seguida,
marque Windows Application no painel Templates.
2. Para Visual C++, selecione o CLR.
3. No painel Templates, selecione Windows Application.
4. Na caixa Name, dê ao projeto um nome exclusivo (por exemplo,
Walkthrough_SimpleDebug).
5. Clique em OK.
Visual Studio cria um novo projeto e exibe um novo formulário no Windows Forms .
PaDesignerra obter mais informações, consulte Windows Forms Designer.
6. No menu View, selecione Toolbox.
Abre a caixa de ferramentas. Para obter mais informações, consulte Caixa de ferramentas.
7. Na caixa de ferramentas, clique sobre o controle Button e arraste o controle para a
superfície de projeto de formulário. Solte o botão no formulário.
8. Na caixa de ferramentas, clique sobre o controle TextBox e arraste o controle para a
superfície de projeto de formulário. Solte a TextBox no formulário.
9. Na superfície de projeto de formulário, clique duas vezes no botão.
Isso leva você para a página de código. O cursor deve estar no button1_Click.
10. Na função button1_Click., adicione o seguinte código:
11. No menu Build, selecione Build Solution.

O projeto deve criar-se com erros.
Depurar seu formulário
Agora, você está pronto para iniciar a depuração.
Para depurar o formulário do Windows criado para essa explicação passo a passo
1. Na janela de origem, clique na margem esquerda na mesma linha quo o texto foi
adicionado:
Um ponto vermelho aparece e o texto na linha é realçado em vermelho. O ponto vermelho

representa um ponto de interrupção. Para obter mais informações, consulte Pontos de
interrupção. Quando você executa o aplicativo sob o depurador, o depurador interromperá a
execução nesse local quando o código é controntado. Você pode exibir o estado do seu
aplicativo e depurá-lo.
2. A partir do menu Debug, escolha Start.
O formulário do Windows começa a ser executado.
3. No formulário do Windows, clique no botão que você adicionou.
No Visual Studio, isso leva você para a linha onde você define o ponto de interrupção na
página de código. Esta linha deve ser realçada em amarelo. Agora você pode exibir as

variáveis no seu aplicativo e controlar sua execução. Agora o aplicativo foi interrompido
quando executava, aguardando uma ação de você.
Observação
Se você tiver definido a Active Solution Configuration como Release, a execução não será
paralisada no ponto de interrupção. Isso simula o comportamento de um programa na versão real.
O círculo que marca o ponto de interrupção irá conter um ponto de interrogação branco. Se
necessário, use a caixa de diálogo Configuration Manager para alterar essa configuração
novamente para Debug.
4. No menu Debug, escolha Windows, em seguida Watch, e clique em Watch1.

5. Na janela Watch1, clique em um linha em branco. Na coluna Name, digite textBox1.Text (se
você estiver usando Visual Basic, Visual C#, ou J#) ou textBox1->Text (se você estiver
usando C++), pressione ENTER.
A janela Watch1 mostra o valor dessa variável entre aspas como:
""
6. A partir do Menu Debug, escolha Step Into.

O valor de textBox1.Text muda na janela Watch1 para:
Button was clicked!
7. A partir do Menu Debug, escolha Continue para continuar a depuração do programa.

8. No formulário do Windows, clique no botão novamente.
Visual Studio quebra a execução novamente.
9. Clique no ponto vermelho que representa o ponto de interrupção.
Isso remove o ponto de interrupção do seu código.
10. A partir do Menu Debug, escolha Stop Debugging.
Anexar ao seu formulário para depuração
No Visual Studio 2005, você pode anexar o depurador a um processo em execução. Se você
estiver usando um Edition Express, não há suporte para este recurso.
Para anexar ao formulário do Windows para depuração

1. No projeto criado acima, clique Na margem esquerda para definir mais uma vez um ponto
de interrupção na linha que você adicionou:
' Visual Basic textBox1.Text = "Button was clicked!" // C# textBox1.Text = "Button was clicked!" // J#

O formulário do Windows inicia executando sob Windows, como se você tivesse clicado
duas vezes seu executável. O depurador não está anexado.
3. No menu Debug, selecione Attach to Process. (Este comando também está disponível a
partir do menuTools.)
A caixa de diálogo Attach to Process será exibida.
4. No painel Available Processes, localize o nome do processo
(Walkthrough_SimpleDebug.exe) na coluna Process e clique nele.

6. No seu formulário do Windows, clique em um e somente um botão.
O depurador quebra a execução do formulário do Windows no ponto de interrupção.
Passo-a-passo: Depuração da função SQL CLR definida pelo usuário com valores em tabela
Este exemplo mostra como depurar uma função table-valued definida pelo usuário SQL CLR
(UDF).
Observação
dependendo de suas 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 Visual Studio.
Para depurar uma função table-valued definida pelo usuário SQL CLR
1. Em um novo projeto SQL Server estabeleça uma conexão a um banco de dados. Para
obter mais informações, consulte Como conectar-se a um banco de dados:.
2. Crie uma nova função usando o código da primeira seção de exemplo abaixo e a nomeie
TableOfPtimes.cs. Para obter mais informações, consulte Como Develop com o tipo do
Project Server SQL:.
3. Adicione um script que testa a função, incluindo-a em uma instrução SELECT. No Solution
Explorer, clique com o botão direito do mouse no diretório TestScripts, clique em Add Test
Script, e inserir o código da segunda das seções de exemplo a seguir. Salve o arquivo com
o nome ReadEventLog.sql. Clique com o botão direito do mouse no nome de arquivo, e
clique em Set as Default Debug Script.
4. Como você está acessando o Event Log, você deve alterar o Permission Level no banco
de dados clicando o nó do nome do projeto no Project Explorer, e clicando em Properties.
Na caixa de propriedade que aparece no editor de textos, clique na guia Database, e em
seguida, defina o Permission Level para Unsafe.
O depurador não oferece suporte completo a depuração de assemblies inseguros. Em
assemblies inseguros, você pode criar novos segmentos e chamar código não gerenciado,
mas esses itens não são suportados pela depuração SQL CLR.
5. Defina pontos de interrupção no ReadEventLog.cs, e em seguida no menu Debug, clique
em Start para compilar, implantar, e fazer o teste de unidade do projeto. Quando o ponteiro
de instrução, designado por uma seta amarela, aparece em um ponto de interrupção, você
está depurando o código SQL CLR.
6. Experimente recursos de depuração diferentes.

1. No menu Debug, clique em Step Into repetidamente para observar a execução
linha por linha da função.
2. Conforme você depura a função, você pode usar as janelas Locals e Watch para
observar os valores dos diferentes membros.
3. Clique em Continue novamente para concluir a depuração da função.
4. Na janela Output, selecione Database Output na lista suspensa Show output
from, e você pode observar os resultados da execução das duas consultas no script
TestPrims.sql.
Exemplo
Este é o código que lê o log de eventos.
using System; using System.Data; using System.Data.Sql; using System.Data.SqlTypes; using

Microsoft.SqlServer.Server; using System.Collections; public partial class UserDefinedFunctions { struct
primeIndex { public int n; public int p; public primeIndex(int n, int p) { this.n = n; this.p = p; } } static bool
isPrime(int p) { if (p < 2) return false; if (p == 2) return true; if (p % 2 == 0) return false; for (int d = 3; d * d
< p; d+=2) { if (p % d == 0) return false; } return true; } static int nextPrime(int p) { int result = p + 1; while
(!isPrime(result)) result++; return result; } [SqlFunction(FillRowMethodName = "Fill", TableDefinition = "n
int,p int,est float")] public static IEnumerable TableOfPrimes(int n) { int p = 1; for (int i = 1; i <= n; i++) { p =
nextPrime(p); yield return new primeIndex(i, p); } } private static void Fill(object source, out int n, out int p,
out SqlDouble est) { primeIndex pi = (primeIndex)source; n = pi.n; p = pi.p; if (n <5) est = SqlDouble.Null;
else { double log = Math.Log(n); double loglog = Math.Log(log); est = n * (log + loglog - 1 + loglog / log - 2 /
log); } } }
Este é o script de teste que chama a função.
SELECT n,p,est FROM dbo.TableOfPrimes(50) SELECT TOP 10 n, p, est, est/p AS factor FROM
dbo.TableOfPrimes(500) ORDER BY factor DESC SELECT TOP 10 n, p, est, est/p AS factor FROM
dbo.TableOfPrimes(1000) WHERE n>500 ORDER BY factor DESC
Passo-a-passo: Depuração de um disparador SQL CLR
Este exemplo mostra como depurar um disparador CLR SQL. Ele usa a tabela Contact no banco
de dados de exemplo AdventureWorks, que é um dos bancos de dados instalado com SQL
Server 2005. O exemplo cria um novo disparador CLR inserir na tabela Contact.

Observação
As caixas de diálogo e comandos de menu você vê pode diferir daquelas descritas na ajuda
dependendo de suas configurações ativas ou versão. Para alterar as configurações, escolha
Para depurar um disparador CLR SQL:

1. Em um novo projeto do SQL Server, estabelecer uma conexão para o banco de dados
AdventureWorks. Para obter mais informações, consulte Como conectar-se a um banco de
dados:.
2. Criar um novo disparador usando o código da primeira seção do exemplo abaixo, e
nomeá-lo iContact.cs. Para obter mais informações, consulte Como Develop com o tipo do
Project Server SQL:.
3. Adicionar um script que testa o disparador gerando uma ativação. No Solution Explorer
clique com o botão direito do mouse no diretório TestScripts, clique Add Test Script, e
insira o código da segunda seção do exemplo abaixo. Salve o arquivo com o nome
truContact.sql. Clique com o botão direito do mouse no nome de arquivo e clique em Set
as Default Debug Script.
4. Defina pontos de interrupção no iContact.cs, e clique em Start do menu Debug para
compilar, implantar e testar a unidade do projeto. Quando o ponteiro de instrução, designado
por uma seta amarela, aparecer em um ponto de interrupção, você está depurando o
disparador.
1. Passe a instrução instanciando o SqlTriggerContext.
2. Abra a janela Locals. Observe que você pode abrir a variável triggContext, que é a
SqlTriggerContext, e você pode examinar seus membros. Para obter mais informações,
consulte Como: usar janelas variáveis do depurador.
Observação
O servidor pode não refletir as alterações em valores de variáveis nas janelas do depurador. Par
obter mais informações, consulte Limitações depuração SQL.
3. Escolha Step Into no menu Debug para passar uma linha na stored procedure.
Observe que a execução tem instanciado o valor da variável sqlP do tipo SqlPipe.
4. Abra a janela Watch. Arraste a variável sqlP para qualquer local na janela Watch. A
variável agora é adicionada à lista de variáveis observadas. Para obter mais
informações, consulte Como: usar janelas variáveis do depurador.
Observação
Você pode editar os valores das variáveis na janela Watch.
5. No editor de texto, clique com o botão direito do mouse na linha última e clique em
Insert Breakpoint.
6. No menu Debug, clique Continue e o depurador executará o código até o novo
ponto de interrupção.

6. Clique Continue novamente para concluir a depuração do disparador. Uma mensagem
aparece na janela Output informando que o disparador foi depurado com êxito e exibe o
resultado da execução dos comandos no arquivo truContact.sql.
Exemplo
Isso é o código necessário para criar o disparador usado neste exemplo.
using System; using System.Data; using System.Data.Sql; using Microsoft.SqlServer.Server; public partial
class Triggers { // Enter existing table or view for the target and uncomment the attribute line.
[Microsoft.SqlServer.Server.SqlTrigger (Name="Trigger1", Target="primes", Event="FOR UPDATE")] public
static void Trigger1() { SqlTriggerContext triggContext = SqlContext.TriggerContext; SqlPipe sqlP =
SqlContext.Pipe; sqlP.Send("primes inserted!"); } }
Este é o script de teste que fará com que o disparador seja acionado.
UPDATE Person.Contact SET MiddleName = 'A' WHERE ContactID = 8
Passo-a-passo: Depuração de um tipo SQL CLR definido pelo usuário
Pro/Team Sim Sim Sim Sim Sim
Este exemplo mostra como depurar um tipo SQL CLR definido pelo usuário. Ele cria um novo tipo
SQL CLR no banco de dados de exemplo AdventureWorks. O tipo depois é usado em uma
definição de tabela, uma instrução INSERT, e em seguida em uma instrução SELECT.
Observação
dependendo de suas configurações ativas ou edição. Para alterar as configurações, escolha
Para depurar um tipo CLR SQL definido pelo usuário

1. Em um novo projeto do SQL Server, estabeleça uma conexão com a banco de dados de
exemplo AdventureWorks. Para obter mais informações, consulte Como conectar-se a um
banco de dados:.
2. Crie um novo tipo usando o código da primeira seção exemplo abaixo, e nomeie-a
Point.cs. Para obter mais informações, consulte Como Develop com o tipo do Project Server
SQL:.

3. Adicione um script que testa o tipo. No Solution Explorer, clique com o botão direito do
mouse no diretório TestScripts , clique Add Test Script, e insera o código da segunda
seção de exemplo abaixo. Salve o arquivo com o nome Point.sql. Clique com o botão direito
do mouse no nome de arquivo, e clique em Set as Default Debug Script.
4. Adicione pontos de interrupção.
1. Na pasta Types no Server Explorer, abra Point.
2. Insira um ponto de interrupção dentro de cada método de modo que você possa
observar o fluxo de controle no interior do tipo.
5. A partir do menu Debug, escolha Start para compilar, implantar, e testar o projeto. Quando
o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de interrupção,
você está depurando sua função.
1. O método Parse é executado uma vez para cada instrução INSERT no script no
Point.sql. Repetidamente clicando Step Into no Debug menu, você pode observar
como o método converte um par de números delimitado por dois-pontos em um objeto
Point.
2. Na janela Locals, abra a variável pt, que contém o Point que está sendo criado
atualmente.
3. No editor de texto, clique duas vezes a variável pt para selecioná-la. Arraste pt para
qualquer local na janela Watch. Agora pt é adicionado à lista de variáveis observadas,
e você pode observá-la comforme o Point é executado.
4. Depurar a classe várias vezes e observar as diferenças entre os caminhos de um
INSERT e um SELECT.
5. Pressione Continue novamente para concluir a depuração da função.
Exemplo
Isso é o código que define o tipo usado neste exemplo. Este código cria uma tabela denominada
pontos, insere linhas nela, e imprime o conteúdo da tabela. Observe que você não deve incluir o
comando em lote GO entre a criação da tabela e seu acesso. Na verdade Visual Studio 2005
interpretará o GO como um comando SQL inválido.
using System; using System.Data.Sql; using System.Data.SqlTypes; using System.Runtime.Serialization;

[Serializable, SqlUserDefinedTypeAttribute(Format.Native)] public struct Point: INullable { private bool
m_isNull; private double m_x; private double m_y; public bool IsNull { get { return (m_isNull); } } public
override string ToString() { if (this.IsNull) { return "NULL"; } else { return this.m_x + ":" + this.m_y; } }
public static Point Parse(SqlString s) { if (s.IsNull) { return Null; } else { // Parse input string here to
separate out points: Point pt = new Point(); string str = Convert.ToString(s); string[] xy = str.Split(':'); pt.X =
Convert.ToDouble(xy[0]); pt.Y = Convert.ToDouble(xy[1]); return (pt); } } public static Point Null { get {
Point pt = new Point(); pt. m_isNull = true; return (pt); } } public double X { get { return (this.m_x); } set {
m_x = value; } } public double Y { get { return (this.m_y); } set { m_y = value; } } }
CREATE TABLE dbo.Points ( ID int IDENTITY(1,1) PRIMARY KEY, Pnt Point) INSERT INTO dbo.Points
(Pnt) VALUES (CONVERT(Point, '3:4')) INSERT INTO dbo.Points (Pnt) VALUES (CONVERT(Point, '-1:5'))
INSERT INTO dbo.Points (Pnt) VALUES (CAST ('1:99' AS Point)) SELECT ID, Pnt.ToString() as StringPoint,
Pnt.X as X, Pnt.Y as Y FROM dbo.Points

Passo-a-passo: Depuração de uma função SQL CLR escalar definida pelo usuário
Este exemplo mostra como depurar uma função SQL CLR definida pelo usuário (UDF). Ele cria
uma nova função SQL CLR definida pelo usuário no banco de dados de exemplo
AdventureWorks.
Observação
As caixas de diálogo e comandos de menu você vê podem diferir daquelas descritas na ajuda
dependendo das suas configurações ativas ou versão. Para alterar as configurações, escolha
Para depurar uma função escalar CLR SQL definida pelo usuário
1. Em um novo projeto do SQL Server, estabeleça uma conexão com a banco de dados de
banco de dados:.
2. Criar uma nova função usando o código da primeira seção do exemplo abaixo, e nomeá-la
OrderCount.cs. Para obter mais informações, consulte Como Develop com o tipo do Project
Server SQL:.
3. Adicionar um script que testa a função incluindo-o em uma instrução SELECT. No Solution
Explorer, clique com o botão direito do mouse no diretório TestScripts, clique Add Test
Script e insira o código da segunda seção do exemplo abaixo. Salve o arquivo com o nome
CallOrderCount.sql. Clique com botão direito mouse no nome do arquivo e escolha Set as
Default Debug Script.
4. Coloque um ponto de interrupção no OrderCount.cs na linha que instancia um
SqlCommand, e no menu Debug, clique Start para compilar, implantar e testar a unidade do
projeto. Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no
ponto de interrupção, você está depurando sua função.
5. Experimentar recursos de depuração diferentes.
1. Passe a instrução instanciando o SqlCommand usando Step Into a partir do menu
Debug.
2. Na janela Locals, abra a variável sqlComm, que é o SqlCommand e examine seus
membros.
3. Clique Step Into no menu Debug para passar uma linha na função. Observe que o
membro sqlComm.CommandText foi instanciado tem.

4. No editor de texto, arraste sqlComm para qualquer local na janela Watch. A variável
agora é adicionada à lista de variáveis observadas.
5. Escolha Step Into novamente e observe que uma nova janela rotulada Dynamic T-
SQL abre, exibindo a instrução SQL que está prestes a ser executada.
6. Escolha Step Into por executar a instrução e retornar para a função.
7. Pressione Continue novamente, e observe a segunda janela Dynamic T-SQL que
abre, mostrando o código que retorna o valor da função.
8. Pressione Continue novamente para concluir a depuração da função.
Exemplo
Isso é o código necessário para criar a função.
using System; using System.Data.SqlClient; using Microsoft.SqlServer.Server; public partial class

UserDefinedFunctions { [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.Read)]
public static int OrderCount() { using (SqlConnection conn = new SqlConnection("context
connection=true")) { conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = conn;
cmd.CommandText = "SELECT 42"; //cmd = new SqlCommand("SELECT 42",conn); int result =
(int)cmd.ExecuteScalar(); return result; } } };
SELECT dbo.OrderCount()
Passo-a-passo: Depuração de uma agregação SQL CLR definida pelo usuário
Edição Visual Studio Visual Basic C# C++ J# Visual Web Developer
Este exemplo mostra como depurar uma CLR SQL agregada definida pelo usuário. Ele cria uma
nova função CLR SQL agregada chamada Concatenate no banco de dados de exemplo
AdventureWorks. Quando esta função é chamada em uma instrução SQL, ela irá concatenar
todos os valores para coluna especificada como seu parâmetro de entrada.
Observação
dependendo da suas configurações ativas ou edição. Para alterar as configurações, escolha

Para depurar uma função CLR SQL agregada
1. Em um novo projeto do SQL Server, estabeleça uma conexão com o banco de dados de
banco de dados:.
2. Crie uma nova função usando o código do primeiro dos exemplo de seções a seguir e
denomine-o Concatenate.cs. Para obter mais informações, consulte Como Develop com o
tipo do Project Server SQL:.
3. Adicione um script que testa a função, incluindo-o em uma instrução SELECT. No
Solution Explorer clique com o botão direito do mouse no diretório TestScripts, selecione
Add Test Script, e insira o código da segunda seção de exemplo abaixo. Salve o arquivo
com o nome Concatenate.sql. Clique com o botão direito do mouse no nome de arquivo, e
clique em Set as Default Debug Script.
4. Coloque um ponto de interrupção na Concatenate.cs dentro do método Accumulate na
instrução if. Para fazer isso, clique na margem esquerda cinza da janela do editor de texto, e
no menu Debug, clique em Start, para compilar, implantar, e testar a unidade do projeto.
Quando o ponteiro de instrução, designado por uma seta amarela, aparecer no ponto de
interrupção, significa que você está depurando sua função.
1. O método Accumulate é executado uma vez para cada linha que constitui a cláusula
GROUP BY em script na Concatenate.sql. Repetidamente clicando Step Into no menu
Debug, você pode observar como o resultado do método é criado.
2. Na janela Locals, abra a variável value, que contém o nome de armazenamento
atual sendo processado.
3. Clique na variável this. O nó filho intermediateResult será retornado dessa função, e
contém todos os nomes de armazenamento até o armazenamento presente,
concatenados juntos e separados por vírgulas.
4. No editor de texto, clique duas vezes a variável intermediateResult para selecioná-lo.
Arraste intermediateResult para a janela Watch e solte-a em qualquer lugar na janela. A
variável agora é adicionada à lista de variáveis observadas.
5. Avançe pelo método várias vezes. O valor de intermediateResult será alterado toda
vez através do método, com um nome de armazenamento adicional concatenado até o
final.
6. Clique no ponto de quebra para removê-la, e adicione um ponto de quebra para a
primeira instrução dentro do método Terminate. Esse método retorna o resultado para o
chamador. Para avançar por ele, no menu Debug, clique em Start. Você pode agora
depurar por ele clicando Step Into no menu Debug. Pare quando você chegar na
instrução return.
7. Clique em Continue novamente para concluir a depuração da função.
Exemplo
Este é o código para a função agregada usada no exemplo.
using System; using System.Data.Sql; using System.Data.SqlTypes; using System.Data.SqlServer; using

System.IO; using System.Text; [Serializable] [SqlUserDefinedAggregate( //use CLR serialization to serialize
the intermediate result. Format.UserDefined, //Optimizer property: IsInvariantToNulls=true, //Optimizer
property: IsInvariantToDuplicates=false, //Optimizer property: IsInvariantToOrder=false, //Maximum size
in bytes of persisted value: MaxByteSize=8000) ] public class Concatenate: IBinarySerialize { ///
<summary> /// Variable holds intermediate result of the concatenation /// </summary> private
StringBuilder intermediateResult; /// <summary> /// Initialize the internal data structures ///

</summary> public void Init( ) { intermediateResult = new StringBuilder(); } /// <summary> ///
Accumulate the next value, nop if the value is null /// </summary> /// <param name="value"></param>
public void Accumulate(SqlString value) { if(value.IsNull) { return; }
intermediateResult.Append(value.Value).Append(','); } /// <summary> /// Merge the partially computed
aggregate with this aggregate. /// </summary> /// <param name="other"></param> public void Merge(
Concatenate other) { intermediateResult.Append(other.intermediateResult); } /// <summary> /// Called at
end of aggregation, to return results. /// </summary> /// <returns></returns> public SqlString
Terminate() { string output = string.Empty; //Delete the trailing comma, if any . if (intermediateResult !=
null && intermediateResult.Length > 0) output = intermediateResult.ToString(0,
intermediateResult.Length-1); return new SqlString(output); } public void Read(BinaryReader r) {
intermediateResult = new StringBuilder(r.ReadString()); } public void Write(BinaryWriter w) {
w.Write(intermediateResult.ToString()); } }
SELECT scu.SalesPersonID, dbo.Concatenate(sst.Name) FROM Sales.Customer as scu INNER JOIN

Sales.Store as sst ON scu.CustomerID = sst.CustomerID INNER JOIN Sales.SalesPerson as spr ON
scu.SalesPersonID = spr.SalesPersonID WHERE scu.SalesPersonID = 283 GROUP BY scu.SalesPersonID
Banco de dados de depuração T-SQL

Esta seção contém exemplos demonstrando a depuração para todos os tipos de objeto de banco
de dados T-SQL.
No passado, os desenvolvedores T-SQL freqüentemente escrevam e depuraram seus aplicativos

T-SQL usando a ferramenta SQL Server Query Analyzer. Hoje, Query Analyzer foi substituído pelo
SQL Server Management Studio, que não tem o depurador. Os desenvolvedores T-SQL agora
usam o depurador Visual Studio 2005 em vez disso.
Os desenvolvedores também podem gravar seus aplicativos T-SQL no Visual Studio 2005,
usando um projeto de banco de dados. Independentemente de você escrever seu aplicativo T-
SQL no Visual Studio 2005 ou não, procedimentos de depuração são quase idênticos.
Há três cenários de depuração a serem considerados:
• Depuração em um objeto de banco de dados T-SQL. Para obter mais informações,

consulte Como etapa em um objeto usando Server Explorer:.

• Execução de um script de teste a partir do SQL Server Management Studio. Para obter
mais informações, consulte Como: Depurar T-SQL usando o SQL Server Management Studio:.
• Execução de um script de teste em um projeto de banco de dados do Visual Studio 2005.
Para obter mais informações, consulte Como Develop na T-SQL com o tipo do projeto de
banco de dados:.
A fim de depurar um disparador, você deve iniciar a sessão de depuração em um procedimento

armazenado. Não é possível depurar um script SQL autônomo, fazer com que ele acione um
disparador, e ser capaz de depurar o disparador.
Passo-a-passo: Depuração um disparador T-SQL
Para depurar um disparador, você define um ponto de interrupção em um procedimento

armazenado que fará com que o disparador seja acionado, defina um ponto de interrupção no
disparador, e prossiga como descrito em Passo-a-passo: Depuração de um procedimento T-SQL
armazenado.
Este exemplo usa o banco de dados AdventureWorks, que tem uma tabela Sales.Currency com
um disparador UPDATE disparador. O exemplo inclui um procedimento armazenado que atualiza
uma linha na tabela, fazendo com que o disparador seja acionado. Defina pontos de interrupção
no disparador, e através da execução do procedimento armazenado com parâmetros diferentes,
você pode seguir caminhos de execução diferentes no disparador.
Observação
As caixas de diálogo e comandos de menu que você vê podem diferir daquelas descritas na ajuda
dependendo de seu configurações ou edição ativas. Para alterar as configurações, escolha
Para depurar um disparador SQL

1. Em um novo projeto do SQL Server, estabeleça uma conexão com o banco de dados
AdventureWorks do exemplo . Para obter mais informações, consulte Como conectar-se a
um banco de dados:.
2. Crie um novo procedimento armazenado usando o código da primeira seção de exemplo
abaixo, e denomine-oUpdateCurrency_T_SQL. Para obter mais informações, consulte Como
Develop com o tipo do Project Server SQL:.
3. Defina pontos de interrupção no UpdateCurrency_T_SQL. Isso é opcional, porque a
Depuração Direta de Banco de Dados faz com que a primeira linha do procedimento atue
como um ponto de interrupção.
4. Defina pontos de interrupção para o disparador.
1. Abra o código fonte do disparador, clicando com o botão direito do mouse no nó
Tablesnó e, então, clicando com o botão direito do mouse no nó da tabela
Sales.Currencye, em seguida, clicando duas vezes no ícone para o disparador que é
chamado uCurrency.
2. Clique com botão esquerdo do mouse na margem cinza ao lado da instrução SET
NOCOUNT ON para definir um ponto de interrupção no disparador. Esta etapa não é
opcional : se você não definir um ponto de interrupção no disparador, você irá ignorar
seu código quando você tentar passar por ele.
5. Entre no procedimento armazenado. Para obter mais informações, consulte Como etapa
em um objeto usando Server Explorer:.
A caixa de diálogo Run Stored Procedure será exibida, perguntando por valores de
parâmetro.
6. Defina os valores de parâmetros a seguir:
1. @currencyCode= AAA
2. @name= Um valor arbitrário como, por exemplo,Nome do Meu Teste.
A seta amarela de um ponteiro de instrução aparece na linha SET @mynvarchar =
@@VERSION, a primeira linha executável de código no procedimento armazenado.
1. Depure o código usando a tecla F11 ou o botão Step Into.
Na instrução UPDATE, quando você pressionar F11 novamente, você entrará no
disparador.
2. Depure o disparador até que você saia de volta ao procedimento armazenado, e
continue até o fim.
8. Você pode verificar os dados que foram inserido clicando com o botão direito do mouse no
nó Sales.Currency em Tables, e em clicando em Show Table Data no Server Explorer.
Exemplo
Esse é o código para o procedimento armazenado que faz com que o disparador seja acionado.
ALTER PROCEDURE dbo.UpdateCurrency_T_SQL ( @currencyCode nvarchar(3), @Name nvarchar(50) )

AS SET NOCOUNT ON UPDATE Sales.Currency SET Name = @Name WHERE CurrencyCode =
@currencyCode RETURN
Passo-a-passo: Depuração de uma função T-SQL definida pelo usuário

Este exemplo usa uma função definida pelo usuário existente chamada de ufnGetStock no banco
de dados AdventureWorks. Esta função retorna uma contagem de itens em estoque para um
determinado ProductID.
O exemplo cria um procedimento armazenado que chama a função várias vezes. O procedimento
armazenado chama a função com parâmetros diferentes, para que você possa seguir caminhos
de execução diferentes através da função. O exemplo também ilustra como saltar de um objeto T-
SQL, o procedimento armazenado, para outro, a função. As etapas são semelhantes àquelas em
Passo-a-passo: Depuração de um procedimento T-SQL armazenado.
Você também pode fazer Direct Database Debugging (depuração de banco de dados direta)
entrando na função no Server Explorer.
Para depurar uma função definida pelo usuário

banco de dados:.
2. Crie um novo procedimento armazenado usando o código da seção de exemplo abaixo e
denomine-o de Test_ufnGetStock. Para obter mais informações, consulte Como Develop
com o tipo do Project Server SQL:.
3. Defina pontos de interrupção em Test_ufnGetStock. Isso é opcional, porque a Direct
Database Debugging (depuração de banco de dados direta) faz com que a primeira linha do
procedimento atue como um ponto de interrupção.
4. Defina pontos de interrupção na função definida pelo usuário ufnGetStock.
1. Abra o código-fonte para a função clicando com o botão direito do mouse no nó
Functions no Server Explorer, depois clique duas vezes no ícone ufnGetStock.
2. Clique com o botão esquerdo do mouse na margem cinza ao lado da instrução
DECLARE para definir um ponto de interrupção.
5. Entre no procedimento armazenado. Se o procedimento tivesse parâmetros, a caixa de
diálogo Run Stored Procedure seria exibida, perguntando por seus valores. Nesse caso, os
parâmetros são todos embutidos em código dentro do procedimento armazenado. Para
obter mais informações, consulte Como etapa em um objeto usando Server Explorer:.
6. Experimente diferentes recursos de depuração.
1. Passe pelo código usando a tecla F11 ou o botão Step Into. Na instrução SELECT,
quando você pressionar F11 novamente, você entrará na função definida pelo usuário.
Passe pela função até que você saia de volta para o procedimento armazenado e
continue.
2. Você pode observar caminhos diferentes de execução na função de acordo com os
parâmetros de entrada. Você pode ver os valores das variáveis em funções definidas
pelo usuário na janela Locals, ou colocando o cursor sobre elas.
Exemplo
Isso é o código para o procedimento armazenado que chama a função definida pelo usuário.
ALTER PROCEDURE Test_ufnGetStock AS SELECT dbo.ufnGetStock(1) as CurrentStock -- non-zero

inventory SELECT dbo.ufnGetStock(316) as CurrentStock -- zero inventory SELECT dbo.ufnGetStock(5) as
CurrentStock -- no such product
Passo-a-passo: Depuração de um procedimento T-SQL armazenado

Este exemplo mostra como criar e depurar um procedimento armazenado T-SQL com depuração
direta no banco de dados (Direct Database Debugging), em outras palavras, entrar no
procedimento armazenado usando Server Explorer. Também ilustra diferentes técnicas de
depuração, como definição de pontos de interrupção, exibição de itens de dados, e assim por
diante.
Observação
As caixas de diálogo e comandos de menu que você vê podem diferir daqueles descritos na Ajuda
dependendo de suas configurações ativas ou de edição. Para alterar as configurações, escolha
Para depurar um procedimento armazenado T-SQL

exemplo AdventureWorks. Para obter mais informações consulte Como conectar-se a um
banco de dados:.
2. Crie um novo procedimento armazenado usando o código da primeira seção exemplo
abaixo, e denomine-o HelloWorld. Para obter mais informações, consulte Como Develop
com o tipo do Project Server SQL:.
3. Defina pontos de interrupção em HelloWorld, e entre no procedimento armazenado. Para
obter mais informações, consulte Como etapa em um objeto usando Server Explorer:. O
ponteiro de instrução, designado por uma seta amarela, será exibido na da linha SET
@mynvarchar = @@VERSION, a primeira linha executável de código no procedimento
armazenado.
4. Experimente diferentes recursos de depuração.
1. Torne a janela Locals visível. Para fazer isso, no menu Debug, clique em
Windows e, em seguida, clique em Locals. Observe que parâmetros e variáveis locais
são exibidos na janela Locals com seus valores correspondentes. Você pode editar os
valores das variáveis na janela Locals à medida que o procedimento armazenado é
executado. Para obter mais informações, consulte Como: usar janelas variáveis do
depurador.
Observação O servidor pode não refletir as alterações em valores de variáveis nas
janelas do depurador. Para obter mais informações, consulte Limitações da Depuração
SQL.
2. Pressione F10 para passar uma linha no procedimento armazenado. Observe que
o valor da variável @mynvarchar foi alterado na janela Locals e seu valor agora é
exibido em vermelho, indicando que foi alterado.

3. Torne a janela Watch visível. Para fazer isso, no menu Debug, clique em
Windows, e escolha Watch. Para obter mais informações, consulte Como: usar
janelas variáveis do depurador.
4. No editor de texto, clique duas vezes na variável @mynvarchar para selecioná-la.
Arraste @mynvarchar para qualquer local na janela Watch. A variável é então
adicionada à lista de variáveis observadas.
Observação Você pode editar os valores das variáveis na janela Watch também.
5. No editor de texto, clique com o botão direito do mouse na linha Return (0), e no
menu de atalho, clique em Insert Breakpoint.
6. No menu Debug, clique em Continue.
5. Escolha Continue novamente para concluir a depuração do procedimento armazenado.
Observação Você pode entrar em qualquer um dos procedimentos armazenados no
banco de dados AdventureWorks que são exibidos sob o nó Stored Procedures associado
ao banco de dados.
Exemplo
Este é o código para o procedimento armazenado.
CREATE PROCEDURE HelloWorld AS DECLARE @mynvarchar NVARCHAR(50), @myfloat FLOAT SET

@mynvarchar = @@VERSION SET @mynvarchar = 'Hello, world!' SET @myfloat = 1.6180 PRINT
@mynvarchar RETURN (0)

Segurança (Como fazer em C#)
Esta página referencia a ajuda sobre tarefas amplamente executadas de segurança e
implantação. Para ver outras categorias de tarefas populares abordadas na ajuda, consulte Como
fazer em C#.
Segurança no Visual Studio

Considerações de segurança devem ser incluídas em todos os aspectos do seu desenvolvimento
de aplicativos, desde o design até a implantação.
Para ajudá-lo efetivamente a desenvolver aplicativos seguros, você deve ter uma compreensão
fundamental dos conceitos de segurança e recursos de segurança das plataformas para as quais
você irá desenvolver. Você também deve ter uma compreensão de técnicas de codificação
segura.
Noções básicas sobre segurança

Segurança em .NET Framework
Descreve a segurança de acesso ao código do .NET Framework, segurança baseada em

função, política de segurança, e ferramentas de segurança.
Defenda seu código com As Dez Principais Dicas De Segurança Que Todo Desenvolvedor Deve
Conhecer (http://msdn.microsoft.com/library/default.asp?url=/library/en-
us/dnsecure/HTML/appsec.asp)
Descreve os problemas realmente importantes que você deve tomar cuidado para não
comprometer seus dados ou seu sistema.
Codificação para segurança
A maioria dos erros de codificação que resultam em vulnerabilidades de segurança ocorrem

porque os desenvolvedores fazem suposições inválidas ao trabalhar com a entrada do usuário ou
porque eles não entendem completamente a plataforma para a qual eles estão desenvolvendo.
Noções Básicas sobre Segurança de Accesso a Código

Todos os aplicativos que aponta o Common Language Runtime deve interagir com sistema de
segurança o Runtime na. Quando um aplicativo é executado, ele é avaliado e é fornecido um
conjunto de permissões em tempo de execução automaticamente. Dependendo das permissões
que o aplicativo recebe, ele é executado corretamente ou gera uma exceção de segurança. As
configurações de segurança local em um computador específico basicamente decidir código
recebe as permissões. Como essas configurações podem alterar de computador para
computador, você nunca poderá ter certeza que seu código receberá permissões suficientes para
executar. Isso serve de contraste para o mundo da desenvolvimento não gerenciado no qual você
não tem se preocupar com a permissão para executar seu código na.
Cada desenvolvedor deve ser familiarizado com os seguintes conceitos de segurança Acesso
código para gravar eficaz aplicativos selecionando o Common Language Runtime:

• Escrevendo código seguro Tipo-: Para ativar código para se beneficiar de Segurança do
Acesso ao Código você deve usar um compilador que gera código verifiably Safe tipo-. Para
obter mais informações, consulte Gravar Verifiably código Safe Type-.
• Sintaxe declarativas e imperativas: interação com o sistema de segurança Runtime é feita
usando segurança declarativas e imperativas chamadas. Chamadas declarativa são efetuada
usando atributos; chamadas imprescindível são executadas usando novas instâncias de
classes de seu código. Algumas chamadas pode ser executada somente imperatively,
enquanto outras pessoas podem ser executadas somente declarativamente. Algumas
chamadas pode ser executada de qualquer maneira. Para obter mais informações, consulte
Sintaxe de segurança.
• Solicitar Permissões de seu código: solicitações são aplicadas ao escopo conjunto, onde
seu código informa o Runtime sobre permissões que ele precisa ser executado ou não deseja
especificamente. Solicitações de segurança são avaliados por tempo de execução quando seu
código é carregado na memória. Solicitações não pode influenciar tempo de execução para
fornecer seu código mais permissões que o Runtime seria tenha dado seu código tinha a
solicitação não foi feita. No entanto, as solicitações são o que seu código usa para informar o
Runtime sobre as permissões requer para serem executados. Para obter mais informações,
consulte Solicitando permissões.
• Usando bibliotecas classe seguro: suas bibliotecas classe usar segurança de acesso ao
código para especificar as permissões que eles precisam para ser acessado. Você deve estar
ciente das permissões necessárias para acessar qualquer biblioteca que usa seu código e
fazem solicitações apropriadas em seu código. Para obter mais informações, consulte Usando
bibliotecas classe segura.
Práticas recomendadas de política de segurança

O.NET Framework fornece um modelo de segurança Acesso código que permite aos
administradores para modificar a diretiva de segurança para atender às suas necessidades
individuais. Enquanto segurança de acesso ao código geralmente aumenta a confiabilidade e
segurança de aplicativos, incorretamente administrar a diretiva de segurança do acesso ao código
potencialmente criar pontos fracos segurança. Esta seção explica conceitos de administração
básicas e descreve algumas das práticas recomendadas para usar ao administrar a diretiva de
segurança do acesso ao código.
Visão geral da administração de política de segurança

O sistema de segurança do .NET Framework é regido por um conjunto de regras chamadas
Diretiva de segurança configuráveis. Esta diretiva permite que o usuário final ou Administrador
para ajustar as configurações que determinam qual código recursos tem permissão para acessar
e basicamente decidir qual código tem permissão para executar o tempo todo.
Por exemplo, suponha que você for um administrador em uma configuração da empresa e você
não confia o software que se origina de uma empresa específica. Talvez essa empresa produz
software que funcionários localizar divertido, mas causas aumenta o tráfego de rede ou causar
estações de trabalho se torne instável. Você pode definir uma diretiva de segurança de nível
empresarial que restringe o acesso que software com uma nome forte criptografia específico (um
identificador exclusivo) de um programa tem aos recursos do computador. Você também pode
definir uma diretiva que impede que software deste editor na seja executado em todos os.
Este tópico fornece uma visão geral sobre administração de diretiva de segurança. Para obter
mais informações, consulte Gerenciamento de diretivas de segurança.
Prova, grupos de código e conjuntos de permissões

Código que aponta o Common Language Runtime é implantado em unidades chamadas
conjuntos de módulos (assemblies). Ao tempo de carregamento, tempo de execução examina
cada conjunto para provas, que é identificar informações sobre conjunto (tais como a assinatura
digital do autor é o código e o local que originou o código). Com base nas provas, Gerenciador de
segurança Runtime idioma comum mapeia montagem para um grupo de códigos com base na
diretiva de segurança. Grupos de códigos são definidos para testar a formulários específicos de
evidências e fazer conjuntos permissão associado a eles. Conjuntos de módulos (assemblies) que
pertencem a um grupo código receberão as permissões definidas pelos conjuntos de permissões
associado. Para obter mais informações sobre provas, grupos de códigos, e conjuntos de
permissões, consulte Modelo de diretiva de segurança.
Permissões
As permissões são simplesmente objetos que representam o direito de acessar um recurso

protegido. Permissões são configuráveis e um objeto de permissão único pode assumir vários
formulários. Por exemplo, a FileIOPermission representa o direito de acesso, criar, ler, gravar ou
modificar arquivos no disco rígido local. Para ser significativo, uma permissão deve conter
informações específicas sobre o tipo de acesso ele representa. Você pode configurar para
representar o direito para ler um arquivo específico, ler e gravar em um arquivo específico, ou ler
os arquivos em uma pasta inteira. um FileIOPermission Os direitos que representam uma
permissão e conjuntos de módulos (assemblies) que recebe são totalmente configuráveis pelo
administrador do computador. Enquanto os aplicativos podem criar e configurar objetos permissão
como qualquer outro objeto, somente a diretiva de segurança pode conceder permissão para um
aplicativo. Basicamente, os administradores controlar a conceder permissão. Para obter uma lista
de permissões comuns, consulte Permissões de acesso código.
Níveis de Diretiva de segurança
Há quatro níveis de diretiva de segurança definidas pelo modelo de segurança, que correspondem
à administração diferentes e cenários de hospedagem. A tabela a seguir descreve cada nível. O
nível de diretiva corporativa é o nível mais alto e o nível de domínio do aplicativo é o menor.
Nível de diretiva Descrição

Diretiva Definida pelos administradores da empresa que definir a diretiva para
corporativa domínios da empresa.
Diretiva da Definida pelos administradores máquina que definir a diretiva para um
máquina computador.
Diretiva de usuário Definido por usuários que definir a diretiva para uma conta de logon único.
Diretiva de Definido pelo host do tempo de execução (qualquer aplicativo que hospeda o
domínio de Common Language Runtime) para definir diretiva tempo carregar-. Este nível
aplicativo não pode ser administrado.
Cada nível de diretiva consiste de uma hierarquia de grupos de código. Os administradores de

cada nível de diretiva pode criar seus próprios grupos de códigos e conjuntos de permissões
associado. Ao tempo de carregamento, o sistema de segurança Acesso código examina todos os
níveis de diretiva e a conceder permissão resultante é a interseção de todas as permissões
permitido em cada nível. Os administradores de um nível de diretiva inferior não pode loosen uma
decisão diretiva feitas em um nível superior, mas eles pode reforçar Diretiva, Much como desejam.
A diretiva de segurança padrão reside em nível de diretiva Máquina.
As configurações de segurança padrão são:
• Níveis de usuário e empresa são definidas como Irrestrito.

• O nível de máquina contém as configurações de diretiva específico e restrições.
• As configurações definidas por todos os níveis três constituem configurações padrão.
Observe que usuário irrestrita e níveis empresa não resultem em Irrestrito sendo concedidas a um
conjunto. Nível do computador define várias restrições, e todos os níveis três são considerados
como um todo, como a conceder permissão resultante é permissões não irrestritas. Para obter
mais informações, consulte Modelo de diretiva de segurança.
Mapeando grupos código para conjuntos de permissões
Gerenciar Diretiva, mapeando grupos de códigos para conjuntos de permissões no nível de

diretiva ou níveis que você administrar.
Grupos de códigos contêm uma condição de membro, definir uma permissão associação, e
atributos grupo código. A evidência que apresenta um conjunto para o Runtime é comparado com
a condição de membro que você especificar para um grupo de códigos. Se um conjunto fornece
prova que corresponda a condição de membro, ele será permitido entrada para o grupo de código.
Os administradores identificar, categorizar conjuntos de módulos (assemblies) em grupos de
códigos, especificando condições de membro, e define a esses grupos código permissão
atribuição. Opcionalmente, atributos grupo código pode ser usado para especificar que nenhum
nível de diretiva abaixo do nível atual deve ser considerada ou que nenhum código grupo exceto a
versão atual deve ser considerada ao atribuir permissão.
Os seguintes tipos de prova interna podem ser usados como condições de membro:
• Diretório de instalação do aplicativo

• O hash criptográfico do conjunto
• A assinatura digital do editor conjunto
• O site da qual provém montagem
• A criptografia nome forte da montagem
• O URL da qual provém montagem
• A zona da qual provém montagem
Você pode reduzir ou aumentar as permissões a conjuntos de módulos (assemblies) com base em
qualquer combinação dessas condições de membro. Porque condições de membro personalizada
pode ser criado, a lista anterior não representa cada possibilidade. Para obter mais informações,
consulte Prova.
Administração de diretiva de segurança geral

Esta seção fornece um conjunto de diretrizes que você pode usar para ajudar Administrar diretiva
para seu computador ou empresa. Essas informações para ajudá-lo a decidir quando se executar
tarefas administrativas e o que foi feito conseqüências ter essas decisões. Para obter informações
sobre como usar ferramentas para executar tarefas específicas Consulte Configuração de diretiva
de segurança.
Determinando quando para modificar a diretiva de segurança

Não necessariamente fazer precisará modificar as configurações de segurança padrão. Para
muitas situações, as configurações de segurança padrão oferecem um nível adequado de
proteção. Código que não é originada do computador local (e, portanto, é provável que ser menos

confiável) recebe restrita acesso a recursos protegidos sob a diretiva de segurança padrão.
Código proveniente de Internet e Intranet Local é restrito de das seguintes maneiras:
• Código que se origina da Internet ou intranet local não tem permissão para ler ou gravar
em uma unidade local.
• Código que se origina da Internet ou intranet local não tem permissão para ler ou gravar no
Registro do sistema.
• Código que se origina da Internet ou Intranet Local pode se comunicar com o site da Web
do origem.
• Código que se origina de intranet local possui acesso irrestrito a elementos UI, mas
somente código originadas na Internet tem acesso à sub janelas e a Área de transferência.
A diretiva de segurança padrão é adequado para situações maioria dos, mas não todos,. Você
deve considerar modificar Diretiva de segurança quando:
• Você deseja confiar um aplicativo que requer mais permissão que a zona da qual ele
provém recebe por padrão.
• Você usar aplicativos de uma editora específica que você completamente confiar e deseja
esses aplicativos para ter acesso a recursos específicos, não importa onde eles são
executados.
• Você deseja aplicativos no computador local para ter menos de confiança total. Por
exemplo, você for um administrador de empresa e você desejar impedir que os usuários de
instalar e executar aplicativos não confiáveis.
Se você decidir editar diretiva, você deve garantir você que não faça diminuir permissão para
aplicativos para o ponto que eles não funcionarão corretamente.
Ferramentas de administração
A maneira recomendada de configurar a diretiva de segurança é para usar o Ferramenta .NET
Framework Configuration (Mscorcfg.msc). Essa ferramenta fornece assistentes para ajudá-lo
ajustar o usuário, computador, e as configurações de segurança corporativa. A tabela a seguir
descreve esses assistentes.
Assistente Descrição
Confiar um Use este assistente para identificar um aplicativo pelas informações Editor
aplicativo ou nome forte e Aumentar nível do aplicativo de confiança.
Ajustar Use este assistente para aumentar ou diminuir permissões a conjuntos de
configurações de módulos (assemblies) proveniente de uma das seguintes zonas: Meu
segurança computador, intranet local, Internet, sites confiáveis e sites não confiáveis.
Criar um pacote de Use este assistente para criar um pacote Windows Installer para implantar a
implantação diretiva de segurança em uma empresa.
Para obter mais informações sobre usando os assistentes, consulte o Ferramenta .NET
Framework Configuration (Mscorcfg.msc).
Se os assistentes não fornecem a funcionalidade necessários para administrar a diretiva de

segurança, você poderá editar os conjuntos de permissões e código grupos diretamente usando a
qualquer toolor .NET Framework Configuration o Ferramenta Diretiva de segurança para acesso
de código (Caspol.exe). Caspol.exe é uma ferramenta de linha de comando fornecida
principalmente para scripts administração de segurança. Para obter informações sobre como
realizar tarefas específicas usando estas ferramentas consulte Configuração de diretiva de
segurança.
Aumentar permissões
Um aplicativo gerenciado que requer mais permissão para executar que permite que a diretiva
atual dependendo da como ele é criada, será Acione uma exceção, deixar de executar, ou função
não corretamente. Você pode usar para exibir o permissões mínimas solicitada, permissões
opcional solicitada, e permissões recusada pelo conjunto para comparar as permissões que
montagem solicitações para as permissões que ele realmente receberá. o Ferramenta exibir
permissões (Permview.exe) Observe que esta ferramenta só mostra permissões que tiver sido
solicitada pelo aplicativo usando a sintaxe declarativa explicitamente. Com essas informações,
poderá aumentar as permissões que conjunto recebe por criando um novo grupo de códigos
personalizados e associá-lo a um novo conjunto de permissão personalizada que contém todas as
permissões que o aplicativo precisa ser executado corretamente. No entanto, você deve aumentar
as permissões somente se você confiar fonte do aplicativo e somente você deve confiar de acordo
com prova que é suitably confiável. Administradores (na maioria dos casos, será ter vários grupos
de códigos personalizados que podem ser usados para categorizar vários aplicativos que
requerem permissões semelhantes.)
Suponha que você tenha um aplicativo que é freqüentemente acessado por vários usuários em
um compartilhamento de rede. Em um contexto não gerenciado, essa situação não representar
um problema de execução geralmente não. No entanto, em um contexto gerenciado, este
aplicativo pode ser concedido um limitado conjunto de permissões porque ele proveniente de à
zona Intranet local. Por exemplo, o aplicativo não pode ser permitido completo permissões de
impressão, que limita utilidade deste aplicativo. Em vez de loosening as configurações de zona
inteiro da intranet local, você deve fazer o seguinte:
1. Uso para o modo cujas permissões você deseja aumentar as permissões mínimas
solicitada pelo conjunto. o Ferramenta Exibir Permissão (Permview.exe) Essas são as
permissões em log de forma mínima precisa para executar o aplicativo.
2. Identificar uma característica exclusivo da montagem. Essa característica pôde incluir
nome forte na montagem, sua chave pública, o hash, ou um atributo personalizado
exclusivo. Se o aplicativo proveniente de um servidor confiável, o local também pode ser
usado para identificar o aplicativo. Lembre-se, você confia todo código que tenha essa
característica.
3. Criar um novo grupo de códigos que requer o identificador exclusivo do membro. Use a
ferramenta (Mscorcfg.msc).NET Framework Configuration ou Ferramenta Diretiva de
segurança para acesso de código (Caspol.exe). Para criar o grupo de códigos
4. Criar um novo conjunto de permissões que inclui todas as permissões montagem em log
de forma mínima precisa para executar usando a ferramenta .NET Framework
Configuration ou a ferramenta Diretiva de Segurança para Acesso ao código.
5. Associar a nova permissão definir com o novo grupo código, utilizando a ferramenta .NET
Framework Configuration ou a ferramenta Diretiva de Segurança para Acesso ao código.
O aplicativo após a conclusão dessas etapas, será executado e receberá permissões suficientes
para funcionar. Outros, menos aplicativos confiáveis não receberão as permissões adicionais; isso
ajuda a proteger seu sistema contra código mal-intencionado. Para obter informações sobre como
realizar tarefas específicas usando as ferramentas de segurança, consulte Configuração de
diretiva de segurança.

Administração com atributos Grupo de códigos
Suponha que você for um administrador empresarial Quem é responsável para administrar a
diretiva de segurança para um número de estações de trabalho. Para o domínio corporativa típica,
o administrador da rede tenha privilégios administrativos em cada servidor e cada cliente. No
entanto, não é difícil para os usuários possam ter privilégios administrativos em uma estação de
trabalho único individuais. Como um resultado, o administrador da rede tenha privilégios
administrativos no nível de diretiva da empresa e o administrador da estação de trabalho tem
privilégios administrativos no nível de diretiva da máquina. Nesta situação, o administrador da
rede parece ter mais controle sobre diretiva como diretiva corporativa é avaliada primeiro e diretiva
de máquina não tem permissão para loosen decisões de segurança feitas pelo administrador de
nível empresarial. No entanto, o administrador de nível máquina ainda pode reforçar segurança,
potencialmente quebrar aplicativos confiáveis que faria caso contrário ter sido podem ser
executadas. Por esse motivo, maior níveis de diretiva pode optar por excluir decisões de diretiva
de nível inferior de ser avaliado.
Para fazer isso, aplicando ou Exclusive atributo a um grupo de código, usando um das
ferramentas de diretiva de segurança. o LevelFinal
Atributo de Nível final
Quando aplicado a um grupo de códigos, o LevelFinal atributo exclui qualquer nível de diretiva de
ser avaliado abaixo do nível atual. Por exemplo, se você aplicar o LevelFinal atributo ao grupo de
códigos de intranet local no nível da empresa, qualquer grupo de códigos no nível do computador
não serão avaliados mesmo se um administrador nível máquina tiver feito alterações. Aplicar o
LevelFinal atributo garante que um conjunto associado a um grupo de códigos marcados com
este atributo nunca receberão as permissões menos devido a decisões tomadas por um
administrador de nível inferior diretiva. Para obter informações sobre configuração do LevelFinal
atributo em um padrão ou grupo de códigos personalizado, consulte o Ferramenta .NET
Framework Configuration (Mscorcfg.msc) ou o Ferramenta Diretiva de segurança para acesso de
código (Caspol.exe).
Atributo exclusivo
Quando aplicado a um grupo de códigos, o Exclusive atributo impede outros grupos de código no
mesmo nível de diretiva de sendo considerados quando o Runtime calcula permissões para
conjuntos de módulos (assemblies) que estão no grupo código exclusivo. Níveis de diretiva acima
e abaixo do nível atual ainda são avaliados, embora. Este atributo permite que um grupo código
específico para tomar a decisão único para o nível de diretiva atual sobre quais permissões são
concedidas aos conjuntos que correspondam desse grupo. Isso é útil quando você deseja
conceder um conjunto específico de permissões aos conjuntos específicos, sem permitir que
permissões de outras correspondências grupo código no mesmo nível de diretiva.
Observe que um conjunto não tem permissão para executar se ele pertencer a mais de um grupo
código marcado como exclusivo. Portanto, use o Exclusive atributo com cautela ao administrar
Diretiva de segurança personalizado. Para obter informações sobre como definir o Exclusive
atributo em um interna em ou personalizados, consulte o Ferramenta .NET Framework
Configuration (Mscorcfg.msc) ou o Ferramenta Diretiva de segurança para acesso de código
(Caspol.exe) grupo de códigos.
COMO: Adicionar Permissões Personalizadas à Política de Segurança
Uma permissão personalizada é um que é fornecido com um aplicativo ou biblioteca, em vez de

sendo fornecido pelo .NET Framework. Para ser significativo, uma permissão personalizada deve
ser adicionado com a diretiva de segurança no computador (ou computadores, no caso de uma
rede) onde o aplicativo usando a permissão executa.

Você deve descrever as especificações da permissão você deseja adicionar ao sistema de
segurança do .NET Framework quando você adiciona ele sua diretiva personalizada. Uma
permissão único pode assumir vários formulários que representam o direito de acessar recursos
específicos. Por exemplo, a permissão personalizada pode ter a capacidade de fornecer acesso
restrito ou irrestrito a um recurso. Como um administrador, você tem a capacidade de decidir qual
tipo a permissão de acesso (restrito ou Irrestrito) representará. Portanto, você deve descrever a
configuração que você deseja a permissão para tem que o sistema de segurança do .NET
Framework. Isso, criando uma representação XML da configuração você deseja a permissão
personalizada para ter e importar o XML para a diretiva de segurança. (O sistema de segurança
do .NET Framework usa XML para serializar permissões.) O editor da permissão ou deve fornecer
uma ferramenta para criar a representação XML ou fornecer instruções para criar o arquivo XML.
Geralmente, as representações XML das permissões que compõem a diretiva de segurança são
armazenadas em arquivos de configuração de diretiva.
Para adicionar uma permissão personalizada à diretiva de segurança

1. Adicionar Conjunto implementar a permissão personalizada para o cache de conjunto de
módulos global e para a lista de conjuntos de módulos (assemblies) totalmente confiável.
2. Criar um arquivo XML que representa o tipo de permissão você deseja criar e atribuir aos
conjuntos.
3. Adicionar a representação XML da permissão para a diretiva de segurança, usando o
Ferramenta .NET Framework Configuration (Mscorcfg.msc) ou o Ferramenta Diretiva de
segurança para acesso de código (Caspol.exe).
Dicas de administração
As práticas descritas na seção são aplicáveis para cada cenário Administração. Você deve
conservá-lo em mente ao configurar e administrar a diretiva de segurança.
Estratégias de longo prazo para administração de diretiva
Definir categorias de confiança que você pode usar para administrar diretiva aplicável. Definir
vários grupos de códigos para discriminate código que é provável que ser executada em seu
ambiente e definir as permissões que devem receber cada grupo. Craft diretiva acordo e
implantar. Você deve fazer estabelecer sua diretiva geral quando você configura seu ambiente,
em vez de fone fone-por-inicialmente como necessários para executar vários aplicativos.
Nível de administração
O nível de diretiva que você escolher para administrar é determinado pelo escopo que você
deseja que afetam. Sempre administrar a diretiva de segurança no nível de diretiva menor que
afeta os usuários mínimo e ainda atender seu cenário Administração. Por exemplo:
• Se você estiver administrando um diretiva que afeta cada estação de trabalho e usuário na
sua empresa, verifique as adições Diretiva no nível da empresa. Nunca fazer uma adição ao
nível empresa de um computador que não foi feito para afetar todos os computadores na sua
empresa.
• Se você estiver administrando um diretiva que afeta todos os usuários em um computador
específico, verifique as adições Diretiva no nível da máquina.
• Se você estiver administrando uma diretiva para um determinado usuário ou grupo de
usuários, verifique as adições Diretiva no nível do usuário.
Sistema de arquivos

Usar o sistema de arquivos NTFS sempre que possível para armazenar os arquivos de diretiva de
segurança. NTFS ajuda a oferecer proteção de arquivos com base em Usuários e grupos, e
somente permite que os usuários com privilégios administrativos para um nível específico para
editar arquivos de configuração de segurança. Sistemas que não usam o sistema de arquivos
NTFS criar pontos fracos de segurança, permitindo que os usuários não autorizados para
modificar a diretiva de segurança.
Administração de diretiva corporativa

O nível de diretiva corporativa contém diretiva para cada computador e usuário na rede e pode ser
administrado por administradores de domínio ou computador. Consulte a seção sobre Implantação
de diretiva de segurança para obter informações sobre estratégias de implantação.
Porque o Runtime avalia Diretiva corporativa primeiro, você pode aplicar o LevelFinal atributo a
um grupo de código nesse nível para excluir os níveis inferiores de fazer alterações de diretiva.
Sem o LevelFinal atributo, menor níveis de diretiva pode remover permissões do conjunto
concessão final, possivelmente causando instabilidade no aplicativo. No entanto, mesmo se você
não se aplicam o LevelFinal atributo, níveis inferiores serão pôde para aumentar a concessão
final definido porque todos os níveis de diretiva são intersected durante a resolução de diretiva.
Você pode considerar Administrar diretiva nesse nível quando cada pessoa em sua empresa usa
um aplicativo e você desejar para certificar-se que ele sempre receberá permissão suficiente para
executar.
Administração de diretiva da máquina

O nível de diretiva Máquina contém a maioria da diretiva de segurança padrão. Todos os
administradores de computador e domínio ter acesso ao computador os arquivos de configuração.
Os administradores máquina pode definir a diretiva que exclui modificação do nível do usuário,
mas não do nível empresa.
Você pode considerar Administrar diretiva de segurança neste nível nas situações a seguir:
• Você não estejam em uma rede ou estiver em uma rede sem um controlador de domínio.
• O computador que você está administrando serve uma função exclusivo. Por exemplo, se
você estiver administrando um computador público que é usada para gerais acesso à Internet
por várias pessoas em uma configuração semi-Public, convém para que uma diretiva Máquina
exclusivo, porque o computador funciona uma função exclusivo. Além disso, convém para
produzir uma diretiva Computador específico que considera às necessidades de segurança de
computadores especializados, como os servidores da sua empresa.
Administração de diretiva de usuário

Diretiva de usuário é o nível mais baixo diretiva administrable. Cada usuário tem um arquivo de
configuração de diretiva de usuário individuais. Quaisquer alterações feitas neste nível de diretiva
serão Aplicável somente ao usuário conectado-no atual. O nível de diretiva de usuário é restrito no
qual ele pode especificar.
Porque este nível é configurável pelo usuário com logon feito atual, administradores de diretivas
do nível empresa deve estar ciente que o usuário potencialmente pode alterar qualquer alteração
feita no nível de diretiva do usuário Diretiva. O nível de diretiva de usuário não é capaz de
conceder mais permissões a uma montagem que é especificado nos níveis de diretiva superior.
No entanto, o nível de diretiva de usuário tem permissão para diminuir permissões, que
potencialmente pode causar aplicativos para parar de funcionar corretamente. Se o LevelFinal

atributo é aplicado a um grupo de códigos no nível da máquina ou empresa, o nível do usuário
não é permitido para reforçar decisões de diretiva que foram feitas nesses níveis.
Administração de nível de usuário é adequado em algumas situações para tightening segurança.

Por exemplo, um usuário pode decidir para Reforçar diretiva de segurança para os conjuntos de
módulos (assemblies) originados a partir da zona Intranet local se não for encontrado um código
não confiável. Você pode considere Administrar diretiva nesse nível quando você tiver um usuário
em uma rede corporativa e achar que as configurações de segurança são não apertada suficiente.
COMO: Usar Proteção de Dados
O.NET Framework fornece acesso à proteção de dados (DPAPI), que permite que você para
criptografar dados usando informações da conta de usuário atual ou computador API. Quando
você usa a DPAPI, você aliviar o problema de explicitamente gerar e armazenar uma chave
criptográfica difícil.
Use a ProtectedMemory classe para criptografar uma matriz de bytes de memória. Essa
funcionalidade está disponível no Microsoft Windows XP e sistemas operacionais posteriores.
Você pode especificar que a memória criptografados por atual processo pode ser
descriptografados pelo processo atual apenas, por todos os processos, ou do mesmo contexto de
usuário. Consulte a MemoryProtectionScope enumeração para obter uma descrição detalhada
das ProtectedMemory Opções.
Use a ProtectedData classe para criptografar uma cópia de uma matriz de bytes. Essa
funcionalidade está disponível no Microsoft Windows 2000 e sistemas operacionais posteriores.
Você pode especificar que dados criptografados pela conta de usuário atual pode ser
descriptografada somente pela mesma conta de usuário, ou você pode especificar que dados
criptografados pela conta de usuário atual pode ser descriptografados por qualquer conta no
computador. Consulte a DataProtectionScope enumeração para obter uma descrição detalhada
das ProtectedData Opções.
Para criptografar dados na memória usando proteção de dados

• Chame o método estático Protect Ao passar uma matriz de bytes para criptografar, a
entropia, e o escopo proteção memória.
Para descriptografar dados na memória usando proteção de dados
• Chame o método estático Unprotect Ao passar uma matriz de bytes para descriptografar e
o escopo Proteção de memória.
Para criptografar dados em um arquivo ou transmitir usando proteção de dados
1. Criar entropia aleatório.
2. Chame o método estático Protect Ao passar uma matriz de bytes para criptografar, a
entropia, e o escopo proteção dados.
3. Gravar os dados criptografados para um arquivo ou fluxo.
Para descriptografar dados de um arquivo ou transmitir usando proteção de dados
1. Ler os dados criptografados de um arquivo ou fluxo.
2. Chame o método estático Unprotect Ao passar uma matriz de bytes para descriptografar e
o escopo proteção de dados.
Exemplo
O exemplo de código a seguir demonstra duas formas de criptografia e descriptografia. Primeiro, o

exemplo de código criptografa e descriptografa depois os uma matriz de bytes de memória. Em
seguida, o exemplo de código criptografa uma cópia de uma matriz de bytes, salva ele em um

arquivo, carrega os dados de volta do arquivo, e então descriptografa os dados. O exemplo exibe
os dados originais, os dados criptografados, e os dados descriptografados.
C#
using System; using System.IO; using System.Text; using System.Security.Cryptography; public class
MemoryProtectionSample { public static void Main() { Run(); } public static void Run() { try {
/////////////////////////////// // // Memory Encryption - ProtectedMemory //
/////////////////////////////// // Create the original data to be encrypted (The data length should be a
multiple of 16). byte[] toEncrypt = UnicodeEncoding.ASCII.GetBytes("ThisIsSomeData16");
Console.WriteLine("Original data: " + UnicodeEncoding.ASCII.GetString(toEncrypt));
Console.WriteLine("Encrypting..."); // Encrypt the data in memory. EncryptInMemoryData(toEncrypt,
MemoryProtectionScope.SameLogon); Console.WriteLine("Encrypted data: " +
UnicodeEncoding.ASCII.GetString(toEncrypt)); Console.WriteLine("Decrypting..."); // Decrypt the data in
memory. DecryptInMemoryData(toEncrypt, MemoryProtectionScope.SameLogon);
Console.WriteLine("Decrypted data: " + UnicodeEncoding.ASCII.GetString(toEncrypt));
/////////////////////////////// // // Data Encryption - ProtectedData // ///////////////////////////////
// Create the original data to be encrypted toEncrypt = UnicodeEncoding.ASCII.GetBytes("This is some data
of any length."); // Create a file. FileStream fStream = new FileStream("Data.dat", FileMode.OpenOrCreate);
// Create some random entropy. byte[] entropy = CreateRandomEntropy(); Console.WriteLine();
Console.WriteLine("Original data: " + UnicodeEncoding.ASCII.GetString(toEncrypt));
Console.WriteLine("Encrypting and writing to disk..."); // Encrypt a copy of the data to the stream. int
bytesWritten = EncryptDataToStream(toEncrypt, entropy, DataProtectionScope.CurrentUser, fStream);
fStream.Close(); Console.WriteLine("Reading data from disk and decrypting..."); // Open the file. fStream =
new FileStream("Data.dat", FileMode.Open); // Read from the stream and decrypt the data. byte[]
decryptData = DecryptDataFromStream(entropy, DataProtectionScope.CurrentUser, fStream,
bytesWritten); fStream.Close(); Console.WriteLine("Decrypted data: " +
UnicodeEncoding.ASCII.GetString(decryptData)); } catch (Exception e) { Console.WriteLine("ERROR: " +
e.Message); } } public static void EncryptInMemoryData(byte[] Buffer, MemoryProtectionScope Scope ) { if
(Buffer.Length <= 0) throw new ArgumentException("Buffer"); if (Buffer == null) throw new
ArgumentNullException("Buffer"); // Encrypt the data in memory. The result is stored in the same same
array as the original data. ProtectedMemory.Protect(Buffer, Scope); } public static void
DecryptInMemoryData(byte[] Buffer, MemoryProtectionScope Scope) { if (Buffer.Length <= 0) throw new
ArgumentException("Buffer"); if (Buffer == null) throw new ArgumentNullException("Buffer"); // Decrypt
the data in memory. The result is stored in the same same array as the original data.
ProtectedMemory.Unprotect(Buffer, Scope); } public static byte[] CreateRandomEntropy() { // Create a byte
array to hold the random value. byte[] entropy = new byte[16]; // Create a new instance of the
RNGCryptoServiceProvider. // Fill the array with a random value. new
RNGCryptoServiceProvider().GetBytes(entropy); // Return the array. return entropy; } public static int
EncryptDataToStream(byte[] Buffer, byte[] Entropy, DataProtectionScope Scope, Stream S) { if
(Buffer.Length <= 0) throw new ArgumentException("Buffer"); if (Buffer == null) throw new
ArgumentNullException("Buffer"); if (Entropy.Length <= 0) throw new ArgumentException("Entropy"); if
(Entropy == null) throw new ArgumentNullException("Entropy"); if (S == null) throw new
ArgumentNullException("S"); int length = 0; // Encrypt the data in memory. The result is stored in the same
same array as the original data. byte[] encrptedData = ProtectedData.Protect(Buffer, Entropy, Scope); //
Write the encrypted data to a stream. if (S.CanWrite && encrptedData != null) { S.Write(encrptedData, 0,
encrptedData.Length); length = encrptedData.Length; } // Return the length that was written to the stream.

return length; } public static byte[] DecryptDataFromStream(byte[] Entropy, DataProtectionScope Scope,
Stream S, int Length) { if (S == null) throw new ArgumentNullException("S"); if (Length <= 0 ) throw new
ArgumentException("Length"); if (Entropy == null) throw new ArgumentNullException("Entropy"); if
(Entropy.Length <= 0) throw new ArgumentException("Entropy"); byte[] inBuffer = new byte[Length];
byte[] outBuffer; // Read the encrypted data from a stream. if (S.CanRead) { S.Read(inBuffer, 0, Length);
outBuffer = ProtectedData.Unprotect(inBuffer, Entropy, Scope); } else { throw new IOException("Could not
read the stream."); } // Return the length that was written to the stream. return outBuffer; } }
• Incluir uma referência para System.Security.dll.
• Incluir e System.Text Espaço para nome., System.Security.Cryptography a System,
System.IO
COMO: Adicionar Permissões Personalizadas à Política de Segurança
Uma permissão personalizada é um que é fornecido com um aplicativo ou biblioteca, em vez de

sendo fornecido pelo .NET Framework. Para ser significativo, uma permissão personalizada deve
ser adicionado com a diretiva de segurança no computador (ou computadores, no caso de uma
rede) onde o aplicativo usando a permissão executa.
Você deve descrever as especificações da permissão você deseja adicionar ao sistema de

segurança do .NET Framework quando você adiciona ele sua diretiva personalizada. Uma
permissão único pode assumir vários formulários que representam o direito de acessar recursos
específicos. Por exemplo, a permissão personalizada pode ter a capacidade de fornecer acesso
restrito ou irrestrito a um recurso. Como um administrador, você tem a capacidade de decidir qual
tipo a permissão de acesso (restrito ou Irrestrito) representará. Portanto, você deve descrever a
configuração que você deseja a permissão para tem que o sistema de segurança do .NET
Framework. Isso, criando uma representação XML da configuração você deseja a permissão
personalizada para ter e importar o XML para a diretiva de segurança. (O sistema de segurança
do .NET Framework usa XML para serializar permissões.) O editor da permissão ou deve fornecer
uma ferramenta para criar a representação XML ou fornecer instruções para criar o arquivo XML.
Geralmente, as representações XML das permissões que compõem a diretiva de segurança são
armazenadas em arquivos de configuração de diretiva.
Para adicionar uma permissão personalizada à diretiva de segurança

1. Adicionar Conjunto implementar a permissão personalizada para o cache de conjunto de
módulos global e para a lista de conjuntos de módulos (assemblies) totalmente confiável.
2. Criar um arquivo XML que representa o tipo de permissão você deseja criar e atribuir aos
conjuntos.
3. Adicionar a representação XML da permissão para a diretiva de segurança, usando o
Ferramenta .NET Framework Configuration (Mscorcfg.msc) ou o Ferramenta Diretiva de
segurança para acesso de código (Caspol.exe).
COMO: Ativar Configurações de Segurança do Internet Explorer para a Execução Gerenciada
Como Microsoft Internet Explorer pode atuar como um host para controles gerenciados e
componentes, suas configurações de segurança afetam execução gerenciado. O controle
gerenciado pode executar no Internet Explorer, a menos controles ActiveX e scripts são ativados
não.
Para ativar as configurações de segurança do Internet Explorer

1. No Internet Explorer, no Internet Options menu Tools.

2. Clique na Security guia. Você pode acessar as configurações para a zona da Internet,
zona Intranet local, sites confiáveis, e Sites restritos na neste guia.
3. Escolha a zona na qual o controle gerenciado Origem e clique no Custom Level botão. e
Run ActiveX controls and plug-insScript ActiveX controls marked safe for scripting
deve ser ativada para gerenciado controles ActiveX para executar ambos.
Consulte também
COMO: Solicitar Permissões Mínimas Usando o Sinalizador RequestMinimum
Sinalizador RequestMinimum, você pode solicitar um conjunto mínimo de permissões para

executar seu código requer. Por outro lado, o RequestRefuse Sinalizador permite fazer recusar
permissões, especificando quais seu código não deve ser concedido explicitamente.
Ao contrário de usar o RequestMinimum Sinalizador, o aplicativo será executada se ele não

receber todas as permissões que você solicitar usando o RequestOptional Sinalizador, e um
SecurityException ser acionada quando seu aplicativo tenta acessar um recurso protegido se. Se
você usar esse tipo de solicitação, você deve ativar o seu código para capturar quaisquer
exceções serão que ser acionada se seu código não é concedido a permissão opcional.
O exemplo a seguir solicita FileIOPermission usando o RequestMinimum Sinalizador. O exemplo

não executará se ele não foi concedido a permissão solicitada. Este exemplo assume que existe
em LogNameSpace Uma classe Log hipotético. A Log classe contém o MakeLog método que cria um
novo arquivo de log no computador local. Este aplicativo cria uma nova instância da classe Log e
executa o MakeLog método no bloco try. Usando a catch palavra-chave, ela intercepta qualquer
SecurityException acionada e exibe uma mensagem.
Exemplo
C#
//The request is placed at the assembly level. using System.Security.Permissions;
[assembly:FileIOPermission(SecurityAction.RequestMinimum, Unrestricted = true)] namespace
MyNamespace { using System; using System.Security; //The hypothetical class log is in this namespace.
using LogNameSpace; public class MyClass { public MyClass() { } public static void Main(string[] args) {
//Put any code that requires optional permissions in the try block. try { Log MyLog = new Log();
MyLog.MakeLog(); Console.WriteLine("The Log has been created."); } //Catch the security exception and
inform the user that the //application was not granted FileIOPermission. catch(SecurityException) {
Console.WriteLine("This application does not have permission to write to the disk."); } } } }
O código anterior cria o arquivo de log e exibirá a seguinte mensagem para o console se ele tiver
permissões suficientes:
The Log has been created.
Se o código é executado em um compartilhamento e as configurações de segurança local não

permitem esse código para possui FileIOPermission, o código não é concedido permissão
suficiente e exibirá a seguinte mensagem:
This application does not have permission to write to the disk.
COMO: Criar Objetos GenericPrincipal e GenericIdentity

Você pode usar a GenericIdentity classe em conjunto com a GenericPrincipal classe para criar um
esquema de autorização que existe independentes de um domínio Windows NT ou Windows
2000.
Para criar um objeto GenericPrincipal

1. Criar uma nova instância da classe identidade e inicializar-lo com o nome que você deseja
que ele seja mantenha. O código a seguir cria um novo GenericIdentity objeto e inicializa-
lo com o nome MyUser.
C#
GenericIdentity MyIdentity = new GenericIdentity("MyUser");
2. Criar uma nova instância da classe GenericPrincipal e inicializar-lo com o objeto criado
GenericIdentity anteriormente e uma matriz de seqüências de caracteres que representam
as funções que você deseja associado a este objeto. O exemplo de código a seguir
especifica uma matriz de seqüências de caracteres que representam uma função
Administrador e uma função do usuário. O GenericPrincipal depois está inicializado com o
anterior GenericIdentity e a matriz de seqüência.
C#
String[] MyStringArray = {"Manager", "Teller"}; GenericPrincipal MyPrincipal = new
GenericPrincipal(MyIdentity, MyStringArray);
3. Use o código a seguir para conectar o objeto para o segmento atual. Isso é importante em
situações onde o principal deve ser validado várias vezes, ele deve ser validado pelo outros
código em execução em seu aplicativo, ou ele deve ser validado por um
PrincipalPermission objeto. Ainda poderá realizar validação baseada em função no objeto
principal sem anexá-los para o segmento. Para obter mais informações, consulte Substituir
um objeto principal.
C#
Thread.CurrentPrincipal = MyPrincipal;
Exemplo
O exemplo de código a seguir demonstra como criar uma instância de um GenericPrincipal e um

GenericIdentity. Este código exibe os valores um desses objetos para o console.
C#
using System; using System.Security.Principal; using System.Threading; public class Class1 { public static int
Main(string[] args) { // Create generic identity. GenericIdentity MyIdentity = new
GenericIdentity("MyIdentity"); // Create generic principal. String[] MyStringArray = {"Manager", "Teller"};
GenericPrincipal MyPrincipal = new GenericPrincipal(MyIdentity, MyStringArray); // Attach the principal
to the current thread. // This is not required unless repeated validation must occur, // other code in your
application must validate, or the // PrincipalPermisson object is used. Thread.CurrentPrincipal =
MyPrincipal; // Print values to the console. String Name = MyPrincipal.Identity.Name; bool Auth =
MyPrincipal.Identity.IsAuthenticated; bool IsInRole = MyPrincipal.IsInRole("Manager");
Console.WriteLine("The Name is: {0}", Name); Console.WriteLine("The IsAuthenticated is: {0}", Auth);
Console.WriteLine("Is this a Manager? {0}", IsInRole); return 0; } }
Quando executado, o aplicativo exibirá uma saída semelhante à seguinte.

The Name is: MyIdentity The IsAuthenticated is: True Is this a Manager? True
COMO: Criar um Objeto WindowsPrincipal
Existem duas maneiras para criar um WindowsPrincipal objeto, dependendo se código

repetidamente deve executar a validação baseada em função ou deve executar ele somente uma
vez.
Se código repetidamente deve executar validação baseada em função, o primeiro dos seguintes
procedimentos produz menos sobrecarga. Quando código precisa para fazer validações baseada
em função apenas uma vez, você pode criar um WindowsPrincipal objeto, usando o segundo
dos procedimentos a seguir.
Para criar um objeto WindowsPrincipal para validação repetidos

1. Chame o SetPrincipalPolicy método no objeto AppDomain que é retornado pela
propriedade estático System.AppDomain.CurrentDomain, passando o método um
PrincipalPolicy valor de enumeração que indica qual a nova diretiva deve ser. Valores com
suporte são NoPrincipal, UnauthenticatedPrincipal,. e WindowsPrincipal O código a seguir
demonstra esse chamada de método.
C#
AppDomain.CurrentDomain.SetPrincipalPolicy( PrincipalPolicy.WindowsPrincipal);
2. Com a diretiva definida, use a propriedade estático

System.Threading.Thread.CurrentPrincipal para recuperar o objeto que encapsula o usuário
Windows atual. Porque o tipo de retorno de propriedade é IPrincipal, você deve convertido o
resultado para um WindowsPrincipal tipo. O código a seguir inicializa um novo
WindowsPrincipal objeto com o valor do principal associado ao segmento atual.
C#
WindowsPrincipal MyPrincipal = (WindowsPrincipal) Thread.CurrentPrincipal;
Para criar um objeto WindowsPrincipal para um único validação

1. Inicializar um novo WindowsIdentity objeto ao chamar o método estático
System.Security.Principal.WindowsIdentity.GetCurrent, que consultas a conta do Windows
atual e coloca informações sobre essa conta para o objeto identidade recém-criado. O
código a seguir cria um novo WindowsIdentity objeto e inicializa-lo para o usuário
autenticado atual.
C#
WindowsIdentity MyIdentity = WindowsIdentity.GetCurrent();
2. Criar um novo WindowsPrincipal objeto e passar ele o valor do WindowsIdentity objeto

criado na etapa anterior.
C#
WindowsPrincipal MyPrincipal = new WindowsPrincipal(MyIdentity);
3. Quando o objeto principal foi criada, pode usar um dos vários métodos para validar-lo.
Para obter mais informações, consulte Verificações de segurança baseada em função.
COMO: Executar Verificações de Segurança Imperativas
Para uma demanda imprescindível, você pode chamar o Demand método do objeto
PrincipalPermission para determinar se o objeto principal atual representa a identidade
especificado, função, ou ambos. Supondo que um objeto corretamente construído

PrincipalPermission chamado MyPrincipalPermission, uma demanda imprescindível pode ser
chamado com o código a seguir.
C#
MyPrincipalPermission.Demand();
Exemplo
O exemplo de código a seguir usa uma verificação imprescindível para garantir que um
GenericPrincipal Correspondências o PrincipalPermission objeto. Uma verificação
imprescindível é útil quando vários métodos ou outros conjuntos de módulos no domínio do
aplicativo deve fazer determinations baseada em função. Enquanto este exemplo é extremamente
simples, ele ilustra o comportamento associado a uma demanda baseada em função.
C#
using System; using System.Security.Permissions; using System.Security.Principal; using System.Security;
using System.Threading; using System.Security.Cryptography; public class MainClass { public static int
Main(string[] args) { Console.WriteLine("Enter '1' to use the proper identity or " + "any other character to
use the improper identity."); if(Console.ReadLine() == "1") { // Create a generic identity. GenericIdentity
MyIdentity = new GenericIdentity("MyUser"); // Create a generic principal. String[] MyString =
{"Administrator", "User"}; GenericPrincipal MyPrincipal = new GenericPrincipal(MyIdentity, MyString);
Thread.CurrentPrincipal = MyPrincipal; } PrivateInfo(); return 0; } public static void PrivateInfo() { try { //
Create a PrincipalPermission object. PrincipalPermission MyPermission = new
PrincipalPermission("MyUser", "Administrator"); // Demand this permission. MyPermission.Demand(); //
Print secret data. Console.WriteLine( "\n\nYou have access to the private data!"); } catch(SecurityException
e) { Console.WriteLine(e.Message); } } }
Se os tipos 1 de usuário, os objetos Principal e identidade necessários para acessar o PrivateInfo

método são criados. Se o usuário digitar qualquer outro caractere, nenhum objeto principal e
identidade são criados e uma exceção de segurança é acionada quando o PrivateInfo método é
chamado. Se o segmento atual está associado a um objeto que tem o nome MyUser e a
Administrator função, a seguinte mensagem será exibida.
You have access to the private data!
Como: Recusar permissões usando o sinalizador RequestRefuse
Se você estiver preocupado com que seu código pode ser usado para acessar recursos do
sistema de forma mal-intencionada, você pode solicitar que ele nunca ser concedida uma
permissão específica. Por exemplo, um aplicativo que navega dados em um arquivo mas nunca
modifica os dados podem recusar quaisquer permissões de gravação arquivo. No caso de um erro
ou um ataque malicioso, esse código não pode danificar os dados no qual ele funciona.
Permite que RequestRefuse um grande conjunto de permissões para ser solicitado como
opcional permissões, garantindo determinadas permissões específicas que não estão na
concessão.
O exemplo a seguir utiliza RequestRefuse para recusar FileIOPermission do sistema de

segurança Runtime idioma comum:
Exemplo
C#

[assembly:FileIOPermission(SecurityAction.RequestRefuse ,Unrestricted = true)] namespace MyNameSpace
{ using System; using System.Security; using System.Security.Permissions; using System.IO; public class
MyClass { public MyClass() { } public static int Main(string[] args) { //Creation of the log is attempted in the
try block. try { StreamWriter TextStream = new StreamWriter("Log.txt"); TextStream.WriteLine("This Log
was created on {0}", DateTime.Now); TextStream.Close(); Console.WriteLine("The Log was created"); }
//Catch the Security exception and inform the user that the //application was not granted FileIOPermission.
catch(SecurityException) { Console.WriteLine("This application does not have permission to write to the
disk."); } return 0; } } }
O exemplo anterior não recebeu permissão para criar o arquivo e gera uma exceção de
segurança. A instrução catch intercepta a exceção e o aplicativo exibe a mensagem a seguir para
o console:
COMO: Solicitar Permissão para Acessar Código Não-Gerenciado
Você pode facilmente solicitar permissões pela aplicação Atributos que representam as
permissões que você deseja solicitação para o nível Conjunto de seu código. Você usar os
atributos podem variar, dependendo as permissões que você está solicitando. Solicitações são
compilado no e avaliadas pelo tempo de execução quando seu código é carregado na memória
durante a execução. do seu aplicativo é manifesto de conjunto de módulos (assembly) o
Metadados
O exemplo a seguir mostra como solicitar permissão para acessar código não gerenciado.
Observe que ele usa um SecurityPermissionAttribute. e especifica dois valores), e um sinalizador
que indica qual permissão é está sendo solicitado um SecurityAction valor que especifica o tipo de
solicitação de permissão está sendo feita, no caso: (RequestMinimum Nesse caso,
SecurityPermissionFlag.UnmanagedCode especifica uma solicitação de permissão de código não
gerenciada. A assembly: sintaxe informa o compilador que o atributo está sendo aplicada no nível
do conjunto.
Exemplo
C#
[assembly:SecurityPermissionAttribute(SecurityAction.RequestMinimum, Flags =
SecurityPermissionFlag.UnmanagedCode)] namespace MyNamespace { using System; using
System.Runtime.InteropServices; public class MyClass { public MyClass() { } public void MyMethod() {
//Perform interoperation with unmanaged code here. } } }
Se o código anterior não receber SecurityPermission com o UnmanagedCode Sinalizador,

tempo de execução throws um PolicyException e o código não é permitido para executar. No
entanto, se o código não receber essa permissão, então ele tem permissão para executar.
COMO: Solicitar Permissão para um Conjunto de Permissões Nomeadas
Em vez de solicitar permissões individuais,. (), usando RequestMinimum, RequestOptional ou

RequestRefuse Você pode solicitar os os seguintes conjuntos permissão interna, Execution,
InternetFullTrust, LocalIntranet e SkipVerification: Nothing Não é possível solicitar
personalizado chamado conjuntos de permissões ou a Everything permissão interna modificável

definir porque eles representam as permissões pode variar. O exemplo a seguir mostra a sintaxe
para solicitar permissão para um conjunto de permissões nomeado. Anexa com um Name valor
que representa o nome da permissão desejado Definir. um PermissionSetAttribute
Exemplo
C#
//The attribute is placed at the assembly level. using System.Security.Permissions;
[assembly:PermissionSetAttribute(SecurityAction.RequestMinimum, Name = "FullTrust")] namespace
MyNamespace { using System; using System.Runtime.InteropServices; public class MyClass { public
MyClass() { } public void MyMethod() { //Perform operations that require permissions here. } } }
Como: Solicitar permissões opcionais usando o sinalizador RequestOptional
O SecurityAction.RequestOptional Sinalizador, você pode solicitar um conjunto de permissões

enquanto recusando todas as outras permissões o Runtime caso contrário pode ter sido disposto
a fornecer. Por outro lado, o RequestRefuse Sinalizador permite fazer recusar permissões,
especificando quais seu código não deve ser concedido explicitamente.
Ao contrário de usar o RequestMinimum Sinalizador, o aplicativo será executada se ele não

receber todas as permissões que você solicitar usando o RequestOptiona Sinalizador l, e um
SecurityException ser acionada quando seu aplicativo tenta acessar um recurso protegido se. Se
você usar esse tipo de solicitação, você deve ativar o seu código para capturar quaisquer
exceções serão que ser acionada se seu código não é concedido a permissão opcional.
As solicitações FileIOPermission exemplo a seguir usando o SecurityAction.RequestOptional

Sinalizador, indiretamente recusando todas as outras permissões. Este exemplo assume que
existe em LogNameSpace Uma classe Log hipotético. A Log classe contém o MakeLog método que
cria um novo arquivo de log no computador local. Este aplicativo cria uma nova instância da
classe Log e executa o MakeLog método no bloco try. Usando a catch palavra-chave, ela
intercepta qualquer SecurityException acionada e exibe uma mensagem.
Exemplo
C#
[assembly:FileIOPermission(SecurityAction.RequestOptional, Unrestricted = true)] namespace
MyNamespace { using System; using System.Security; //The hypothetical class log is in this namespace.
using LogNameSpace; public class MyClass { public MyClass() { } public static void Main(string[] args) {
//Put any code that requires optional permissions in the try block. try { Log MyLog = new Log();
MyLog.MakeLog(); Console.WriteLine("The Log has been created."); } //Catch the security exception and
inform the user that the //application was not granted FileIOPermission. catch(SecurityException) {
Console.WriteLine("This application does not have permission to write to the disk."); } } } }
O código anterior cria o arquivo de log e exibirá a seguinte mensagem para o console se ele tiver
permissões suficientes:
The Log has been created.
Se o código é executado em um compartilhamento e as configurações de segurança local não

permitem esse código para possui FileIOPermission, o código não é concedido permissão
suficiente e exibirá a seguinte mensagem:

COMO: Armazenar Chaves Asssimétricas em um Contêiner de Chaves
Assimétrica chaves particulares nunca devem ser armazenadas verbatim ou em texto sem
formatação para o computador local. Se você precisará armazenar uma chave particular, você
deve usar um contêiner de chave Para obter mais informações sobre recipientes chave, consulte a
seção CryptoAPI na documentação do Platform SDK em http://msdn.microsoft.com.
Para criar uma chave assimétrica e salvá-lo em um contêiner de chave

1. Criar uma nova instância de uma CspParameters classe e passar o nome que você deseja
que chamar o contêiner de chave para o CspParameters.KeyContainerName campo.
2. Create a new instance of a class that derives from the AsymmetricAlgorithm class (usually
RSACryptoServiceProvider or DSACryptoServiceProvider) and pass the previously
created CspParameters object to its constructor.
Para excluir uma chave de uma contêiner de chave
1. Criar uma nova instância de uma CspParameters classe e passar o nome que você
deseja que chamar o contêiner de chave para o CspParameters.KeyContainerName
campo.
2. Criar uma nova instância de uma classe que deriva da classe AsymmetricAlgorithm (. ou
DSACryptoServiceProvider) e passar o objeto anteriormente criado CspParameters para
seu construtor geralmente RSACryptoServiceProvider
3. Definir a PersistKeyInCSP propriedade de classe que deriva de AsymmetricAlgorithm
para false (False no Visual Basic.)
4. Chame o Clear método da classe que deriva de AsymmetricAlgorithm. Esse método
libera todos os recursos da classe e limpa o contêiner de chave.
Exemplo
O exemplo a seguir demonstra como criar uma chave assimétrica, salvá-lo em um contêiner de
chave, recuperar a chave em uma hora posterior e excluir a chave do contêiner.
Observe que que código no método GenKey_SaveInContainer e o GetKeyFromContainer método é

semelhante. Quando você especificar um nome contêiner de chave para um CspParameters
objeto e transmiti-las a um AsymmetricAlgorithm objeto com a PersistKeyInCsp propriedade ou
PersistKeyInCsp propriedade definida como true, ocorre o seguinte. Se um contêiner de chave
com o nome especificado não existir, então um é criado e a chave é persistente. Se um contêiner
de chave com o nome especificado não existir, então a chave no contêiner automaticamente é
carregado no objeto atual AsymmetricAlgorithm. Portanto, o código no método
GenKey_SaveInContainer persiste a chave porque ele é executado primeiro, enquanto o código no
método GetKeyFromContainer carrega a chave porque ele é executado segundo.
C#
using System; using System.IO; using System.Security.Cryptography; public class StoreKey { public static
void Main() { try { // Create a key and save it in a container. GenKey_SaveInContainer("MyKeyContainer");
// Retrieve the key from the container. GetKeyFromContainer("MyKeyContainer"); // Delete the key from
the container. DeleteKeyFromContainer("MyKeyContainer"); // Create a key and save it in a container.
GenKey_SaveInContainer("MyKeyContainer"); // Delete the key from the container.
DeleteKeyFromContainer("MyKeyContainer"); } catch(CryptographicException e) {
Console.WriteLine(e.Message); } } public static void GenKey_SaveInContainer(string ContainerName) { //
Create the CspParameters object and set the key container // name used to store the RSA key pair.

CspParameters cp = new CspParameters(); cp.KeyContainerName = ContainerName; // Create a new
instance of RSACryptoServiceProvider that accesses // the key container MyKeyContainerName.
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp); // Display the key information to the
console. Console.WriteLine("Key added to container: \n {0}", rsa.ToXmlString(true)); } public static void
GetKeyFromContainer(string ContainerName) { // Create the CspParameters object and set the key
container // name used to store the RSA key pair. CspParameters cp = new CspParameters();
cp.KeyContainerName = ContainerName; // Create a new instance of RSACryptoServiceProvider that
accesses // the key container MyKeyContainerName. RSACryptoServiceProvider rsa = new
RSACryptoServiceProvider(cp); // Display the key information to the console. Console.WriteLine("Key
retrieved from container : \n {0}", rsa.ToXmlString(true)); } public static void
DeleteKeyFromContainer(string ContainerName) { // Create the CspParameters object and set the key
container // name used to store the RSA key pair. CspParameters cp = new CspParameters();
cp.KeyContainerName = ContainerName; // Create a new instance of RSACryptoServiceProvider that
accesses // the key container. RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cp); // Delete
the key entry in the container. rsa.PersistKeyInCsp = false; // Call Clear to release resources and delete the
key from the container. rsa.Clear(); Console.WriteLine("Key deleted."); } }
Saída
Key added to container: <RSAKeyValue> Key Information A</RSAKeyValue> Key retrieved from
container : <RSAKeyValue> Key Information A</RSAKeyValue> Key deleted. Key added to container:
<RSAKeyValue> Key Information B</RSAKeyValue> Key deleted.
COMO: Adicionar Assemblies à Política de Segurança usando Caspol.exe
Um conjunto que implementa uma permissão personalizada, ou implementa qualquer outro objeto
de segurança personalizado que não está incluído no .NET Framework, deve ser adicionado à
lista do conjunto totalmente confiável. Você pode fazer isso usando o Ferramenta Diretiva de
segurança para acesso de código (Caspol.exe). Não é uma lista separada para cada nível de
diretiva. A lista do conjunto totalmente confiável concede seus membros para o nível de diretiva
relacionadas confiança total. Isso é necessário para manter o Runtime de executar resoluções da
diretiva circular.
Para adicionar um conjunto que implementa um objeto de segurança personalizados para a lista
do conjunto totalmente confiável
1. Antes de adicionar um conjunto a diretiva de segurança, você deve dar-lhe um nome de
alta segurança e colocá-lo no cache de conjunto global Para obter mais informações sobre
como trabalhar com conjuntos e o cache de conjunto de módulos global, consulte Criando e
usando conjuntos Named STRONG-.
2. Digite o seguinte comando no prompt de comando:
[caspol -enterprise | -user | -machine] addfulltrust – AssemblyFile
Especificar a opção Nível diretiva antes da –addfulltrust opção.Se você omitir a opção
Nível de diretiva, listas Caspol.exe a permissão define como o nível de diretiva padrão. Para
administradores de computadores, o nível padrão é o nível de diretiva da máquina; para
outros, ele é o nível de diretiva de usuário.
O comando a seguir adiciona MyCustomPermissionSet.exe à lista o nível de diretiva de
usuário na montagem totalmente confiável.
caspol –user –addfulltrust MyCustomPermissionSet.exe

3. Se você adicionar o conjunto depende do outro conjunto você também deve incluir esse
conjunto para a lista. (ou seja, usa tipos implementados em outro conjunto),
Adicionar um conjunto a uma lista do conjunto totalmente confiável não não garante que ele irá
receber confiança total pelo sistema da diretiva como um todo, mas apenas que ele irá receber
confiança total no nível de diretiva onde ele estiver listado. Por exemplo, se você incluir o conjunto
MyCustomPermission.exe para o nível de diretiva de usuário é totalmente confiável Lista do
conjunto, mas MyCustomPermission.exe recebe direitos de execução apenas de diretiva da
máquina, MyCustomPermission.exe eventualmente seria concedida apenas direitos de execução.
Portanto, é importante lembrar que colocar um conjunto na lista do conjunto totalmente confiável
somente ajuda evite criar resoluções da diretiva circular para o nível de diretiva onde ele estiver
listado. Isso não garante que o conjunto realmente implementar a permissão personalizada recebe
uma concessão confiança total.
COMO: Exibir Grupos de Código Utilizando Caspol.exe
Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) você pode usar para
exibir uma lista simples de grupos de código pertencentes a um nível de diretiva, ou uma lista que
inclui os nomes e descrições dos grupos de código.
Para listar o código grupos para um nível de diretiva

• Digite o seguinte comando no prompt de comando:
[caspol -enterprise | -all | -machine | -user] listgroups –
Especificar a opção Nível diretiva antes da –listgroups opção.Se você omitir a opção Nível de
diretiva, Caspol.exe listará os grupos de códigos no nível de diretiva padrão. Para
administradores de computadores, o nível padrão é o nível de diretiva da máquina; para outros,
ele é o nível de diretiva de usuário.
O comando a seguir lista os grupos de códigos no nível de diretiva do usuário.
caspol –user -listgroups
Para listar os nomes de grupo de código e descrições de um nível de diretiva

[caspol -enterprise | -all | -machine | -user] listdescription –
Se você omitir a opção Nível de diretiva, Caspol.exe listará os grupos de códigos no nível
padrão.
O comando a seguir lista os grupos de códigos e as descrições para todos os níveis de diretiva
(Empresa, Máquina e Usuário).
caspol –all –listdescription
COMO: Modificar Permissões em um Conjunto de Permissões
Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para modificar uma permissão
em um conjunto de permissão.
Observação
O.NET Framework inclui diversos conjuntos de permissão interna. O conjunto de permissões

somente internos que pode ser alterado é o Everything conjunto de permissão.
Para modificar uma permissão em uma permissão definido usando Mscorcfg.msc

1. Execute a ferramenta .NET Framework Configuration (Mscorcfg.msc).
1. No Painel de Controle, abra Ferramentas administrativas.
2. Clique duas vezes Microsoft .NET Framework <version> Configuration.
Como alternativa, você pode executar a ferramenta em um prompt de comando:
o Nas versões do .NET Framework 1.0 e 1.1, digite o seguinte no prompt de
comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc
o Do Prompt de comando SDK no início .NET Framework 2.0, e tipo mscorcfg.msc.
2. Expanda o Runtime Security Policy nó.
3. Expanda o nó para o nível de diretiva você deseja alterar a permissão para.
4. Expanda o Permission Sets nó.
5. Clique com o botão direito do mouse no conjunto de permissão cuja permissão você
deseja modificar e escolha Change Permissions.
6. Selecione uma permissão a partir da Assigned Permissions lista e clique em Properties.
A Permission Settings caixa de diálogo será exibida, que contém informações sobre a
permissão selecionada. Altere as informações para essa permissão e clique em OK.
COMO: Adicionar Permissões a um Conjunto de Permissões
Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para adicionar uma permissão a
um conjunto de permissão.
Observação

Para adicionar uma permissão a uma permissão definido usando Mscorcfg.msc

comando: %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc.
3. Expanda o nó para o nível de diretiva que contém o conjunto de permissão você deseja
adicionar a permissão para.
5. Clique com o botão direito do mouse no conjunto de permissão você deseja adicionar a
permissão para e escolha Change Permissions.
6. Selecione uma permissão a partir da Available Permissions lista e clique em Add. A
Permission Settings caixa de diálogo será exibida, que contém informações sobre a
permissão selecionada. Digite as informações necessárias para essa permissão e clique
em OK.
Se você desejar adicionar uma permissão personalizada, clique no Import botão e navegue
até o arquivo XML que contém informações sobre a permissão personalizada.
7. Quando você tiver terminado adicionar permissões, clique em Finish.
COMO: Suprimir Avisos de Alteração de Política Usando Caspol.exe
Do Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) sempre que você usa
uma opção que altera a diretiva de segurança, avisa sobre a alteração de diretiva específico que
está prestes a ocorrer. Se você estiver familiarizado com Caspol.exe e considere desses avisos
desnecessários, você pode desativá-los.
Para suprimir avisos alterar da diretiva

caspol –polchgprompt off
Para ativar diretiva alterar avisos

caspol –polchgprompt on
Antes como desativar este recurso, considere que geralmente é muito mais fáceis de serem
confirmar uma alteração de diretiva. antes que ele é para corrigir a diretiva posteriormente
COMO: Alterar Condições de Participação em um Grupo de Código
Você pode usar a ferramenta .NET Framework Configuration (Mscorcfg.msc) para alterar
condições de membro em relação a grupos de códigos.
Para alterar para um grupo de códigos usando Mscorcfg.msc condições de membro

3. Expanda o nó para o nível de diretiva que contém o grupo de código que você deseja
modificar.
4. Expanda o Code Groups nó e expanda árvore sob o All_code nó.
5. Clique com o botão direito do mouse no grupo de código adequada e selecione
Properties.
6. Clique na Membership Condition guia.
7. Selecione a condição de membros você deseja associar ao grupo de códigos na caixa de
listagem drop-down. Em seguida, siga as instruções para digitar as informações
necessárias para a condição de membro e clique em OK.
Se você deseja importar uma condição de membro de um arquivo XML, selecione (custom)
na lista drop-down condição de participação. Clique Import e navegue até o arquivo XML.

COMO: Exibir Grupos de Código e Conjuntos de Permissões Usando Caspol.exe
Configurações de segurança indesejado se algumas vezes, aplicam a um conjunto porque ele por
engano pertence ou não pertence a algum grupo de códigos. Esses efeitos colaterais pode
ocorrer quando os grupos de códigos são adicionadas ou excluídas de níveis de diretiva. Do
Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) para facilitar ainda mais a
localizar esses problemas no código os níveis de diretiva ' hierarquias de grupo, você pode usar
para listar todos os grupos de código pertence a um conjunto.
O conjunto é concedido um conjunto de permissões por cada nível de diretiva. O conjunto de

permissões efetivas que a diretiva de segurança concede ao código é determinado pela
interseção das conjuntos de permissões concedidas pelas diretivas máquina e usuário. Você pode
usar Caspol.exe para exibir conjunto concedido a um conjunto de permissões por um nível de
diretiva específico. Você pode usar Caspol.exe para exibir o conjunto de permissões que resulta
da interseção do conjunto de permissão concedido pelas diretivas máquina e usuário.
Para listar os grupos de códigos um conjunto pertence a

[caspol -enterprise | -all | -machine | -user] resolvegroup – assembly-file
Especificar a opção Nível diretiva antes da –resolvegroup opção.Se você omitir a opção Nível
de diretiva, Caspol.exe mostra todos os níveis de diretiva.
O comando a seguir lista os grupos de códigos que MyAssembly.dll pertença no nível de diretiva
do usuário.
caspol – resolvegroup do usuário – MyAssembly.dll
Para listar a permissão definir para um conjunto

caspol [-enterprise|-machine|-user|-all] –resolveperm assembly-file
Especificar a opção Nível diretiva antes da –resolveperm opção.Se você omitir a opção Nível
de diretiva, Caspol.exe mostra a interseção de todos os níveis de diretiva.
O comando a seguir solicita uma lista de permissões que se aplicam a MyApplication.exe no
nível de diretiva do usuário.
caspol –user –resolveperm MyApplication.exe
Como: Administrar a política de segurança para usuários não padrão usando Caspol.exe
administrar uma diretiva de usuário para um usuário que não seja o usuário atual.
Para administrar diretiva de usuário para um usuário que não seja o usuário atual
• Use the -customuser path option instead of the –user policy-level option.
The –customuser option points Caspol.exe to a specified user security configuration file. Note
that –customuser must be followed by the path to the user security configuration file.
O comando a seguir lista os grupos de códigos no usuário arquivo de configuração de diretiva
de segurança localizado em C:\config_test\.
caspol –customuser "C:\config_test\security.config" –listgroups

Quando você especifica a –all opção antes da opção Nível de diretiva para listar ou resolver
Diretiva, Caspol.exe considera todos os níveis de diretiva (usuário, máquina, e empresa).A -all
opção sempre usa a diretiva para o usuário atual. No entanto, você pode usar a diretiva para outro
usuário em uma lista de todos os níveis de diretiva ou uma resolução da diretiva em níveis de
diretiva.
Para listar ou resolver toda a diretiva níveis para um usuário que não seja o usuário atual
• Use a -customall path opção em vez da opção -all.

O seguinte comando resolve diretiva contra a empresa atual e diretiva da máquina,, bem como
contra uma diretiva de usuário personalizada.
caspol –customall "c:\config_test\security.config" –resolvegroup "myApplication.exe"
COMO: Alterar Conjuntos de Permissão Associados com um Grupo de Código Existente
Você pode usar a ferramenta .NET Framework Configuration (Mscorcfg.msc) para alterar os
conjuntos de permissões associados a um grupo de códigos.
Para alterar permissão conjuntos associado a um grupo de códigos existentes usando

Mscorcfg.msc
3. Expanda o nó para o nível de diretiva que contém o grupo de código que deseja modificar.
5. Clique com o botão direito do mouse no grupo de código adequada e selecione
Properties.
6. Clique na Permission Set guia.
7. Selecione a permissão conjunto você deseja associar ao grupo de códigos na lista drop-
down e clique em OK.
COMO: Analisar Problemas com Permissões de Assembly Usando Caspol.exe
Você pode usar para solucionar problemas que podem causar um conjunto para não executar ou
para acessar recursos protegidos ou executado quando não deveria. o Ferramenta Diretiva de
segurança para acesso de código (Caspol.exe)
Para analisar problemas com um conjunto que não é executado

1. Use the –all and the –resolveperm options to determine the permissions that policy grants
to the assembly:
caspol –all –resolveperm assembly-file
Determinar se o conjunto tem o direito de executar, verificando se o sinalizador de
execução está definido na classe SecurityPermission. Se o conjunto possui direitos de

execução, o conjunto de permissões de segurança será ser irrestrito, ou o atributo
sinalizadores irão incluir o sinalizador de execução.
Se o conjunto deve acessar um recurso protegido, (por exemplo, para acessar um disco,
criar janelas, gravação para o registro, e assim por diante), verifique se as permissões
apropriadas estão definidas.
2. Como as permissões concedidas pelos níveis de diretiva Empresa, Máquina, e usuário
interseção, uma permissão deve ser definida em todos os níveis de um conjunto para
recebê-lo. Se o conjunto não possui permissões suficientes, verifique as permissões
concedidas ao conjunto em cada nível de diretiva:
caspol –enterprise –resolveperm assembly-file
caspol –machine –resolveperm assembly-file
caspol –user –resolveperm assembly-file
3. Se o conjunto for parte de um grupo de códigos cuja condição de membro é muito
restritiva, ou definido cuja permissão associado não contém as permissões necessárias
para o conjunto à função, o conjunto não pode ser executado corretamente. Se as
permissões concedidas ao código são insuficientes, você pode criar um novo grupo de
códigos que concede o conjunto as permissões necessárias
Você também pode modificar o conjunto de permissões associado de ou a condição de
membro de um dos grupos de códigos existentes para que o conjunto recebe as
permissões apropriadas. Para obter mais informações sobre como fazer isso, consulte
Como alterar grupos de códigos usando Caspol.exe:.
Para analisar um conjunto que acessa recursos protegidos ou é executada quando não deveria
• Se um conjunto é executado mas não, Deve ou se acessar recursos que ele não deve
acessar (tais como recursos necessários para criar caixas de diálogo), um conjunto o conjunto
provavelmente tem sido receber permissões muitos. Use the –resolveperm option to
determine which permissions the assembly has been granted. Then use the –resolvegroups
option to determine which code groups it belongs to. Alterar as condições de participação ou os
conjuntos dos grupos de códigos associados para limitar as permissões concedidas ao
conjunto de permissões associado.
COMO: Exibir Conjuntos de Permissão Usando Caspol.exe
listar a permissão define pertencentes para todos os níveis de diretiva ou para um nível única
diretiva.
Para exibir a permissão conjuntos usados em um nível de diretiva

[caspol-enterprise | -all | -machine | -user] -listpset
Especificar a opção Nível diretiva antes da –listpset opção.Se você omitir a opção Nível de
diretiva, listas Caspol.exe a permissão define para o nível de diretiva padrão. Para
O comando a seguir lista os conjuntos de permissão para todos os níveis de diretiva três.
caspol –all -listpset
COMO: Desfazer Alterações de Política Usando Caspol.exe

Se uma alteração de diretiva tem indesejados efeitos colaterais ou se acidentalmente a alteração
foi feita no nível da Diretiva de segurança errado para recuperar a última diretiva Máquina, Usuário
ou empresa antes que a alteração foi feita. No diretiva nível do computador em vez do nível de
diretiva de usuário), como você pode usar (o Ferramenta Diretiva de segurança para acesso de
código (Caspol.exe)
Para desfazer uma alteração de diretiva

[caspol -enterprise | -all | -machine | -user] –recover
Especificar a opção Nível diretiva antes da –recover opção.Se você omitir a opção Nível de
diretiva, Caspol.exe desfaz a alteração de diretiva no nível de diretiva padrão. Para
O seguinte comando desfaz a última alteração para a diretiva de usuário.
caspol –user -recover
Observação
A –recover opção somente desfaz a última alteração.Caspol.exe não não cache quaisquer
alterações feitas a última alteração antes. Se você chamar essa opção duas vezes, você desfazer
a recuperação da diretiva.
COMO: Importar uma Permissão Usando um Arquivo XML
Um aplicativo talvez precise controlar o acesso a um recurso em uma maneira através de que não
haja suporte pelas permissões fornecidos com o SDK do .NET Framework. Por exemplo, um
aplicativo pode usar os registros de pessoal onde cada registro de funcionário é armazenado em
um arquivo separado;, nesse caso, acesso Leitura e Gravação deve ser controlado
independentemente em diferentes tipos de dados Funcionários. O desenvolvedor de aplicativos
deve fornecer uma classe de permissão que permite que o aplicativo para que esse nível de
detalhes de acesso para um arquivo.
Exemplo
O exemplo a seguir mostra como as informações para uma permissão podem exibidas no arquivo
XML.
<IPermission class="CustomPermission, customPerm, Version=0.0.0.0, Culture=neutral,

PublicKeyToken=64a85a7d791b1a32" version="1" Unrestricted="True"/>
O <IPermission> elemento, class atributo, e version Atributo são presente para cada permissão
no arquivo XML. O class atributo aponta para a classe e conjunto que implementam a permissão
personalizada. A seqüência valor para este atributo pode estar em qualquer formato discutido no
Especificando tipo nomes totalmente qualificados, mas será provavelmente estar no formato
mostrado no exemplo.
A <IPermission> marca pode conter outros atributos ou elementos filho definidos pelo
desenvolvedor que descrevem o estado da permissão. No exemplo anterior, o Unrestricted
atributo é definido pela classe CustomPermission.

A nova permissão deve ir em um conjunto de permissões. Você pode usar para colocar a
permissão em um dos conjuntos de permissão mutáveis ou para criar uma nova permissão
definida. o Ferramenta .NET Framework Configuration (Mscorcfg.msc)
Cuidado
Antes de adicionar a permissão a diretiva de segurança, você talvez precise alterar o arquivo XML
para que o estado da permissão atenda às suas necessidades. Consulte a documentação do
aplicativo para saber sobre os atributos específicos para a permissão e como alterar seu estado.
Cada grupo de código que está associado ao conjunto de permissões modificado concederá a
nova permissão para código que é um membro do grupo do código. Para saber como adicionar
uma permissão personalizada a um conjunto de permissões, consulte Configurar conjuntos de
permissões usando a ferramenta Configuração .NET Framework.
COMO: Voltar para as Configurações de Política de Segurança Padrão Usando Caspol.exe
Ocasionalmente, talvez seja necessário para redefinir uma diretiva de segurança para os padrões
após algumas alterações da diretiva criar efeitos colaterais indesejáveis. A diretiva de segurança
padrão fornece segurança adequada para seu computador em maioria das situações.
Para retornar para as configurações Diretiva de segurança padrão

[caspol -enterprise | -all | -machine | -user] –reset
Especificar a opção Nível diretiva antes da –reset opção.Se você omitir a opção Nível de
diretiva, a Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) retorna as
configurações Diretiva de segurança padrão no nível de diretiva padrão. Para administradores
de computadores, o nível padrão é o nível de diretiva da máquina; para outros, ele é o nível de
diretiva de usuário.
O comando a seguir redefine a diretiva Máquina.
caspol –machine –reset
Observação
Você pode desfazer a redefinição usando a –recover opção se nenhuma alteração de diretiva
forem feitas após a –reset chamada.
COMO: Adicionar Grupos de Código Usando Caspol.exe
Sample Group Addition Commands
When you use the Code Access Security Policy tool (Caspol.exe) to add a code group to a code
group hierarchy, you must define both a membership condition and a permission set for the new
code group. You must also define the label or name of the parent code group in which you are
adding the new code group. Optionally, you can also set other flags on the code group. For more
information about these flags, see Code Access Security Policy Tool (Caspol.exe).
To add a code group to a code group hierarchy

• Type the following command at the command prompt:

caspol [-enterprise|-machine|-user] -addgroup {parentLabel|parentName} mship pset_name
[-exclusive {on|off}][-levelfinal {on|off}] [-name name] [-description description text]
Specify the policy-level option before the –addgroup option. If you omit the policy-level option,
Caspol.exe adds the code group to the default policy level. For computer administrators, the
default level is the machine policy level; for others, it is the user policy level. In this command:
o The parentLabel argument is the label of the parent code group for the new code
group. Alternatively, you can use the parent's code group name (parentName) instead of the
parentLabel. To obtain this information, list the code groups as described in How to: View Code
Groups Using Caspol.exe.
o The pset_name argument is the name of the permission set to associate with the
new code group. Before a named permission set can be associated with a code group, it must
be known at the policy level where you are adding the new code group. For example, if you
want to associate a MyPset permission set with a new code group in the user policy, you must
have already added the MyPset permission set to the user policy. The only time a permission
set does not need to be added beforehand is when you use one of the standard permission
sets provided by the .NET Framework. To learn how to add a permission set to a policy level,
see How to: Add Permission Sets Using Caspol.exe.
o The mship argument is the membership condition for the new code group. For the
list of values for the mship argument, see Code Access Security Policy Tool (Caspol.exe).
Observação
You cannot use the –addgroup option to add a code group to more than one level at a time. Each
such addition must be made separately because different code group labels and the availability of
certain permission sets can cause confusion.
Sample Group Addition Commands
The following procedures describe how to perform some of the most common code group addition
tasks.
To add a code group that targets code from the intranet
• Use the -zone option, and specify Intranet as the membership value.
The following command associates the Everything permission set with code from the intranet.
The code group is also given the name Intranet_CG. You can use this name to refer to the
newly created code group, rather than using its numeric labels.
caspol –addgroup 1.1. –zone Intranet Everything –name "Intranet_CG"
To add a code group that targets code from the Internet Explorer Trusted sites
• Use the –zone option, and specify Trusted as the membership value.
The following command associates the LocalIntranet permission set with code from the trusted
zone and inserts the new code group as a child of the root of the code group hierarchy.
caspol -addgroup All_Code -zone Trusted LocalIntranet
To add a code group that targets a specific software publisher
• Use the –pub option, and specify a certificate file, a signed file, or the hexadecimal
representation of an X.509 certificate.

Files from a software publisher must be signed appropriately for this membership condition to
work. The membership condition can be constructed on the basis of either an actual certificate
file or a signed .exe file.
Suppose the certificate file for FourthCoffee (FourthCoffee.cer) is available. The following
command adds a code group in the machine policy for code published by FourthCoffee and
associates the Nothing permission set with the new group. The code group is added as a child
code group of the root.
caspol –machine –addgroup 1 –pub –cert FourthCoffee.cer Nothing
To add a code group that targets code from a particular Web site
• Use the –site option, and specify the URL of the Web site.
Observação
Due to the possibility of DNS name spoofing, using a Web site as a membership condition is not an
effective way to ascertain the identity of code. Where possible, use a strong name membership
condition, publisher membership condition, or the hash membership condition.
• The following command associates the Intranet permission set with code from
www.microsoft.com.
• caspol –addgroup 1 –site www.microsoft.com Intranet
To add a code group that targets code from a particular URL
• Use the –url option, and specify the URL of the site.
The URL must include a protocol, such as http://, http://, or ftp://. Additionally, a wildcard
character (*) can be used to specify multiple assemblies from a particular URL.
Observação
Because a URL can be identified using multiple names, using a URL as a membership condition is
not a safe way to ascertain the identity of code. Where possible, use a strong name membership
condition, a publisher membership condition, or the hash membership condition.
caspol –user –addgroup 1 –url http://www.contoso.com/bin/* FullTrust caspol –user –addgroup 1 –url
http://www.contoso.com/bin/MyAssembly.dll FullTrust
To add a code group that overrides other permissions at a policy level
• Set the –exclusive flag for the new code group.

The following command adds a code group under the Intranet_cg code group. The new code
group grants the Everything permission set if the zone is trusted, overriding any other
permissions that other code groups might grant.
caspol –addgroup "Intranet_cg" –zone Trusted Everything –exclusive on
To add a code group with a custom membership condition
• Use the –custom option, and specify an XML file that contains the XML serialization of the
custom membership condition.

Caspol.exe supports the use of custom membership conditions in policy, which makes the
policy system highly extensible.
The following command adds a new code group to the root of the user policy. This new code
group contains a custom membership condition found in the NewMembershipCondition.xml file
and grants full trust to assemblies matching this membership condition.
caspol –user –addgroup All_Code –custom NewMembershipCondition.xml FullTrust
To add a code group with a name and description
1. Use the –name option, and specify a name for the code group. Double quotes (" ") are
required around names that contain spaces.
2. Use the –description option, and specify a description for the code group.
You can use the name later to refer to a code group. The name provides better support than
numeric labels for scripting policy changes.
Default policy is shipped with default names. If not explicitly changed by an administrator, the
default names make it easy for administrators using Caspol.exe to access specific code groups
across policies and computers.
The following command adds a code group under the All_Code group in the machine policy. The
new code group checks for a FourthCoffee strong name (as found on Signed.exe) and grants
FullTrust to all code that is so signed. The code group is named FouthCoffeeStrongName and is
given an appropriate description.
caspol –machine –addgroup All_Code –strong –file signed.exe FullTrust –name FouthCoffeeStrongName –
description "Code group granting trust to code signed by FourthCoffee"
Observação
If the same name is present in more than one code group, Caspol.exe resolves to the first code
group it can find with the given name. It searches all the child code groups of a code group before
searching sibling groups.
COMO: Substituir o Mecanismo de Auto-Proteção do Caspol.exe
O Ferramenta Diretiva de segurança para acesso de código (Caspol.exe) contém um mecanismo

Self-Protection que impede alterações de diretiva de segurança que causaria-lo para cessar
funcionando. Você pode substituir esse mecanismo Self-Protection, se necessário. Por exemplo,
um administrador talvez precise substituir o mecanismo Self-Protection para atualizar a
segurança, mesmo que Caspol.exe pode não funcionar corretamente posteriormente.
Para substituir o mecanismo Self-Protection Caspol.exe

• Use a –force opção para a diretiva Alterar opção que caso contrário, ser rejeitada pelo
Caspol.exe.
O comando a seguir altera grupo de código raiz a diretiva Usuário é para associá-lo ao
Nothing conjunto de permissões.
caspol –force –user –chggroup 1 Nothing
Cuidado

Use esta opção somente com extrema cautela. Ele poderá causar Caspol.exe para falhar ou
cessar funcionando, nesse caso, a –recover opção não pode ser aplicada porque Caspol.exe não
pode ser executado.
Observação
Se isso ocorrer, você pode executar o equivalente de uma –recover operação manual.A máquina
submetidos a backup e diretiva de usuário são gravadas em arquivos Security.CFG.old.
Simplesmente excluir o arquivo Security.cfg em onde você fez a alteração, o nível de diretiva e
renomear o arquivo Security.CFG.old para Security.CFG. Para obter mais informações sobre onde
esses arquivos estão localizados, consulte Arquivos de configuração de segurança.
COMO: Criar Grupos de Código
Quando você cria um grupo de códigos usando a ferramenta .NET Framework Configuration
(Mscorcfg.msc), você também deve associar o grupo com uma condição de membro e um
conjunto de permissões.
Para criar código grupos usando Mscorcfg.msc

3. Expanda o nó para o nível de diretiva você deseja adicionar o grupo de códigos para.
5. Clique com o botão direito do mouse no grupo de código que será o pai imediato do novo
grupo de códigos, e escolha New.
6. Dê ao grupo de código um nome e, opcionalmente, uma descrição. Clique em Next.
7. Selecione uma condição de membro na caixa drop-down. Siga as instruções para inserir
as informações solicitadas para a condição de membro. Clique em Next.
8. Escolha um conjunto de permissões existente a partir da caixa drop-down ou selecione
Create a new permission set. Clique em Next e, clique em Finish.
COMO: Desativar a Coleta de Lixo Concorrente
O Common Language Runtime (CLR) ou pode executar coleta de lixo simultaneamente em um

segmento separado ou no mesmo segmento como o aplicativo. Use o < gcConcurrent > elemento
para especificar como o Runtime deve ser executado coleta de lixo. A seguir mostra para
desativar coleta de lixo simultâneas.
Exemplo
<configuration> <runtime> <gcConcurrent enabled="false"/> </runtime> </configuration>

Por padrão, o tempo de execução executa coleta de lixo simultaneamente, que reduz o
desempenho. Se seu aplicativo é segmento único e envolve interação usuário intensivo, deixe
coleta de lixo simultâneas ativada para o aplicativo não faz pausa para executar coleta de lixo. Se
seu aplicativo tem um aplicativo do servidor ASP.NET, não é preciso alterar o valor padrão de
elemento <gcConcurrent>.
COMO: Importar um Grupo de Código Usando um Arquivo XML
Um aplicativo pode exigir que você adicionar um grupo código específico do aplicativo à diretiva
de segurança. O aplicativo pode fornecidos com um conjunto que implementa o novo grupo de
códigos e um arquivo XML que contém um serialização do novo grupo de códigos. O arquivo XML
pode ser importado para diretiva de segurança usando o Ferramenta .NET Framework
Configuration (Mscorcfg.msc). O arquivo XML também pode conter informações sobre
participação o conjunto condição e permissões associada ao grupo de códigos. Normalmente, o
aplicativo atender à condição de participação especificado e precisa definir a permissão
associada.
O exemplo a seguir mostra como informações para um grupo de códigos e seu conjunto condição
e permissão de membros associados podem exibidas em um arquivo XML.
Exemplo
<CodeGroup class="System.Security.Policy.UnionCodeGroup, mscorlib, Version=1.0.2411.0,
Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Name="myCodeGroup"
Description="test code group"> <IMembershipCondition class="MyCustomMembershipCondition,
myAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1"
Url="http://www.microsoft.com/"/> <PermissionSet class="NamedPermissionSet" version="1"
Name="MyPermissionSet" Description="Permission set containing my custom permission"> <IPermission
class="myCustomNamespace.CustomPermission, customPerm, Version=0.0.0.0, Culture=neutral,
PublicKeyToken=64a85a7d791b1a32" version="1" Unrestricted="True"/> </PermissionSet> </CodeGroup>
O <CodeGroup> elemento contém informações para um novo grupo de códigos. O class e

version atributos são necessários para o <CodeGroup> elemento. O class atributo aponta para a
classe e conjunto que implementa o novo grupo de códigos. Valor do class atributo pode ser em
qualquer formato discutido no Especificando tipo nomes totalmente qualificados, mas geralmente
será estar no formato mostrado no exemplo. Para esta versão do .NET Framework, o version
atributo é " 1 ". O Name e Description atributos pode ser qualquer seqüência válida e pode ser
editado. O Name atributo é o nome da permissão definido como ele aparece na ferramenta .NET
Framework Configuration.
O <IMembershipCondition> elemento contém atributos ou elementos filho que especificam a

condição que conjuntos devem atender para se tornar um membro do grupo do código e receber
suas permissões associadas. O class atributo para <IMembershipCondition> está no mesmo
formato que o class atributo para <CodeGroup>.
Se um <CodeGroup> elemento contém um <IMembershipCondition> elemento e uma

<PermissionSet> elemento , participação o conjunto condição e Permissão são associadas ao
grupo de códigos automaticamente quando ele é importado. Do Ferramenta .NET Framework
Configuration (Mscorcfg.msc) se uma desses elementos estiverem faltando, você deverá usar
para associar o item ausente com o novo grupo de códigos. Para obter detalhes, consulte
Configurar grupos de códigos usando a ferramenta Configuração .NET Framework.
COMO: Criar uma Política do Publisher

Fornecedores de conjuntos podem estado que aplicativos devem usar uma versão mais recente
de um conjunto, incluindo um arquivo de diretiva do editor com o conjunto atualizado. O arquivo de
diretivas do editor especifica redirecionamento do conjunto e configurações base de código, e usa
o mesmo formato como um arquivo de configuração do aplicativo. O arquivo de diretivas do editor
é compilado em um conjunto e inserido no cache de conjunto global.
Há três etapas envolvidas ao criar uma diretiva do editor:
1. Criar um arquivo de diretivas do editor.

2. Cria um conjunto da diretiva do editor.
3. Incluir o conjunto da diretiva do editor para o cache de conjunto de módulos global.
O esquema da diretiva do editor está descrita em Redirecionando versões assembly. O exemplo a

seguir mostra um editor que redireciona uma versão do myAssembly para outro arquivo de diretiva.
<configuration> <runtime> <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

<dependentAssembly> <assemblyIdentity name="myAssembly" publicKeyToken="32ab4ba45e0a69a1"
culture="en-us" />  <bindingRedirect
oldVersion="1.0.0.0" newVersion="2.0.0.0"/> </dependentAssembly> </assemblyBinding> </runtime>
</configuration>
Para saber como especificar uma base de código, consulte Especificar local um conjunto na.
Criando o conjunto da diretiva Publisher
Do Vinculador do conjunto (AL.exe) uso para criar o conjunto da diretiva do editor.
Para criar um conjunto da diretiva do editor

al /link:publisherPolicyFile /out:publisherPolicyAssemblyFile /keyfile:keyPairFile
Neste comando:
o O publisherPolicyFile argumento é o nome do arquivo de diretiva do editor.
o O publisherPolicyAssemblyFile argumento é o nome da montagem da diretiva do
editor que resulta deste comando. O nome arquivo do conjunto deve seguir o formato:
policy.majorNumber.minorNumber.mainAssemblyName.dll
o O keyPairFile argumento é o nome do arquivo que contém o par de chaves. Você
deverá assinar o conjunto e editor conjunto da Diretiva com o mesmo par de chaves.
O seguinte comando cria um conjunto da diretiva do editor chamado policy.1.0.myAssembly a
partir de um arquivo de diretiva do editor chamado pub.config, e atribui um nome de alta
segurança ao conjunto usando o par de chaves no arquivo sgKey.snk.
al /link:pub.config /out:policy.1.0.myAssembly.dll /keyfile:sgKey.snk
Adicionando o conjunto da diretiva Publisher no cache do conjunto de módulos (assembly) global
Do Ferramenta Assembly Cache global (Gacutil.exe) uso para adicionar o conjunto da diretiva do
editor a cache de conjunto global.
Para adicionar o conjunto da diretiva do editor a cache de conjunto global

gacutil /i publisherPolicyAssemblyFile
O comando a seguir adiciona policy.1.0.myAssembly.dll a cache de conjunto global.
gacutil /i policy.1.0.myAssembly.dll
COMO: Remover Grupos de Código Usando Caspol.exe
remover grupos de códigos das hierarquias de grupo de código. Quando você exclui um grupo de
código que tenha grupos de códigos filho, você também excluir os grupos de códigos filho. Você
não pode copiar parte de uma hierarquia de grupo de código para outra parte do grupo de códigos
ou para outra hierarquia de grupo de código. Portanto, a exclusão de um grupo de código pai
destrói qualquer comportamento de segurança que foi definido na sua hierarquia filho.
Cuidado
Como ele altamente pode afetar a segurança, tome cuidado extremos quando você exclui grupos
de códigos.
Para remover um grupo de códigos de uma hierarquia de grupo de código

caspol [-enterprise|-machine|-user] –remgroup {label|name}
Especificar a opção Nível diretiva antes da –remgroup opção.Se você omitir a opção Nível de
diretiva, Caspol.exe removerá a hierarquia de grupo de códigos especificada do nível de
diretiva padrão. Para administradores de computadores, o nível padrão é o nível de diretiva da
máquina; para outros, ele é o nível de diretiva de usuário.
O comando a seguir exclui o grupo de códigos rotulado 1.1.2..
caspol –remgroup 1.1.2.
O comando a seguir exclui o grupo de códigos chamado MyApp_CodeGroup.

caspol –remgroup MyApp_CodeGroup
COMO: Criar um Modelo de Canal num Arquivo de Configuração
O exemplo a seguir mostra como criar um modelo do canal em um arquivo de configuração.
Exemplo
<configuration> <system.runtime.remoting> <application> </application> <channels> <channel
id="MyChannel" type="MyChannel,MyChannelAssembly" > <clientProviders> <formatter ref="soap">
</formatter> <provider type="Channels.AuthenticationSink,MyChannels" /> </clientProviders>
</channel> </channels> </system.runtime.remoting> </configuration>
COMO: Alterar Conjuntos de Permissão Usando Caspol.exe
Você pode alterar o conteúdo de uma permissão específica definida por importar um novo arquivo
XML que contém um conjunto de permissões que substitui o conjunto de permissões original. O
conjunto de permissões somente mutáveis fornecido pelo SDK do .NET Framework é o
Everything conjunto de permissão. Do Ferramenta Diretiva de segurança para acesso de código

(Caspol.exe) você pode usar para substituir a permissão original de disco com o novo conjunto
especificado no arquivo XML.
Para alterar uma permissão defina

caspol –chgpset pset_file pset_name.
O comando a seguir altera a FilePset permissão definida na diretiva de usuário para o estado
especificado no arquivo NewPset.xml.
caspol –user –chgpset NewPset.xml FilePset
COMO: Remover Conjuntos de Permissão
Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para remover um conjunto em

um nível específico de permissões.
Para remover uma permissão defina usando Mscorcfg.msc

o No.NET Framework 1.0 e 1.1, digite o seguinte no prompt de comando:
%Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc.
3. Expanda o nó para o nível de diretiva que deseja remover um conjunto de permissões.
5. Clique com o botão direito do mouse no conjunto de permissão você deseja remover e
escolha Delete.
Observação
Não é possível remover conjuntos de permissão interna ou conjuntos de permissões que estão
associados a um grupo de códigos.
COMO: Criar Conjuntos de Permissão
Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para criar uma permissão
definido para uma determinada nível e associá-lo a um grupo de códigos nova ou existente.
Para criar uma permissão conjunto usando Mscorcfg.msc


3. Expanda o nó para o nível de diretiva você deseja adicionar uma permissão definida.
4. Clique com o botão direito do mouse Permission Sets e escolha New.
5. Dar o conjunto de permissões um nome e, opcionalmente, uma descrição. Clique em Next.
6. Selecione uma permissão a partir da Available Permissions lista e clique em Add. A
Permission Settings caixa de diálogo será exibida, que contém informações sobre a
permissão selecionada. Digite as informações necessárias para essa permissão e clique
em OK.
Se você desejar adicionar uma permissão personalizada, clique no Import botão e navegue
até o arquivo XML que contém informações sobre a permissão personalizada.
7. Repita a etapa seis até todas as permissões desejadas são adicionadas ao conjunto de
permissões.
8. Quando você tiver terminado adicionar permissões, clique em Finish.
COMO: Tornar Grupos de Código Exclusivos ou Nível Final
Opcionalmente, usando a ferramenta .NET Framework Configuration (Mscorcfg.msc), você pode

fazer um código exclusivo de grupo ou Nível final, como mostrado nas seguintes instruções.
Para tornar código grupos exclusivo ou final usando Mscorcfg.msc

3. Expanda o nó para o nível de diretiva que contém o grupo de código você deseja tornar
exclusivo ou final.
5. Clique com o botão direito do mouse no grupo de código que você deseja que seja
exclusivo ou final e selecione Properties.
6. Para fazer um grupo de códigos exclusivos, marque a caixa de seleção rotulada " Este
nível de diretiva só terá a permissões do conjunto de permissões associado a este grupo de
código ".
Ou-
Para fazer um nível de grupo de código final, marque a caixa de seleção rotulada " níveis
de diretiva abaixo deste nível não serão avaliados ".
7. Clique em OK.
COMO: Adicionar uma à lista de Política de Assemblies

Para o sistema de segurança para avaliar diretiva em um nível que tenha objetos de segurança
que não são fornecidos com o SDK do .NET Framework, com êxito o conjunto deve ter confiança
total no nível de diretiva.
Do Ferramenta .NET Framework Configuration (Mscorcfg.msc) Quando você receber um conjunto

que contém um novo componente de segurança, use para adicionar o conjunto à lista do conjunto
totalmente confiável.
Observação
Colocar um conjunto na lista do conjunto totalmente confiável fornece confiança total ao conjunto
somente no nível. Se o conjunto não estiver na lista de confiança total em todos os outros níveis, o
conjunto não terá confiança total mas sim a interseção da qual é concedido por aqueles outros
níveis.
Para adicionar um conjunto à lista do conjunto totalmente confiável

1. Em.NET Framework 1.0 e 1.1, na linha de comando, digite
%Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc. Do Prompt
de comando SDK no .NET Framework 2.0, inicie e tipo mscorcfg.msc.
A interface de usuário para a ferramenta é exibida.
3. Expanda o nó para o nível de diretiva você deseja adicionar o novo conjunto para.
4. Clique com o botão direito do mouse Policy Assemblies e escolha Add.
5. Selecione o nome do conjunto a partir da lista que aparece. Esses são os conjuntos que
estão em cache de conjunto global.
6. Clique em Select.
COMO: Importar um Conjunto de Permissão Usando um Arquivo XML
O arquivo XML pode conter um conjunto de permissão (com ou sem uma permissão
personalizada) que contém as permissões do aplicativo precisa ser executado. Você pode
importar a permissão definir em Diretiva de segurança usando o Ferramenta Configuração
estrutura .NET (Mscorcfg.msc) ou usando o Ferramenta Code Access Security Policy
(Caspol.exe).
Adicionando uma permissão personalizada usando a ferramenta Configuração .NET Framework
O exemplo a seguir mostra um conjunto de permissões e uma permissão dentro de um arquivo

XML.
<PermissionSet class="NamedPermissionSet" version="1" Name="MyPermissionSet"

Description="Permission set containing my custom permission"> <IPermission
class="myCustomNamespace.CustomPermission, customPerm, Version=0.0.0.0, Culture=neutral,
PublicKeyToken=64a85a7d791b1a32" version="1" Unrestricted="True"/> </PermissionSet>
O <PermissionSet> elemento pode conter qualquer número de <IPermission> elementos, que

representam as permissões no conjunto de permissões. O class atributo normalmente contém o
valor "NamedPermissionSet" ou "System.Security.NamedPermissionSet". O version atributo
indica a versão do .NET Framework. O Name atributo é o nome da permissão definido como ele
aparece na ferramenta .NET Framework Configuration. O Description atributo fornece uma

descrição do conjunto de permissões. Do Name você pode modificar ambos e Description
atributos.
Cuidado
Antes de adicionar permissão definida como diretiva de segurança, você talvez precise alterar o
arquivo XML para que o estado das permissões atenda às suas necessidades. Consulte a
documentação do aplicativo para saber sobre os atributos específicos para a permissão e como
alterar seu estado.
Para importar uma permissão definir de um arquivo XML utilizando Mscorcfg.msc
1. No.NET Framework 1.0 e 1.1, digite o seguinte no

%Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc Prompt de
comando. Do Prompt de comando SDK no .NET Framework 2.0, inicie e tipo
mscorcfg.msc.
A interface de usuário para a ferramenta é exibida.
3. Expanda o nó para o nível de diretiva você deseja adicionar uma permissão definida.
4. Clique com o botão direito do mouse Permission Sets e selecione New.
5. Clique em Import e selecione o arquivo XML que contém as informações sobre o conjunto
de permissões.
6. Associar permissão definido com um grupo de códigos. Para obter detalhes, consulte
Configurar grupos de códigos usando a ferramenta Configuração .NET Framework
(Mscorcfg.msc).
Adicionando uma permissão personalizada usando Access Código a ferramenta Diretiva de
segurança
Os Ferramenta Code Access Security Policy (Caspol.exe) ships com o .NET Framework SDK e
oferece suporte script para alterar a diretiva de segurança. Você pode usar Caspol.exe para
adicionar novos conjuntos de permissões, mas não para modificar permissão conjuntos. Se o
arquivo XML tiver somente uma permissão — um conjunto — de permissões e você não desejar
adicionar a permissão usando Caspol.exe, você deve colocá a permissão entre um conjunto de
permissões.
Para adicionar uma permissão definida por meio Caspol.exe

caspol {-enterprise|-machine|-user} -addpset xmlFile
Neste comando, xmlFile é o nome do arquivo que contém o conjunto de permissões e a
permissão.
COMO: Localizar Assemblies Usando DEVPATH
Os desenvolvedores podem desejar certificar-se que um conjunto compartilhado que está criando
funciona corretamente com vários aplicativos. Em vez de continuamente colocar o conjunto no
cache de conjunto global durante o ciclo de desenvolvimento, o desenvolvedor pode criar uma
variável de ambiente DEVPATH que aponta para o diretório de saída da compilação para o
conjunto.

Por exemplo, suponha que que você estiver criando um conjunto compartilhado chamado
MySharedAssembly e a pasta de saída é C:\MySharedAssembly\Debug. Você pode colocar
C:\MySharedAssembly\Debug na variável DEVPATH. Em seguida, especifique o <
developmentMode > elemento no arquivo de configuração do computador. Este elemento informa
o Common Language Runtime para usar DEVPATH para localizar conjuntos.
O conjunto compartilhado deve ser localizável pelo tempo de execução. Para especificar uma
pasta particular para resolver conjunto referências usam o <codeBase> Element ou
<probing> Element Em uma configuração arquivo, conforme descrito em Especificar local um
conjunto na. Você também pode colocar o conjunto em um subdiretório do diretório do aplicativo.
Para obter mais informações, consulte Como o tempo de execução localiza conjuntos de módulos
(assemblies).
Observação
Isso é um recurso avançado, direcionado somente para desenvolvimento.
O exemplo a seguir mostra como para fazer com que o tempo de execução para procurar por
conjuntos em diretórios especificados pela variável do ambiente DEVPATH.
Exemplo
<configuration> <runtime> <developmentMode developerInstallation="true"/> </runtime>
</configuration>
Essa configuração será definido padrão como False.
Observação
Use esta configuração somente no tempo de desenvolvimento. Tempo de execução não verifica
as versões em conjuntos de nome seguro encontrados no DEVPATH. Ele simplesmente usa o
primeiro conjunto que encontrar.
COMO: Registrar um Objeto Ativado pelo Servidor e um Objeto Ativado pelo Cliente para um
Domínio de Aplicativo de Host
O exemplo a seguir mostra como registrar um objeto servidor-activated e um objeto activated

cliente-para um domínio do aplicativo host. O type atributo na <activated> marca indica o nome
completo do tipo e nome do conjunto do objeto, como ele aparece na marca <wellknown> .
Exemplo
<configuration> <system.runtime.remoting> <application> <service> <wellknown mode = "SingleCall" type
= "myType,myAssembly" objectUri = "myType.soap" /> <activated type="MyActivatedType, TypeAssembly"
/> </service> </application> </system.runtime.remoting> </configuration>
COMO: Exibir a Política de Segurança Usando Caspol.exe
exibir a diretiva de segurança (hieraquia de grupo de código) e uma lista de conjuntos de
permissões conhecidos para todos os níveis de diretiva ou para um nível único diretiva.

Para exibir a diretiva de segurança
[caspol -enterprise | -all | -machine | -user] –list
Especificar a opção Nível diretiva antes da –list opção.Se você omitir a opção Nível de diretiva,
Caspol.exe mostra a hierarquia de grupo de código e conhecido permissão nomeada Define a
diretiva padrão no nível Para administradores de computadores, o nível padrão é o nível de
diretiva da máquina; para outros, ele é o nível de diretiva de usuário.
Ter Grupos de códigos um número de referência e, opcionalmente, um nome. Você pode usar um
para se referir a grupos de códigos específicos.
Lista Caspol.exe o nome condição de participação e um valor condição de participação (se

houver), seguido do nome de conjunto de permissões associado a esse grupo de códigos. Se o
grupo de códigos mescla as permissões de seus grupos de código filho usando lógica match first-,
Caspol.exe indica isso através da exibição (FirstMatchCodeGroup.) ao lado do grupo de código A
lógica de mesclagem padrão executa uma união das permissões que grupos de códigos filho
conceder. Para obter mais informações, consulte Modelo de diretiva de segurança.
Após a hierarquia de grupo de código é uma lista dos conjuntos nomeados de permissão
conhecido em que nível de diretiva e uma lista de conjuntos confiança total, também conhecidos
como conjuntos de diretiva.
COMO: Adicionar Conjuntos de Permissão usando Caspol.exe
Você pode usar para adicionar permissão define como um grupo de códigos. o Ferramenta
Diretiva de segurança para acesso de código (Caspol.exe) Antes você pode associar uma
permissão nomeada definido com um grupo de códigos, ele deve ser conhecido no nível de
diretiva do grupo de código. Antes que você possa adicionar permissão definida com nível de
diretiva do grupo de código, você deve criá-lo como um arquivo XML.
Para adicionar uma permissão nomeada defina como um nível de diretiva

[caspol -enterprise [permissionSetName | -machine | -user] -addpset xmlFile ]
Especificar a opção Nível diretiva antes da –addpset opção.Se você omitir a opção Nível de
diretiva, Caspol.exe adiciona o conjunto de permissões no nível de diretiva padrão. Para
Forneça um nome conjunto de permissão se o arquivo XML não contiver um na forma de um
valor de atributo nome.
O comando a seguir importa o MyPermissions.xml arquivo conjunto de permissão como a
MyPermissions permissão definida no nível de diretiva da máquina.
caspol -machine –addpset MyPermissions.xml MyPermissions
COMO: Alterar Grupos de Código Usando Caspol.exe
Use a –chggroup opção de para alterar o nome, condição de membro, conjunto de permissões,
sinalizadores, ou a descrição de um grupo de códigos. o Ferramenta Diretiva de segurança para
acesso de código (Caspol.exe)Você pode alterar um, alguns, ou todos os esses atributos de grupo
de código
Para alterar um grupo de códigos

caspol [-enterprise|-machine|-user] –chggroup label|name {[mship] [pset_name] [-exclusive
{on|off}][-levelfinal {on|off}] [-name name] [-description description_text] }
Especificar a opção Nível diretiva antes da –chggroup opção.Se você omitir a opção Nível de
diretiva, Caspol.exe altera o grupo de códigos especificada no nível de diretiva padrão. Para
A sintaxe e significado de mship, pset_name, -exclusive, e -levelfinal são o mesmo usado
para a –addgroup opção.Para obter mais informações sobre esses argumentos e opções,
consulte Como adicionar grupos de códigos usando Caspol.exe:.
O comando a seguir altera a condição de membro para o grupo de códigos rotulado 1.2.1. para
a Internet condição de membro da zona.
caspol –chggroup 1.2.1. –zone Internet
O comando a seguir altera o nome do rotulado 1.2.1.1. para MyApp_CodeGroup o grupo de

códigos.
caspol –chgroup 1.2.1.1. –name MyApp_CodeGroup
O comando a seguir associa permissão Internet definido com o grupo 1.3. de códigos e desliga
o -exclusive Sinalizador.
caspol –chggroup 1.3. Internet –exclusive off
Cuidado
Alterar um grupo de códigos pode ter largura repercussões para segurança. Use esta opção com
cuidado.
COMO: Configurar Canais
O exemplo a seguir, mostra como para criar com um nome que é diferente de " http " e utilizá-la
de um aplicativo do servidor. um HttpChannel
Exemplo
<configuration> <system.runtime.remoting> <application> <service> <wellknown type="Type,Assembly"
mode="Singleton" objectUri="endpoint" /> </service> <channels> <channel ref="OtherChannel"/>
</channel> </application> <channels> <channel id="OtherChannel" type="CompleteTypeInformation
including versiong and strong-name information" /> </channels> </system.runtime.remoting>
</configuration>
Consulte também
COMO: Ativar e Desativar a Segurança Usando Caspol.exe
Você pode usar para Ativar segurança e a. o Ferramenta Diretiva de segurança para acesso de
código (Caspol.exe) Quando a segurança de acesso ao código é desativada, todas as demandas
de acesso ao código êxito. Desativar a segurança de acesso ao código torna o sistema vulnerável
a ataques por código mal-intencionado, como vírus e worms. A desativação de segurança obtém
alguns desempenho extra mas só deve ser feito quando outras medidas de segurança ter sido
seguidas para ajudar a proteger exemplos de segurança do sistema. Exemplos de outras
precauções de segurança incluem desconectando de redes públicas, fisicamente proteger
computadores, e assim por diante.

Cuidado
Desativando a segurança de acesso ao código é uma operação todo computador-que termina

verificações de segurança para todo código gerenciado e para todos os usuários no computador.
Embora a –list opção mostra que Segurança está desativada, nada mais claramente indica para
outros usuários que segurança tenha sido desativada.Se versões lado a lado-do Common
Language Runtime são instaladas, esse comando desativa a segurança para cada versão do
tempo de execução instalado no computador.
Para desativar a segurança

caspol –security off
Para ativar segurança

caspol –security on
COMO: Remover Permissões de um Conjunto de Permissões
Use a ferramenta .NET Framework Configuration (Mscorcfg.msc) para remover uma permissão de
um conjunto de permissão.
Observação

Para remover uma permissão de uma permissão definido usando Mscorcfg.msc

3. Expanda o nó para o nível de diretiva que deseja remover a permissão de.
5. Clique com o botão direito do mouse no conjunto de permissão você deseja remover a
permissão de e escolha Change Permissions.
6. Selecione uma permissão a partir da Assigned Permissions lista e clique em Remove.
Como: Executar tarefas de política de segurança comuns usando a ferramenta de configuração

do .NET Framework (Mscorcfg.msc)

Do Ferramenta Configuração estrutura .NET (Mscorcfg.msc) você pode usar para configurar a
diretiva de segurança para atender às suas necessidades. A tabela a seguir descreve algumas
das tarefas você pode executar.
Tarefas de diretiva de
segurança Descrição
Novo Criar um novo arquivo de diretiva. Use esta opção para criar e implantar
novos arquivos de nível de diretiva sem afetar a diretiva no computador
atual.
Abrir Abra um nível de diretiva. Use esta opção para abrir arquivos criados
usando a New opção de diretiva.
Redefinir tudo Redefinir todos os níveis de diretiva para o padrão.
Ajustar Segurança Ajuste o nível de segurança para cada zona.
Avaliar Conjunto de Exibir as permissões concedidas a um conjunto ou os grupos de
Módulos (Assembly) códigos que conceder permissões a um conjunto.
Confiar assembly Atribuir um nível de confiança a um conjunto.
Criar um pacote de Criar e implantar a diretiva de segurança em uma rede.
implantação
Para executar essas tarefas com base em segurança

2. No painel esquerdo, clique com o botão direito do mouse no Runtime Security Policy nó.
3. Escolha a tarefa que deseja executar a partir do menu.
Como Criar um Gerenciador de Recursos de Compensação (CRM)
Exemplo do código
Um gerenciador de recursos de compensação (CRM) é um serviço fornecido pelo COM + que

permite que você para incluir objetos não transacional em transações Microsoft Distributed
transações distribuídas (DTC). Embora os CRMs não fornecem os recursos do Gerenciador de
recursos completo, eles fazer fornecem atomicidade transacional (comportamento All-or-Nothing)
e durabilidade através o log de recuperação.
Para criar um gerenciador de recursos Compensating

1. Importar os espaços para nome EnterpriseServices e CompensatingResourceManager.
C#
using System.EnterpriseServices; using
System.EnterpriseServices.CompensatingResourceManager;

2. Ativar o suporte do CRM para o conjunto.
C#
[assembly: ApplicationCrmEnabled]
3. Definir uma classe do operador CRM que deriva da classe ServicedComponent. Por
exemplo, o código a seguir mostra uma classe CRMWorker que deriva diretamente de
ServicedComponent.
C#
[Transaction] public class CRMWorker:ServicedComponent { }
4. Implementar um método público que cria um objeto Clerk e confirma ou anula a transação.
O método deve atualizar o log do CRM usando o objeto Clerk. Por exemplo, o código a
seguir mostra um método CRMMethod que atualiza o log do CRM e confirma ou anula a
transação.
C#
public void CRMMethod(string fileName, bool bCommit) { // Create clerk object. Clerk clerk = new
Clerk(typeof(CRMCompensator), "CRMCompensator", CompensatorOptions.AllPhases);
clerk.WriteLogRecord(fileName); clerk.ForceLog(); if (bCommit) ContextUtil.SetComplete(); else
ContextUtil.SetAbort(); }
5. Definir uma classe que deriva da classe compensação.

C#
[JustInTimeActivation] public class CRMCompensator:Compensator { }
Observação
Você deve aplicar o JustInTimeActivation atributo para o compensador; caso contrário anular é
chamado duas vezes.
1. Substituir e EndAbort membros da classe Compensator., EndPrepare,

CommitRecordBeginCommit, BeginAbortEndCommit, AbortRecord a BeginPrepare,
PrepareRecord
2. Criar um aplicativo do cliente para testar os componentes do operador CRM e
Compensator.
1. Importar os nomes necessários, como o System.EnterpriseServices e espaço para
nome que implementa as classes do operador CRM e Compensator.
C#
using System; using System.IO; using System.EnterpriseServices; using CrmServer; using
System.Runtime.InteropServices;
2. Definir uma classe e implementar o método principal para criar uma instância da
classe do operador CRM, e chamar esse método que cria o objeto Clerk CRM.
Por exemplo, o código a seguir cria um objeto do tipo CRMWorker e chama o
método CRMMethod para criar o objeto Clerk CRM.
C#
class CRM { public static int Main() { string logfilename = "crm.log";
Console.WriteLine("Creating a managed CRM worker object..."); CRMWorker crmworker
= new CRMWorker(); Console.WriteLine("Demonstrating a worker commit...");
crmworker.CRMMethod(logfilename, true); Console.WriteLine("Demonstrating a worker

abort..."); crmworker.CRMMethod(logfilename, false); Console.WriteLine("DONE!");
return 0; } }
3. Gerar uma chave forte e compilar o exemplo a seguir.

C#
sn –k crm.key csc /t:library /r:System.EnterpriseServices.dll crm.cs csc /r:crm.dll crmclient.cs
Exemplo
C#
using System; using System.IO; using System.Reflection; using System.EnterpriseServices; using
System.EnterpriseServices.CompensatingResourceManager; [assembly:
ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationCrmEnabled] [assembly:
AssemblyKeyFile("crm.key")] namespace CrmServer { [Transaction] // Create a Worker class. public class
CRMWorker:ServicedComponent { public void CRMMethod(string fileName, bool bCommit) { // Create
clerk object. Clerk clerk = new Clerk(typeof(CRMCompensator), "CRMCompensator",
CompensatorOptions.AllPhases); clerk.WriteLogRecord(fileName); clerk.ForceLog(); if (bCommit)
ContextUtil.SetComplete(); else ContextUtil.SetAbort(); } } // Create class derived from Compensator class.
[JustInTimeActivation] public class CRMCompensator:Compensator { bool bBeginPrepareCalled = false;
bool bPrepareRecordCalled = false; bool bBeginCommitCalled = false; bool bCommitRecordCalled = false;
bool bBeginAbortCalled = false; bool bAbortRecordCalled = false; String _fileName; public override void
BeginPrepare() { bBeginPrepareCalled = true; } public override bool PrepareRecord(LogRecord rec) { Object
o = rec.Record; _fileName = o.ToString(); bPrepareRecordCalled = true; return false; } public override bool
EndPrepare() { if (!bBeginPrepareCalled) {return false;} if (!bPrepareRecordCalled) {return false;} if
(_fileName==null) {return false;} // This is a Prepare Phase success. return true; } public override void
BeginCommit(bool fRecovery) { bBeginCommitCalled = true; } public override bool
CommitRecord(LogRecord rec) { bCommitRecordCalled = true; return true; } public override void
EndCommit() { if (!bBeginCommitCalled) {return;} if (!bCommitRecordCalled) {return;} if
(_fileName==null) {return;} // This is a Commit Phase success. } public override void BeginAbort(bool
fRecovery) { bBeginAbortCalled = true; } public override bool AbortRecord(LogRecord rec) {
bAbortRecordCalled = true; Object o = rec.Record; _fileName = o.ToString(); return true; } public override
void EndAbort() { if (!bBeginAbortCalled) {return;} if (!bAbortRecordCalled) {return;} if (_fileName==null)
{return;} // This is an Abort Phase success. } } }
O procedimento a seguir descreve como criar um novo componente de serviço.
Para criar um componente de serviço

1. Definir uma classe que deriva direta ou indiretamente a partir da ServicedComponent
classe. Por exemplo, o código a seguir garante que a Calculator classe é hospedada por
um aplicativo do COM +.
C#
using System.EnterpriseServices; public class Calculator : ServicedComponent { public int Add (int
x, int y) { return(x+y); } }
2. Aplicar atributos para indicar como cada conjunto, classe, ou método deve interagir com
funcionalidade com +.

Observação
No.NET Framework versão 1.1, a configuração de segurança do COM + é habilitada por padrão
se o ApplicationAccessControlAttribute atributo não está presente no conjunto. Isso é uma
alteração no comportamento de .NET Framework versão 1.0.
C#
[assembly: ApplicationName("Calculator")] [assembly:
System.Reflection.AssemblyKeyFile("Calculator.snk")] [MustRunInClientContext] public class
Calculator : ServicedComponent { // Member definitions. }
3. Gerar uma chave forte e compilar o exemplo a seguir:

C#
sn –k Calculator.snk csc /t:library /r:System.EnterpriseServices.dll Calculator.cs
4. Implantar o aplicativo de componentes atendidos por registrar seu conjunto dinamicamente

ou manualmente.
5. Após um componente de serviço estiver registrado, os clientes podem criar instâncias do
componente como eles criar instâncias de qualquer outro componente. Para obter um
exemplo completo, consulte Exemplo de serviço do componente.
Observação
Em plataformas Windows 2000, com + sempre carrega a versão mais recente do Common
Language Runtime do para o componente você está criando. Isso significa que em um
computador com o .NET Framework versão 1.0 e .NET Framework versão 1.1 instalado,.NET
Framework versão 1.1 é carregado sempre. Como uma solução, você pode criar um arquivo
Dllhost.exe.Configuration COM + que permite que você para “ bloquear ” todos os aplicativos para
uma versão específica do .NET Framework. No Windows xp e plataformas Windows Server
2003, a configuração diretório raiz de aplicativo pode ser usada para apontar com + para uma
pasta apropriada para seu arquivo de configuração.
Exemplo
C#
using System.EnterpriseServices; [assembly: ApplicationName("Calculator")] [assembly:
System.Reflection.AssemblyKeyFile("Calculator.snk")] [MustRunInClientContext] public class Calculator :
ServicedComponent { public int Add (int x, int y) { return(x+y); } }
O exemplo a seguir mostra como aplicar o DescriptionAttribute atributo para definir a descrição de
um conjunto.
Exemplo
C#
using System.EnterpriseServices; [ assembly: Description("BankComponent assembly")] public class
Account : ServicedComponent { static void Main() {} }

Este exemplo requer:
• Referências a espaços para nome do sistema e System.EnterpriseServices.
Este exemplo mostra como usar o estático SetComplete e SetAbort métodos da classe
System.EnterpriseServices.ContextUtil. Para obter mais informações sobre esses métodos,
consulte Votação em uma transação automáticas.
Exemplo
C#
//Try to do something crucial to the transaction in progress. if( !DoSomeWork() ) { ContextUtil.SetAbort();
//Something goes wrong. } else { ContextUtil.SetComplete(); //All goes well. }
Este exemplo mostra como aplicar o atributo ApplicationID a um conjunto.
Exemplo
C#
using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] [ assembly:
ApplicationID("4fb2d46f-efc8-4643-bcd0-6e5bfa6a174c")] public class Account : ServicedComponent {
static void Main() {} }
• Referências a espaços para nome do sistema e System.EnterpriseServices
Para uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, com +

Objeto pool pode usar para evitar a sobrecarga de instanciar objetos de zero. Em vez disso
objetos obter recebidos de um pool quando ativado. Para obter mais informações, consulte Objeto
pool.
Para criar um objeto agrupado e definir seu tamanho e tempo limite limita
1. Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, e
aplique o ObjectPoolingAttribute atributo à classe. Por exemplo, o código a seguir define
uma classe denominada TestObjectPooling e define e CreationTimeout propriedades para a
classe. o MinPoolSize, MaxPoolSize
C#

[ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public
class TestObjectPooling : ServicedComponent { }
2. Substituir o Activate, Deactivate., e CanBePooled métodos de classe

System.EnterpriseServices.ServicedComponent
3. Teste o objeto em pool, em um aplicativo do cliente:
1. Criar uma instância da classe do objeto agrupada e chamar os métodos no objeto
em pool. Por exemplo, o código a seguir cria uma instância da classe
TestObjectPooling e chama um Perform método.
C#
public class App { public static int Main(string[] args) { TestObjectPooling order = new
TestObjectPooling(); order.Perform();
2. Chame o método DisposeObject para retornar o objeto para o pool.

C#
ServicedComponent.DisposeObject (order);
Exemplo
C#
[ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public class
TestObjectPooling : ServicedComponent { public void Perform () { // Method contents go here. } protected
override void Activate() { // Called when removed from the pool. } protected override void Deactivate() { //
Called before deactivating or placing back in pool. } protected override bool CanBePooled() { // Called after
Deactivate. Indicate your vote here. return true; } }
O procedimento a seguir descreve como criar um método de serviço da Web que usa transações
automáticas. Se ocorrer uma exceção enquanto um método de serviço da Web está participando
em uma transação, ASP.NET anula automaticamente a transação. Da mesma forma, se nenhuma
exceção ocorrer, a transação é confirmada automaticamente.
Para criar um serviço da Web que usa transações automáticas

1. Importar os espaços para nome System.WebServices e System.EnterpriseServices.
Outros espaços para nomes, tais como System.Data e System.Data.SqlClient, podem ser
importado conforme necessário.
C#
<%@ WebService Language="C#" Class="Orders" %> <%@ assembly
name="System.EnterpriseServices" %> using System.Web.Services; using System.EnterpriseServices;
2. Definir uma classe que deriva da classe WebService. Por exemplo, o código a seguir
define uma classe denominado Pedidos que deriva da classe WebService.
C#
public class Orders : WebService { }
3. Para cada método Web que deve participar automaticamente de uma transação, aplicar o
WebMethodAttribute atributo, e definir a opção da transação. Por exemplo, no código a
seguir o atributo WebMethod é aplicado para o DeleteAuthor método, e a TransactionOption
propriedade é definida como TransactionOption.RequiresNew.

C#
[ WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string
lastName) { // Perform the required database task. }
Exemplo
C#
<%@ WebService Language="C#" Class="Orders" %> <%@ assembly name="System.EnterpriseServices"
%> using System; using System.Data; using System.Data.SqlClient; using System.Web.Services; using
System.Web.Util; using System.EnterpriseServices; public class Orders : WebService { [
WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string
lastName) { String deleteCmd = "DELETE FROM authors2 where au_lname='" + lastName + "'" ;
SqlConnection sqlConn = new SqlConnection("Integrated Security=SSPI;database=pubs;server=myserver");
SqlCommand myCommand = new SqlCommand(deleteCmd,sqlConn); // If a Web service method is
participating in a transaction and an // exception occurs, ASP.NET automatically aborts the transaction. //
Likewise, if no exception occurs, then the transaction is // automatically committed.
myCommand.Connection.Open(); return myCommand.ExecuteNonQuery(); } }
Este exemplo mostra como definir a propriedade SoapVRoot " MyVRoot ".
Exemplo
C#
[ApplicationActivation(ActivationOption.Library, SoapVRoot="MyVRoot")]
• Referências para o sistema e System.EnterpriseServices Namespace espaços para nome
Este exemplo mostra como definir o limite de transação como 10 segundos.
Exemplo
C#
[Transaction(TransactionOption.Required, Isolation=TransactionIsolationLevel.Serializable, Timeout=10)]
• Referências ao espaço para nome System.EnterpriseServices.
Este exemplo mostra como para fornecer o nome do aplicativo, usando o conjunto - atributo
ApplicationName.

Exemplo
C#
using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] public class Account :
ServicedComponent { static void Main() {} }
• Referências para o sistema e System.EnterpriseServices espaços para nome.
COM+
Exemplo do código
O procedimento e exemplo a seguir mostram como uma classe derivada da classe

ServicedComponent pode usar o recurso BYOT do COM + para acessar um coordenador
transações distribuídas (DTC). Para obter mais informações como utilizar o recurso BYOT de
dentro do espaço de nome System.EnterpriseServices, consulte BYOT (colocar seu próprio
Transaction).
Para criar um objeto que usa a transação de outro objeto.

1. Definir uma classe que deriva da classe ServicedComponent, e expõe uma propriedade
pública que retorna o objeto transações DTC com + atual. Por exemplo, no código a seguir
a classe Base, herda a classe ServicedComponent e tem uma propriedade pública que
retorna o objeto ContextUtil.Transaction para a transação COM + DTC atual no qual o
objeto é instanciado.
C#
using System.EnterpriseServices; public class Base : ServicedComponent { public Object Transaction
{ get { return ContextUtil.Transaction; } } }
2. Crie duas classes que derivar da classe definida na etapa 1 e defina o atributo de
transações para ambas as classes. Por exemplo, o código a seguir declara duas classes
CTransaction1 e CTransaction2 derivar de classe Base, e têm seu conjunto de atributos de
transações.
C#
[Transaction] public class CTransaction1 : Base { // Insert your transaction logic here. }
[Transaction] public class CTransaction2 : Base { // Insert your transaction logic here. }
3. Criar um aplicativo do cliente que usa as classes criadas na etapa 2 para testar o recurso
BYOT.
1. Criar uma instância de uma das classes definidas na etapa 2. Por exemplo, o
código a seguir cria uma instância da classe CTransaction1.
C#
class BYOTDemonstration { static void Main() { CTransaction1 tx1 = new CTransaction1(); } }
2. Recuperar a transação COM + DTC atual do objeto criado no 3.a etapa. Por
exemplo, o código a seguir recupera o objeto transações a partir da propriedade
Transaction pública da classe CTransaction1.
C#

Object tx = tx1.Transaction;
3. Criar uma instância da classe segundo definiu na etapa 2, usando o objeto

Transaction recuperado em 3.b etapa. Por exemplo, o código a seguir cria uma
instância da classe CTransaction2 usando o Transaction recuperada em 3.b etapa.
C#
CTransaction2 tx2 = (CTransaction2)BYOT.CreateWithTransaction(tx,
typeof(CTransaction2));

C#
sn –k BYOTDemo.snk
Exemplo
C#
using System; using System.Reflection; using System.EnterpriseServices; [assembly:
AssemblyKeyFileAttribute("byotdemo.snk")] public class Base : ServicedComponent { public Object
Transaction { get { return ContextUtil.Transaction; } } } [Transaction] public class CTransaction1 : Base { //
Insert your transaction logic here. } [Transaction] public class CTransaction2 : Base { // Insert your
transaction logic here. } class BYOTDemonstration { static void Main() { /* Create a transactional object, and
then get its transaction. */ CTransaction1 tx1 = new CTransaction1(); Console.WriteLine("Created
transaction1."); Object tx = tx1.Transaction; Console.WriteLine("Got the transaction of transaction1.");
CTransaction2 tx2 = (CTransaction2)BYOT.CreateWithTransaction(tx, typeof(CTransaction2));
Console.WriteLine("Created transaction2 using the transaction of transaction1."); } }
Este exemplo mostra como usar o atributo PrivateComponentAttribute em uma classe.
Exemplo
C#
[PrivateComponent] public class CPrivate : ServicedComponent
• Referências ao espaço para nome System.ServiceProcess.
Este exemplo mostra como definir o tipo de ativação para " Servidor ".
Exemplo
C#
using System.EnterpriseServices; [ assembly: ApplicationActivation(ActivationOption.Server)] public class

O exemplo a seguir mostra como habilitar a sincronização em instâncias da classe TestSync .
Exemplo
C#
[Synchronization] public class TestSync : ServicedComponent
O procedimento a seguir descreve como preparar uma classe para participar de uma transação
automática.
Para preparar uma classe para participar de uma transação automática

1. Do TransactionAttribute derivar sua classe de classe ServicedComponent, e aplicar à sua
classe. O exemplo a seguir mostra como aplicar o atributo TransactionAttribute a uma
classe derivada da classe ServicedComponent.
C#
[Transaction(TransactionOption.Required)] public class Account : ServicedComponent { //. . . }
2. Aplicar o atributo AutoCompletar para cada método para o qual o método

ContextUtil.SetComplete deve ser chamado automaticamente na ausência de exceções. O
exemplo a seguir mostra como aplicar o atributo AutoCompletar.
C#
[AutoComplete] public void Debit(int amount) { // Do some database work. Any exception thrown
here aborts the // transaction; otherwise, transaction commits. }
3. Assinar o assembly com um strong name. Do AssemblyKeyFileAttribute para assinar o

conjunto usando atributos, crie um par de chaves usando Sn.exe, e adicione ou
AssemblyKeyNameAttribute Conjunto atributo e especifique o nome do arquivo que contém
o par de chaves para assinar o conjunto com um nome de alta segurança.
C#
[assembly: AssemblyKeyFileAttribute("TestApp.snk")]
4. Registrar o conjunto que contém a classe com o catálogo COM +.

5. Se as instâncias de chamada de sua classe do cliente é gerenciado pelo Common
Language Runtime, o registro será executado para você. No entanto, se você prevê que um
chamador não gerenciado pode criar e chamar instâncias da sua classe, usar a ferramenta
de instalação dos Serviços .NET (Regsvcs.exe) para executar o Registro manualmente.
Exemplo
C#

// ----------------------------------------------------------------- // TestApp.cs // Generate a Strong name: // sn -k
TestApp.snk // Compile the code: // csc /target:exe /r:System.EnterpriseServices.dll TestApp.cs // Run
TestApp: // start TestApp.exe // ----------------------------------------------------------------- using System; using
System.Runtime.CompilerServices; using System.EnterpriseServices; using System.Reflection;
//Registration details. //COM+ application name as it appears in the COM+ catalog. [assembly:
ApplicationName("TestApp")] //Strong name for assembly. [assembly:
AssemblyKeyFileAttribute("TestApp.snk")] [Transaction(TransactionOption.Required)] public class Account
: ServicedComponent { //Provides SetComplete behavior in the absence of exceptions. [AutoComplete]
public void Debit(int amount) { // Do some database work. Any exception thrown here aborts the //
transaction; otherwise, transaction commits. } } public class client { public static int Main() { Account
accountX = new Account(); accountX.Debit(100); return 0; } }
Este exemplo mostra como habilitar ativação JIT e desativação e de uma classe.
Exemplo
C#
[JustInTimeActivation] public class TestJITObjectPooling : ServicedComponent
Este exemplo mostra a colocação de atributo AutoCompletar em uma classe reconhecem

transações. Para obter mais informações sobre o AutoCompletar atributo, consulte Votação em
uma transação automáticas.
Exemplo
C#
[Transaction(TransactionOption.Supported)] public class Account : ServicedComponent { [AutoComplete]
transaction; otherwise, transaction commits. } }
Como Implementar um Componente Enfileirado que Exibe uma Mensagem de Forma

Assíncrona
Exemplo do código
O serviço QC COM + fornece uma maneira de uma classe componente para ser chamado
assincronamente USAR O enfileiramento de mensagens Microsoft. Para obter mais informações

sobre componentes enfileirados derivados da System.EnterpriseServices.ServicedComponent
classe, consulte O QC (queueds Components).
Para implementar um componente enfileirado que exibe uma mensagem de forma assíncrona
1. Importar espaço para nome System.EnterpriseServices.
C#
using System.EnterpriseServices;
2. Defina o ApplicationActivation atributo como ActivationOption.Server; ativar o ouvinte da

fila aplicativo enfileiramento e definindo o ApplicationQueuing atributo assembly, como
mostrado no código de exemplo a seguir:
C#
[assembly: ApplicationActivation(ActivationOption.Server)] [assembly:
ApplicationQueuing(Enabled=true, QueueListenerEnabled=true)]
3. Definir uma interface na fila, e aplique o InterfaceQueuing atributo à interface. Por exemplo
o código a seguir mostra o atributo InterfaceQueuing aplicada para a IQComponent interface
que tenha um único método DisplayMessage.
C#
[InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); }
4. Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent e

implementa a interface na fila. Por exemplo, o código de exemplo a seguir declara uma
classe denominada QComponent que deriva da classe
System.EnterpriseServices.ServicedComponent e implementa a IQComponent interface.
C#
public class QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string
msg) { MessageBox.Show(msg, "Processing message"); } }
5. Criar um aplicativo cliente e testar o componente enfileirado.

1. Criar uma variável cujo tipo de dados é a interface na fila do qual a classe
componente enfileirado é derivada.
C#
IQComponent iQc = null;
2. Vincular ao moniker correspondente à interface na fila, e chamamos o método no

componente enfileirado para exibir a mensagem de forma assíncrona. Por exemplo o
código a seguir vincula ao componente enfileirado que corresponda à interface
IQComponent, e chama o método DisplayMessage para exibir uma mensagem de forma
assíncrona.
C#
IQComponent iQc = null; try { iQc = (IQComponent)
Marshal.BindToMoniker("queue:/new:QCDemo.QComponent"); } catch {
MessageBox.Show("Cannot create Queued Component"); } iQc.DisplayMessage
(messageToSend.Text); Marshal.ReleaseComObject(iQc);
Exemplo
C#
using System.Reflection; using System.EnterpriseServices; [assembly: ApplicationName("QCDemoSvr")]
[assembly: ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationQueuing(Enabled=true,

QueueListenerEnabled=true)] [assembly: AssemblyKeyFile("QCDemoSvr.snk")] namespace QCDemo {
[InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); } public class
QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string msg) {
MessageBox.Show(msg, "Processing message"); } } }
Exemplo do código
O procedimento e exemplo a seguir mostram como para implementar uma classe de evento e
coletor de eventos que implementam uma interface de eventos comuns, mais um editor para
acionar um evento. Para obter mais informações sobre como usar o modelo flexível coupled
Eventos COM +, consulte Eventos flexível Coupled.
Para implementar flexível aliada eventos

1. Definir uma interface de eventos. Por exemplo, o código a seguir define uma interface de
evento denominada IlceMsg que tenha um método chamado EventMethod.
C#
public interface ILceMsg { void EventMethod(string message); }
2. Definir uma classe de evento que deriva da classe

System.EnterpriseServices.ServicedComponent e implementa a interface de evento definiu
na etapa 1. Por exemplo, o código a seguir define uma classe de evento chamado LceClass.
C#
[EventClass] public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string
message){} }
3. Definir uma classe mesmo do coletor que deriva da classe

na etapa 1. Por exemplo, o código a seguir define uma classe do coletor de evento
chamado LceSink.
C#
public class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) {
MessageBox.Show(message, "Event sink"); } }
4. Criar um editor de eventos para disparar o LCE.

C#
protected void Fire_Click (object sender, System.EventArgs e) { ILceMsg evt = (ILceMsg) new
LceClass(); evt.EventMethod("Hello events"); }
Exemplo
C#
System.Runtime.InteropServices; [assembly: ApplicationName("EventDemo")] [assembly:
ApplicationActivation(ActivationOption.Library)] [assembly: AssemblyKeyFile("EventDemoSvr.snk")]
namespace EventDemo { public interface ILceMsg { void EventMethod(string message); } [EventClass]
public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string message){} } public
class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) {
MessageBox.Show(message, "Event sink"); } } }

C#
//Publisher protected void Fire_Click (object sender, System.EventArgs e) { ILceMsg evt = (ILceMsg) new
O procedimento e exemplo a seguir descrevem como configurar construção de objeto e definir a

seqüência de inicialização padrão da classe TestObjectConstruct para a seqüência "Initial
Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes". Essa seqüência é
usada para conectar a um banco de dados SQL Server. O tópico Construção de objeto,. explica
mais o uso do COM + construção de objeto a partir da
System.EnterpriseServices.ServicedComponent classe
Para configurar construção de objeto e definir a seqüência de inicialização padrão para uma
classe
1. Definir uma classe que deriva direta ou indiretamente a partir da
System.EnterpriseServices.ServicedComponent classe. Por exemplo, o código a seguir
mostra uma classe TestObjectConstruct que deriva diretamente da classe
System.EnterpriseServices.ServicedComponent.
C#
using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; …
public class TestObjectConstruct : ServicedComponent { … }
2. Aplicar o ConstructionEnabled atributo para a classe e definir propriedade do atributo

Default. Por exemplo, o código a seguir se aplica o ConstructionEnabled atributo da
TestObjectConstruct classe e define a Padrão propriedade como a seqüência de conexão
SQL Server.
C#
[ConstructionEnabled(Default="Initial Catalog=Northwind;Data
Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class TestObjectConstruct :
ServicedComponent { … }
3. Substituir o método construir.

Visual Basic
<ConstructionEnabled([Default] := "Initial Catalog=Northwind;Data

Source=.\\SQLServerInstance;Trusted_Connection=yes")> _ Public Class TestObjectConstruct
Inherits ServicedComponent Private m_connectStr As String Private conn as SqlConnection
Protected Overrides Sub Construct(constructString As String) ' Called after constructor.
m_connectStr = constructString End Sub Public Sub ConnectToDatabase() conn = New
SqlConnection(m_connectStr) End Sub End Class
[C#] [ConstructionEnabled(Default="Initial Catalog=Northwind;Data
ServicedComponent { private string connectStr; SqlConnection conn; public TestObjectConstruct() {
… } protected override void Construct(string constructString) { // Called after constructor. connectStr
= constructString; } public void ConnectToDatabase() { conn = new SqlConnection(connectStr);
conn.Open(); } }
4. No aplicativo do cliente, criar uma instância da classe do componente sem especificar uma
seqüência de construção, para que o padrão é usado. Por exemplo, o código a seguir cria
uma instância da classe TestObjectConstruct, e a seqüência de construção padrão será
"Initial Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes".
C#
public class App { public static void Main() { TestObjectConstruct order = new TestObjectConstruct();
order. ConnectToDatabase(); } }
Depois de instalar o aplicativo Serviços componente, você pode especificar seqüências de

construção por meio da ferramenta administrativa Serviços de componente. Para inserir uma
seqüência de construção de objeto para um componente, execute as seguintes etapas:
1. Abra a ferramenta administrativa Serviços de componente.

2. Clique com botão direito na ferramenta administrativa Serviços de componente, mouse no
componente que você deseja configurar, e, em seguida, clique em Properties.
3. Se você não tenha definido o atributo ConstructionEnabled para True, na caixa Properties
de diálogo, na guia Activation, marque a Enable object construction caixa de seleção
para ativar o uso da seqüência de caracteres de construção do objeto.
4. Se você desejar alterar a seqüência de construção do padrão especificado com o atributo
ConstructionEnabled, na caixa Constructor string, insira a seqüência de construção.
Exemplo
C#
using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; [assembly :
ApplicationName("OCDemo")] namespace OCDemo { [ConstructionEnabled(Default="Initial
Catalog=Northwind; Data Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class
TestObjectConstruct : ServicedComponent { private string connectStr; SqlConnection conn; public
TestObjectConstruct() { … } protected override void Construct(string constructString) { // Called after
constructor. connectStr = constructString; } public void ConnectToDatabase() { conn = new
SqlConnection(connectStr); conn.Open(); } } }
O System.Reflection espaço para nome contém vários métodos para obter informações de um
conjunto de módulos (assembly). Esta seção demonstra um dos métodos. Para obter informações
adicionais, consulte Visão geral de reflexão.
O exemplo a seguir obtém informações Tipo e membro de um conjunto.
Exemplo
C#
using System; using System.Reflection; class Asminfo1 { public static void Main(string[] args) {
Console.WriteLine ("\nReflection.MemberInfo"); //Get the Type and MemberInfo. //Insert the fully
qualified class name inside the quotation marks in the following statement. Type MyType
=Type.GetType("System.IO.BinaryReader"); MemberInfo[] Mymemberinfoarray =
MyType.GetMembers(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Insta
nce|BindingFlags.DeclaredOnly); //Get and display the DeclaringType method. Console.Write("\nThere are
{0} documentable members in ", Mymemberinfoarray.Length); Console.Write("{0}.", MyType.FullName);
foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) { Console.Write("\n" +
Mymemberinfo.Name); } } }

Um conjunto de Arquivo Único, que é o tipo mais simples do conjunto, contém informações de tipo
e implementação,, bem como o Manifesto do conjunto. Você pode usar Compiladores de linha de
comando ou Visual Studio 2005 Para criar um conjunto de Arquivo Único. Por padrão, o
compilador cria um arquivo de montagem com uma extensão.exe.
Observação
Para Visual Studio 2005 C# e Visual Basic pode ser usada somente para criar conjuntos de
Arquivo Único. Se você deseja criar vários arquivos conjuntos, use Compiladores de linha de
comando ou Visual Studio 2005 com as extensões Managed do C++.. ou Visual Studio 2005 Com
o Managed Extensions para C++
Os procedimentos a seguir mostram como criar conjuntos de Arquivo Único usando Compiladores
Para criar um conjunto com uma extensão.exe

• No prompt de comando, digite o seguinte comando:
< compiler command> <module name>
Neste comando, compiler command é o comando do compilador para o idioma usado em seu
módulo de código, e module name é o nome do módulo de código para compilar para o
conjunto.
O exemplo a seguir cria um conjunto chamado myCode.exe de um módulo de código chamado

myCode.
C#
csc myCode.cs
Visual Basic
vbc myCode.vb
Para criar um conjunto com uma extensão.exe e especificar o nome do arquivo de saída

< compiler command> /out:<file name> <module name>
módulo de código, file name é o nome de arquivo de saída, e module name é o nome do
módulo de código para compilar para o conjunto.
O exemplo a seguir cria um conjunto chamado myAssembly.exe de um módulo de código chamado

myCode.
C#
csc /out:myAssembly.exe myCode.cs

Visual Basic
vbc /out:myAssembly.exe myCode.vb
Criando conjuntos da biblioteca
Um conjunto de biblioteca é semelhante a uma biblioteca de classes. Ele contém tipos que serão
referenciados por outros conjuntos, mas ele tem nenhum ponto de entrada para iniciar a
execução.
Para criar um conjunto de biblioteca

< compiler command> /t:library <module name>
conjunto. Você pode usar outras opções do compilador, como a /out: opção.
O exemplo a seguir cria um conjunto de biblioteca chamado myCodeAssembly.dll de um módulo de

código chamado myCode.
C#
csc /out:myCodeLibrary.dll /t:library myCode.cs
Visual Basic
vbc /out:myCodeLibrary.dll /t:library myCode.vb
Como: Criar um domínio de aplicativo
Um host Runtime de idioma comum cria domínios aplicativos automaticamente quando eles são
necessários. No entanto, você pode criar seus próprios domínios aplicativos e carregá-los esses
conjuntos que você deseja gerenciar pessoal. Você também pode criar domínios de aplicativo do
qual você executar código.
Criar um novo domínio do aplicativo usando um dos métodos sobrecarregados CreateDomain na

classe System.AppDomain. Você pode dar o domínio do aplicativo um nome e fazer referência a
ela com esse nome.
O exemplo a seguir cria um novo domínio do aplicativo, atribui o nome MyDomain, e seguida,
imprime o nome de domínio host e domínio de aplicativo filho recém-criado para o console.
Exemplo
C#
using System; using System.Reflection; class AppDomain1 { public static void Main() {
Console.WriteLine("Creating new AppDomain."); AppDomain domain =
AppDomain.CreateDomain("MyDomain"); Console.WriteLine("Host domain: " +
AppDomain.CurrentDomain.FriendlyName); Console.WriteLine("child domain: " + domain.FriendlyName);
}}

Como determinar um conjunto o nome totalmente qualificado:
Há várias maneiras para descobrir o nome totalmente qualificado de um conjunto no cache de

conjunto global:
• Use o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).

• Exibir o diretório do cache de conjunto de módulos global.
• Use o Global ferramenta cache assembly (Gacutil.exe).
Procedimentos
Para exibir os nomes de conjuntos totalmente qualificados no cache de conjunto global usando a
ferramenta .NET Framework Configuration
1. Clique no Start botão, aponte para Administrative Tools, e clique em Microsoft .NET
Framework Configuration
2. Clique em Manage the Assembly Cache e, clique em View List of Assemblies in the
Assembly Cache.
Para obter informações sobre como usar a ferramenta Global Assembly Cache para exibir os
nomes de conjuntos, totalmente qualificados Consulte Como Visualizar o Conteúdo da Cache
Global de Assemblies.
Do Disassembler MSIL (Ildasm.exe) para conjuntos de módulos (assemblies) que não estão no
cache de conjunto global, você pode usar código para exibir as informações para o console ou a
uma variável, ou você pode usar para examinar metadados do conjunto, que contém o nome
totalmente qualificado.
Para obter mais informações sobre como definir atributos do conjunto, como versão, cultura e
nome do conjunto, consulte Definir atributos Assembly. Para obter mais informações sobre dar um
conjunto um nome de alta segurança, consulte Criando e usando assemblies de nome forte.
Exemplo
O exemplo de código a seguir mostra como exibir o nome totalmente qualificado de um conjunto
que contém uma classe especificada para o console.
C#
using System; using System.Reflection; class asmname { public static void Main() { Type t =
typeof(System.Data.DataSet); string s = t.Assembly.FullName.ToString(); Console.WriteLine("The fully
qualified assembly name containing the specified class is {0}.", s); } } Imports System Imports
System.Reflection Imports Microsoft.VisualBasic ' For a class not contained in mscorlib.dll, compile this code
with ' the /r:<dllname> option; for example,compile the code below using: ' vbc asmname.vb
/r:System.Data.dll /r:System.dll /r:System.Xml.dll ' If the class is contained in mscorlib.dll, the
/r:<dllname> compiler option is unnecessary. Class asmname Public Shared Sub Main() Dim t As Type =
GetType(System.Data.DataSet) Console.WriteLine("The fully qualified assembly name containing the
specified class is {0}.", t.Assembly.FullName.ToString()) End Sub 'Main End Class 'asmname

Você pode fornecer o Common Language Runtime com informações de configuração para um
novo domínio do aplicativo usando a AppDomainSetup classe. Ao criar seus próprios domínios de
aplicativo, a propriedade mais importante é ApplicationBase. As outras AppDomainSetup
propriedades são usadas principalmente por hosts de tempo de execução para configurar um
domínio aplicativo específico.
A ApplicationBase propriedade Define o Diretório de raiz do aplicativo. Quando o Runtime

precisa atender uma requisição tipo, ele investiga para o conjunto que contém o tipo no diretório
especificado pela propriedade ApplicationBase.
Observação
Um novo domínio do aplicativo herdará apenas a ApplicationBase propriedade do criador.
O exemplo a seguir cria uma instância da classe AppDomainSetup, usa esta classe para criar um
novo domínio do aplicativo, grava as informações ao console, e depois descarrega o domínio do
aplicativo.
Exemplo
C#
using System; using System.Reflection; class AppDomain4 { public static void Main() { // Create application
domain setup information. AppDomainSetup domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = "f:\\work\\development\\latest"; // Create the application domain.
AppDomain domain = AppDomain.CreateDomain("MyDomain", null, domaininfo); // Write application
domain information to the console. Console.WriteLine("Host domain: " +
Console.WriteLine("Application base is: " + domain.SetupInformation.ApplicationBase); // Unload the
application domain. AppDomain.Unload(domain); } }
Você pode usar para exibir informações linguagem intermediária (MSIL) Microsoft em um arquivo.
o Disassembler MSIL (Ildasm.exe) Se o arquivo sendo examinado for um conjunto, essas
informações podem incluir atributos do conjunto,, bem como referências a outros módulos e
conjuntos. Essas informações podem ser útil para determinar se um arquivo é um conjunto ou
parte de um conjunto, e se o arquivo possui referências a outros módulos ou conjuntos.
Para exibir o conteúdo de um conjunto usando Ildasm.exe

• Type ildasm <assembly name> at the command prompt. Por exemplo, o comando a seguir
desmonta o Hello.exe conjunto.
ildasm Hello.exe
Para exibir informações manifesto do conjunto

• Clique duas vezes no ícone MANIFEST na janela Disassembler MSIL.
Exemplo
O exemplo a seguir inicia com " Um Hello, básico " World programa. Depois compilar o programa,
use Ildasm.exe para desmontar o conjunto Hello.exe e exibir o manifesto do conjunto.

Visual Basic
Imports System Public Module modmain Sub Main() Console.WriteLine ("Hello World using Visual Basic!")
End Sub End Module using System; class MainApp { public static void Main() { Console.WriteLine("Hello
World using C#!"); } } #using <mscorlib.dll> using namespace System; void main() {
Console::WriteLine(L"Hello World using Managed Extensions!"); }
Executando o ildasm.exe Comando no conjunto Hello.exe e duas vezes no ícone MANIFEST na

janela DASM IL produz o seguinte resultado:
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 1:0:2411:0 }

.assembly Hello { // --- The following custom attribute is added automatically; do not uncomment. ------- //
.custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(bool, // bool) = ( 01 00 00
01 00 00 ) .hash algorithm 0x00008004 .ver 0:0:0:0 } .module Hello.exe // MVID: {58AD9DFD-63A6-
462A-8AD5-42CBC95AA147} .subsystem 0x00000003 .file alignment 512 .corflags 0x00000001 // Image
base: 0x03330000
A tabela a seguir descreve cada diretiva no conjunto do manifesto da montagem Hello.exe usado
no exemplo.
Diretiva Descrição
.assembly extern Especifica outro conjunto que contém itens referenciados pelo módulo
<assembly name> atual (, neste exemplo, mscorlib).
.publickeytoken <token> Especifica o símbolo da chave real da montagem referenciada.
.ver <version number> Especifica o número de versão da montagem referenciada.
.assembly <assembly Especifica o nome do conjunto.
name>
.hash algorithm <int32 Especifica o algoritmo hash usado.
value>
.ver <version number> Especifica o número de versão do conjunto.
.module <file name> Especifica o nome dos módulos que compõem o conjunto. Neste
exemplo, o conjunto consiste em apenas um arquivo.
.subsystem <value> Especifica o ambiente do aplicativo necessário para o programa. Neste
exemplo, o valor 3 indica que este executável é executado de um
console.
corflags Atualmente um campo reservado nos metadados.
Um manifesto do conjunto pode conter um número de diretivas diferentes, dependendo do

conteúdo do conjunto. Para obter uma lista abrangente das diretivas no manifesto do conjunto,
consulte a documentação ECMA, especialmente " ii partição metadados: e semântica " definição e
" partição III: CIL instrução Set ". A documentação está disponível online em
http://msdn.microsoft.com/net/ECMA/ e http://www.ECMA-
International.org/publications/Standards/ECMA-335.htm.

O processo na referência tipos ou recursos em um conjunto de nome seguro é normalmente
transparente. Você pode fazer a referência no tempo de compilação (antecipada ligação) ou em
tempo de execução.
Uma referência em tempo de compilação ocorre quando você indicar o compilador para que seu
conjunto faz referência outro conjunto explicitamente. Quando você usar em tempo de compilação
referência, automaticamente o compilador obtém a chave pública do conjunto de nome seguro de
destino e coloca-na referência do conjunto da montagem sendo compilada.
Observação
Um conjunto de nome seguro só pode usar tipos de outros conjuntos de nome seguro. Caso
contrário a segurança do conjunto de nome seguro deve ser comprometida.
Fazer uma referência a um conjunto de nome seguro em tempo de compilação

< compiler command> /reference:<assembly name>
Neste comando, compiler command é o comando do compilador para o idioma que você está
usando e assembly name é o nome do conjunto de nome seguro sendo referenciado. Você
pode usar outras opções do compilador, como a /t:library opção para criar um conjunto de
biblioteca.
O exemplo a seguir cria um conjunto chamado myAssembly.dll que referências um conjunto de

nome seguro chamado myLibAssembly.dll a partir de um módulo de código chamado
myAssembly.cs.
csc /t:library myAssembly.cs /reference:myLibAssembly.dll
Fazer uma referência a um conjunto de nome seguro em tempo de execução

• Quando você fazer uma referência em tempo de execução a um conjunto de nome seguro,
por exemplo, usando você deve usar o nome de exibição do conjunto de nome seguro
referenciado. ou Assembly.GetType métodos, o Assembly.Load A sintaxe de um nome de
exibição é a seguinte:
< assembly name>, <version number>, <culture>, <public key token>
Por exemplo:
myDll, Version=1.1.0.0, Culture=en, PublicKeyToken=03689116d3a4ae33
Do PublicKeyToken, neste exemplo, é a forma hexadecimal do símbolo de chave pública. Se

houver nenhum valor de cultura, use Culture=neutral.
O exemplo de código a seguir mostra como usar essas informações com o Assembly.Load
método.
C#
Assembly.Load("myDll,Version=1.0.0.1,Culture=neutral,PublicKeyToken=9b35aa32c18d4fb1");
Você pode imprimir o formato hexadecimal da chave pública e símbolo de chave pública para um
conjunto específico usando o seguinte Ferramenta nome forte (SN.exe) Comando:

sn -Tp <assembly>
Se você tiver um arquivo chave público, use o seguinte comando em vez disso (observe a
diferença no caso com a opção de linha de comando):: (observe a diferença no caso com a opção
de linha de comando)
sn -tp <assembly>
Como: Descarregar um domínio de aplicativo
Quando você tiver terminado usando um domínio de aplicativo, descarregá-lo usando o

System.AppDomain.Unload método. O Unload método normalmente desliga o domínio do
aplicativo especificado. Durante o processo descarregando, nenhum novo segmento pode
acessar o domínio de aplicativo, e são liberadas estruturas dados específicos de domínio – do
aplicativo todos os.
Conjuntos carregados no domínio de aplicativo são removidas e não estão mais disponíveis. Se
um conjunto no domínio do aplicativo é domínio neutro-, dados para o conjunto permanece na
memória até que o processo inteiro é desligado. Não há nenhum mecanismo para descarregar um
conjunto-domínio neutro diferente desligar o processo inteiro. Há situações em que a solicitação
para descarregar um domínio de aplicativo não funciona e resulta em um
CannotUnloadAppDomainException.. um CannotUnloadAppDomainException
O exemplo a seguir cria um novo domínio denominado MyDomain do aplicativo, imprime algumas
informações ao console, e depois descarrega o domínio do aplicativo. Observe que o código tenta
imprimir o nome amigável do domínio do aplicativo descarregado para o console. Essa ação gera
uma exceção que é tratada pelas instruções try / catch no final do programa.
Exemplo
C#
AppDomain.CreateDomain("MyDomain", null); Console.WriteLine("Host domain: " +
AppDomain.Unload(domain); try { Console.WriteLine(); Console.WriteLine("Host domain: " +
AppDomain.CurrentDomain.FriendlyName); // The following statement creates an exception because the
domain no longer exists. Console.WriteLine("child domain: " + domain.FriendlyName); } catch
(AppDomainUnloadedException e) { Console.WriteLine("The appdomain MyDomain does not exist."); } } }
Do Ferramenta Assembly Cache global (Gacutil.exe) uso para remover um conjunto de cache de
conjunto global.
Para remover um conjunto de cache de conjunto global

gacutil –u <assembly name>
Neste comando, assembly name é o nome da montagem para remover do cache de conjunto
global.
O exemplo a seguir remove um conjunto chamado hello.dll do cache de conjunto global.

gacutil -u hello
O SDK do .NET Framework também fornece uma extensão Shell do Windows chamado que você
pode usar para remover conjuntos de cache de conjunto global. o Visualizador cache do conjunto
(Shfusion.dll),
Existem quatro maneiras para instalar um conjunto no cache de conjunto global:
• Usando o Ferramenta Assembly Cache global (Gacutil.exe).

Você pode usar Gacutil.exe para adicionar conjuntos de nome seguro de cache de conjunto
global e para exibir o conteúdo do cache de montagem global.
Observação
Gacutil.exe serve apenas para fins de desenvolvimento e não deve ser usado para instalar
conjuntos de produção no cache de conjunto global.
• Usando o Microsoft Windows Installer 2.0.

Essa é a maneira recomendada e mais comum para adicionar conjuntos de cache de conjunto
global. O instalador fornece referência Contagem de conjuntos no cache de conjunto global, e
outros benefícios.
• Usando uma extensão do shell do Windows fornecido pelo SDK do .NET Framework
chamado o Visualizador cache do conjunto (Shfusion.dll).
A extensão do shell permite que você a arrastar conjuntos para cache de conjunto global.
• Usando o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).
O Ferramenta Configuração estrutura .NET (Mscorcfg.msc) permite que você se exibir o cache
de conjunto de módulos global e adicionar novos conjuntos de no cache.
Para instalar um conjunto de nome seguro no cache de conjunto global usando a ferramenta
Global Assembly Cache (Gacutil.exe)
gacutil –I <assembly name>
Neste comando, assembly name é o nome da montagem para instalar em cache de conjunto
global.
O exemplo a seguir instala um conjunto com o nome hello.dll de arquivo no cache de conjunto
global.
gacutil -i hello.dll
Esta seção descreve o procedimento utilizado para criar um conjunto de vários arquivos e fornece
um exemplo completo que ilustra cada uma das etapas no procedimento.
Para criar um conjunto de vários arquivos

1. Compilar todos os arquivos que contêm espaços para nome referido por outros módulos
na montagem em módulos de código. A extensão padrão para módulos de código

é.netmodule. Por exemplo, se criar um arquivo chamado Stringer espaço para nome
chamada myStringer que é referenciado no arquivo Código do cliente, Stringer deve ser
compilado em um módulo de código primeiro.
2. Compilar todos os outros módulos, usando as opções do compilador necessário para
indicar os outros módulos que são referenciados no código.
3. Do Vinculador do conjunto (AL.exe) uso para criar o arquivo de saída que contém o
manifesto do conjunto. Esse arquivo contém informações de referência para todos os
módulos ou recursos que fazem parte do conjunto.
Observação
O Visual Studio 2005 IDE de C# e Visual Basic poderá somente usar para criar conjuntos de
Arquivo Único. Se você desejar criar vários arquivos conjuntos, deve usar os compiladores de
linha de comando ou Visual Studio 2005 com Visual C++.. ou Visual Studio 2005 com Visual C++
O exemplo a seguir ilustra a etapa 1 do procedimento acima, por compilação arquivos com
espaços para nome referido por outros arquivos. Este exemplo inicia com alguns código simples
para o Stringer arquivo. Espaço para nome chamado myStringer com uma classe chamado
StringerStringer. A Stringer classe contém um método chamado StringerMethod que grava uma
única linha para o console.
C#
// Assembly building example in the .NET Framework SDK. using System; namespace myStringer { public
class Stringer { public void StringerMethod() { System.Console.WriteLine("This is a line from
StringerMethod."); } } }
Use o seguinte comando para compilar este código:
Visual Basic
vbc /t:module Stringer.vb
C#
csc /t:module Stringer.cs
Especificando o module parâmetro com a /t: opção de compilador indica que o arquivo deve ser
compilado como um módulo em vez de como um conjunto. O compilador produz um módulo
chamado Stringer.netmodule, que pode ser adicionado a um conjunto.
Na Etapa dois do procedimento acima, você deve compilar módulos com referências a outros
módulos. Essa etapa usa a /addmodule opção de compilador. No exemplo a seguir, um módulo
de código chamado Client tem um método ponto Main de entrada que referencia um método no
módulo Stringer.dll criado na etapa 1.
O exemplo a seguir mostra o código para Client.
C#
using System; using myStringer; //The namespace created in Stringer.netmodule. class MainClientApp { //
Static method Main is the entry point method. public static void Main() { Stringer myStringInstance = new
Stringer(); Console.WriteLine("Client code executes"); //myStringComp.Stringer();
myStringInstance.StringerMethod(); } }

Visual Basic
vbc /addmodule:Stringer.netmodule /t:module Client.vb
C#
csc /addmodule:Stringer.netmodule /t:module Client.cs
Especificar a /t:module opção porque este módulo irá ser adicionado a uma montagem em uma
etapa futura. Especificar a /addmodule opção porque o código em Client Referências criado pelo
código em Stringer.netmodule um espaço para nome. O compilador produz um módulo chamado
Client.netmodule que contém uma referência a outro módulo, Stringer.netmodule.
Observação
O C# e Visual Basic compiladores suportam diretamente criação usando as seguintes sintaxes

diferentes dois conjuntos de vários arquivos.
• Dois compilations criar um conjunto-dois arquivos:

Visual Basic
vbc /t:module Stringer.vb vbc Client.vb /addmodule:Stringer.netmodule
C#
csc /t:module Stringer.cs csc Client.cs /addmodule:Stringer.netmodule
• Uma compilação cria um conjunto-dois arquivos:

Visual Basic
vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
C#
csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
Do Vinculador do conjunto (AL.exe) você pode usar para criar um conjunto de uma coleção de
compilado módulos de código.
Para criar um conjunto de vários arquivos usando o vinculador assembly

al <module name> <module name> … /main:<method name> /out:<file name>
/target:<assembly file type>
Os module name argumentos neste comando, especifique o nome de cada módulo para incluir
no conjunto. A /main: opção especifica o nome do método que é ponto de entrada do conjunto.
A /out: opção especifica o nome do arquivo de saída, que contém metadados do conjunto. A
/target: opção especifica que o conjunto é um arquivo executável (.exe) do aplicativo Console,
um arquivo executável (.Win) do Windows, ou um arquivo biblioteca (.lib).
No exemplo a seguir, a Al.exe cria um conjunto que é um aplicativo de console executável

chamado myAssembly.exe. O aplicativo consiste de dois módulos chamados Client.netmodule e
Stringer.netmodule. e o arquivo executável chamado myAssembly.exe, que contém somente

metadados conjunto O ponto de entrada do conjunto é o Main método na classe MainClientApp,
que está localizado em Client.dll.
al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
Do Disassembler MSIL (Ildasm.exe) você pode usar para examinar o conteúdo de um conjunto ou
determinar se um arquivo é um conjunto ou um módulo.
No.NET Framework, existem várias maneiras para carregar um conjunto em um domínio de

aplicativo. Cada forma usa uma classe diferente.
Você pode usar os seguintes métodos sobrecarregados para carregar um conjunto em um

domínio de aplicativo:
• A System.AppDomain classe contém vários métodos sobrecarregados Carga. Esses

métodos principalmente são usados para interoperabilidade com, embora eles podem ser
usados para carregar qualquer conjunto na atual ou um novo domínio do aplicativo com êxito.
Também é possível carregar um conjunto usando os CreateInstance métodos.
• A System.Reflection.Assembly classe contém dois métodos sobrecarregados estáticos,
Carga e LoadFrom. Os dois métodos variar pelo contexto de carga.
O exemplo seguinte carrega um conjunto no domínio de aplicativo atual e executa o conjunto.

Para uma discussão completa sobre como obter informações de um conjunto carregado, consulte
Carregar dinamicamente e Usando tipos.
Observação
Na versão do .NET Framework 2.0 domínios do aplicativo possuem um contexto somente

Reflection-. Conjuntos carregados neste contexto podem ser examinados mas não executado,
permitindo exame de conjuntos que destino outras plataformas. Consulte Como Carregar
Assemblies no Contexto Somente de Reflexão e ReflectionOnlyLoad.
Exemplo
C#
using System; using System.Reflection; public class Asmload0 { public static void Main () { // Use the file
name to load the assembly into the current application domain. Assembly a =
Assembly.LoadFrom("adname.exe"); //Get the type to use. Type myType = a.GetType("adname"); //Get the
method to call. MethodInfo mymethod = myType.GetMethod("adnamemethod"); //Create an instance.
Object obj = Activator.CreateInstance(myType); //Execute the adnamemethod method.
mymethod.Invoke(obj,null); } }
COMO: Assinar uma Assembly com Nome Forte
Há duas maneiras para assinar um conjunto com um nome de alta segurança:
• Do Vinculador do conjunto (AL.exe) Usando fornecido pelo .NET Framework SDK.

• Usando atributos do conjunto para inserir as informações de nome de alta segurança em
seu código. Você pode usar ou AssemblyKeyFileAttribute a AssemblyKeyNameAttribute,
dependendo da onde o arquivo de chave a ser usado está localizado.
Você deve ter um par de chaves de criptografia para assinar um conjunto com um nome de alta
segurança. Para obter mais informações sobre como criar um par de chaves, consulte Como criar
um par de chaves pública / Private:.
Para criar e assinar um conjunto com um nome de alta segurança usando o vinculador assembly
al /out:<assembly name> <module name> /keyfile:<file name>
Neste comando, assembly name é o nome da montagem para entrar com um nome de alta
segurança, module name é o nome do módulo do código usado para criar o conjunto, e file
name é o nome do recipiente ou arquivo que contém o par de chaves.
O exemplo a seguir assina o conjunto MyAssembly.dll com um nome de alta segurança usando o
arquivo sgKey.snk de chave.
al /out:MyAssembly.dll MyModule.netmodule /keyfile:sgKey.snk
Para assinar um conjunto com um nome de alta segurança com atributos
• Entre um módulo de código, adicione o AssemblyKeyFileAttribute ou o

AssemblyKeyNameAttribute, especificando o nome do arquivo ou recipiente que contém o
par de chaves para usar ao assinar o conjunto com um nome de alta segurança.
Do AssemblyKeyFileAttribute exemplo usa o seguinte código com um arquivo de chave

chamado sgKey.snk, localizado na pasta onde o conjunto é compilado. Isso pressupõe que o
conjunto é compilado usando o vbc.exe Compiladores de linha de comando e csc.exe.
C#
[assembly:AssemblyKeyFileAttribute(@"sgKey.snk")]
Observação
Em ambientes de desenvolvimento, como Visual Studio, o conjunto não pode ser compilado no
diretório do projeto. Por exemplo, algumas versões do Visual Studio Compilar projetos C# em um
bin\Debug subdiretório. Nesse caso, o caminho no exemplo de código seria ".. \\ \\sgKey.snk ". No
Visual Studio 2005 arquivo de chave no C# pode ser especificado nas configurações do projeto.
Você também pode atrasar assinar um conjunto durante a compilação. Para obter mais
informações, consulte Atraso assinatura um conjunto.
Ao assinar um conjunto com um nome de alta segurança, a Vinculador do conjunto (AL.exe)

Aparência da chave arquivos relativo para a pasta atual e para o diretório de saída. Ao usar linha
comando compiladores, basta copiar a chave para a pasta atual que contém seus módulos de
código.
Do Ferramenta Assembly Cache global (Gacutil.exe) uso para exibir o conteúdo do cache de
montagem global.

Para exibir uma lista das montagens no cache de conjunto global
l Gacutil –
pode usar para exibir o conteúdo do cache de conjunto global. o Visualizador cache do conjunto
(Shfusion.dll),
Para assinar um conjunto com um nome de alta segurança, você deve ter um par de chaves
pública / particular Criptografia esse par de chaves pública e privada é usado durante a
compilação para criar um conjunto de nome seguro. Você pode criar um par de chaves usando o
Ferramenta nome forte (SN.exe). Par de Chaves arquivos geralmente têm uma extensão.snk.
Para criar um par de chaves

sn –k <file name>
Neste comando, file name é o nome do arquivo de saída que contém o par de chaves.
O exemplo a seguir cria um par de chaves denominado sgKey.snk.
sn -k sgKey.snk
Se você pretende atrasar a assinatura um conjunto e você controlar o par de chaves toda (que é
improvável fora cenários de teste), você pode usar o seguinte comandos para gerar um par de
chaves e então extrair a chave pública em um arquivo separado. Primeiro, crie o par de chaves:
sn -k keypair.snk
• Em seguida, extrair a chave pública do par de chaves e copiá-la para um arquivo

separado:
sn -p keypair.snk public.snk
• Assim que você criar o par de chaves, você deve colocar o arquivo em que ele pode
localizar o nome de alta segurança assinatura ferramentas.

código.
Se você estiver usando um IDE, tais como Visual Studio 2005, para assinar um conjunto com um
nome de alta segurança, é necessário compreender onde o IDE procura o arquivo de chave. Por
exemplo, Visual Basic 2005 procura pelo arquivo de chave no diretório que contém a Solução
Visual Studio, enquanto o compilador C# procura o arquivo de chave no diretório que contém o
binário. Coloque o arquivo de chave no diretório do projeto adequado e defina o atributo de
arquivo da seguinte maneira:
Visual Basic
<Assembly: AssemblyKeyFileAttribute("key.snk")>
C#

[assembly: AssemblyKeyFileAttribute(@"..\..\key.snk")]
Você pode compactar uma biblioteca de tipos como um arquivo separado ou incorporá-lo como
arquivo recurso Win32 dentro de um aplicativo baseado em .NET. O Microsoft Visual Basic 6.0
executado essa tarefa para você automaticamente; no entanto, ao usar Microsoft Visual Basic
2005, você deve incorporar sua biblioteca tipo manualmente.
Para incorporar uma biblioteca de tipos como um recurso do Win32 em um aplicativo baseado em
.NET
1. Compilar o aplicativo gerenciado como um arquivo de biblioteca. Por exemplo, para criar
um conjunto para um aplicativo chamado MyApp, digite o seguinte comando no prompt de
comando:
Visual Basic
vbc /t:library MyApp.vb
C#
csc /t:library MyApp.cs
2. Exportar um arquivo biblioteca tipo do seu conjunto usando o Tipo Exporter da biblioteca
(TlbExp.exe). No prompt de comando, digite o seguinte comando:
tlbexp MyApp.dll /out:mytypelib.tlb
3. Criar um script de recursos que contenha a instrução a seguir:

IDR_TYPELIB1 typelib "mytypelib.tlb"
Para este exemplo, o nome de arquivo script é myresource.rc.

4. Compilar o script usando o Microsoft Windows Resource compiler (Rc.exe). No prompt de
comando, digite o seguinte comando:
rc myresource.rc
Rc.exe produz ao myresource.res arquivo de recurso.

5. Compile o arquivo de origem novamente e especifique o arquivo de recurso. No prompt de
Visual Basic
vbc /t:library MyApp.vb /win32res:myresource.res
C#
csc /t:library MyApp.cs /win32res:myresource.res
A maneira mais simples para produzir conjuntos de interoperabilidade primárias consiste em usar
o Importador de Biblioteca de Tipos (TLBIMP.exe).
Para gerar um conjunto de interoperabilidade primário usando TLBIMP.exe

• No prompt de comando, digite:
tlbimp tlbfile /primary /keyfile:filename /out:assemblyname

Neste comando, tlbfile é o arquivo que contém a biblioteca de tipos COM, filename é o nome
do recipiente ou arquivo que contém o par de chaves e assemblyname é o nome da montagem
para entrar com um nome de alta segurança.
Conjuntos de interoperabilidade primárias podem referenciar apenas outros conjuntos de

interoperabilidade primárias. Se seu conjunto faz referência tipos de uma biblioteca de tipos com
de terceiros, você deverá obter um conjunto interoperacional primário do editor antes você pode
gerar seu conjunto interoperacional primário. Se você for o editor, você deve gerar um conjunto de
interoperabilidade primário para a biblioteca de tipos dependente antes de gerar conjunto de
módulos (assembly referência o) de interoperabilidade primária.
Primário um conjunto interoperacional dependente com um número de versão que seja diferente
da biblioteca de tipos original é não localizável quando instalado no diretório atual. Você deve
registrar Principal conjunto interoperacional do dependente no Registro do Windows ou use a
/reference Opção para ter certeza que localiza TLBIMP.exe a DLL dependente.
Você também poderá dispor várias versões de uma biblioteca de tipos. Para obter instruções,
consulte Como Empacotar Várias Versões de Bibliotecas de Tipos.
Exemplo
O exemplo a seguir importa a biblioteca LibUtil.tlb de tipos COM e assina o conjunto LibUtil.dll
com um nome de alta segurança usando o arquivo CompanyA.snk de chave. Omitindo um nome de
espaço para nome específico, este exemplo produz o espaço para nome LibUtil padrão.
tlbimp LibUtil.tlb /primary /keyfile:CompanyA.snk /out:LibUtil.dll
Para um nome mais descritivo). (usando, o exemplo a seguir substitui o nome de arquivo do
conjunto padrão e nome namespace nomeação diretriz. LibraryName o VendorName
tlbimp LibUtil.tlb /primary /keyfile:CompanyA.snk /namespace:CompanyA.LibUtil

/out:CompanyA.LibUtil.dll
O exemplo a seguir importa MyLib.tlb, quais referências CompanyA.LibUtil.dll, e assina o conjunto

CompanyB.MyLib.dll com um nome de alta segurança usando o arquivo CompanyB.snk de chave.
Espaço para nome, CompanyB.MyLib,. substitui o nome de espaço para nome padrão
tlbimp MyLib.tlb /primary /keyfile:CompanyB.snk /namespace:CompanyB.MyLib

/reference:CompanyA.LibUtil.dll /out:CompanyB.MyLib.dll
Uma abordagem menos usada para produzir uma biblioteca de tipos envolve criar um conjunto de
interoperabilidade primário manualmente no código fonte, usando uma linguagem que é
compatível com o COM comum especificação (cls), como C# idioma. Essa abordagem é útil
quando uma biblioteca de tipos não está disponível.
Para gerar um conjunto interoperacional primário no código fonte

1. Crie um conjunto de interoperabilidade no código fonte. Para obter instruções, consulte
Criando um wrapper manualmente. Observação Se você deve incluir todos os tipos COM
da biblioteca Tipo original quando você cria um conjunto de interoperabilidade primário
manualmente.
2. No nível do conjunto, aplicar os seguintes atributos:

1. ou AssemblyKeyFileAttributeAssemblyKeyNameAttribute, para especificar o nome
do arquivo ou recipiente que contém o par de chaves para usar ao assinar o conjunto
com um nome de alta segurança.
2. GuidAttribute Para especificar o identificador de biblioteca (LIBID) da biblioteca de
tipos de destino.
3. PrimaryInteropAssemblyAttribute Para identificar o conjunto como um conjunto
interoperacional primário.
Observação
3. O exemplo de código a seguir aplica chamado CompanyA.snk com um arquivo de chave e

especifica que este conjunto de módulos (assembly) é um conjunto de interoperabilidade
primário suporte versões de biblioteca tipo 4.2 e 5.2. o AssemblyKeyFileAttribute Como
mostra o exemplo, você pode dispor mais de uma versão de uma biblioteca tipo Aplicando
atributos adicionais conjunto-nível.
C#
[assembly:AssemblyKeyFile(@"..\..\CompanyA.snk")] [assembly:Guid("97d25db0-0363-1cf-abc4-02608
c9e7553"] [assembly:PrimaryInteropAssembly(4, 2)] [assembly:PrimaryInteropAssembly(5, 2)]
O Importador da biblioteca Tipo (TLBIMP.exe) é uma ferramenta de linha de comando que

converte o coclasses e interfaces contidos em uma biblioteca de tipos com aos metadados. Essa
ferramenta cria um conjunto interoperacional e espaço para nome para as informações tipo
automaticamente. Depois os metadados de uma classe estiver disponível, clientes gerenciados
podem criar instâncias do tipo COM e chamar seus métodos, apenas como se fosse uma
instância .NET. TLBIMP.exe converte uma biblioteca inteira tipo aos metadados de uma vez e não
pode gerar informações sobre tipo de um subconjunto dos tipos definidas em uma biblioteca de
tipos.
Para gerar um conjunto de interoperabilidade de uma biblioteca de tipos

• Use o seguinte comando:
TLBIMP < type-library-file>
Adicionando a /out: opção produz um conjunto de interoperabilidade com um nome alterada,
como LOANLib.dll. Alterar o nome Conjunto interoperacional pode ajudar a distingui-lo da DLL
com original e evitar problemas que podem ocorrer tenham nomes duplicados.
Exemplo
O seguinte comando produz o conjunto Loanlib.DLL no espaço para nome Loanlib.
tlbimp Loanlib.dll
O seguinte comando produz um conjunto de interoperabilidade com um nome alterada

(LOANLib.dll).
tlbimp LoanLib.dll /out: LOANLib.dll

Se você estiver familiarizado com o modelo baseado em delegate-evento fornecido pelo .NET
Framework, não Consulte Manipulando e disparando eventos. Para obter detalhes específicos que
se aplicam a este tópico, consulte Disparar um evento na mesma seção.
O.NET Framework fornece um sistema baseado em delegate-evento para conectar-se um

remetente de evento (origem) a um destinatário de evento (PIA). Quando o coletor é um cliente
COM, a origem deve incluir elementos para simular pontos de conexão adicionais. Com essas
modificações, um cliente COM pode registrar sua interface do coletor de eventos no modo
tradicional chamando o IConnectionPoint::Advise método. (Visual Basic oculta detalhes ponto
de conexão, para que não faça precise chamar esses métodos diretamente.)
Para interoperar com um coletor de eventos com

1. Definir a interface do coletor de eventos no código gerenciado. Esta interface pode conter
um subconjunto dos eventos sourced por uma classe gerenciado. Os nomes método da
interface deve ser a mesma os nomes de eventos.
2. Do ComSourceInterfacesAttribute aplicar se conectar a interface do coletor de eventos a
classe gerenciada.
3. Exportar o conjunto que contém a classe para uma biblioteca de tipos. Use API equivalente
ou Tipo Exporter da biblioteca (TlbExp.exe) um para exportar o conjunto.
4. Implementar a interface do coletor de eventos em COM.
5. Para clientes com que coletar eventos, implementar a interface do coletor de eventos
definido pela fonte de eventos na sua biblioteca de tipos. Usar o mecanismo ponto de
conexão para conectar-se a interface do coletor à fonte de eventos.
Exemplo
O exemplo a seguir mostra um servidor gerenciado como a origem de eventos e um cliente COM
como o coletor de eventos. O servidor gerenciado declara ButtonEvents como uma interface do
coletor de eventos e se conecta a interface a Button classe. O cliente não gerenciado cria uma
instância da classe Button e implementa a interface do coletor de eventos.
Visual Basic
' Managed server (event source) Option Explicit Option Strict Imports System Imports
System.Runtime.InteropServices Namespace EventSource Public Delegate Sub ClickDelegate(x As Integer, y
As Integer) Public Delegate Sub ResizeDelegate() Public Delegate Sub PulseDelegate() ' Step 1: Defines an
event sink interface (ButtonEvents) to be ' implemented by the COM sink. <GuidAttribute("1A585C4D-3371-
48dc-AF8A-AFFECC1B0967"), _ InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)> _ Public
Interface ButtonEvents Sub Click(x As Integer, y As Integer) Sub Resize() Sub Pulse() End Interface ' Step 2:
Connects the event sink interface to a class ' by passing the namespace and event sink interface '
("EventSource.ButtonEvents, EventSrc"). <ComSourceInterfaces(GetType(ButtonEvents))> _ Public Class
Button Public Event Click As ClickDelegate Public Event Resize As ResizeDelegate Public Event Pulse As
PulseDelegate Public Sub CauseClickEvent(x As Integer, y As Integer) RaiseEvent Click(x, y) End Sub Public
Sub CauseResizeEvent() RaiseEvent Resize() End Sub Public Sub CausePulse() RaiseEvent Pulse() End Sub
End Class End Namespace using System; using System.Runtime.InteropServices; namespace EventSource {
public delegate void ClickDelegate(int x, int y); public delegate void ResizeDelegate(); public delegate void
PulseDelegate(); // Step 1: Defines an event sink interface (ButtonEvents) to be // implemented by the COM
sink. [GuidAttribute("1A585C4D-3371-48dc-AF8A-AFFECC1B0967") ]

[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)] public interface ButtonEvents { void
Click(int x, int y); void Resize(); void Pulse(); } // Step 2: Connects the event sink interface to a class // by
passing the namespace and event sink interface // ("EventSource.ButtonEvents, EventSrc").
[ComSourceInterfaces(GetType(ButtonEvents))] public class Button { public event ClickDelegate Click;
public event ResizeDelegate Resize; public event PulseDelegate Pulse; public Button() { } public void
CauseClickEvent(int x, int y) { Click(x, y); } public void CauseResizeEvent() { Resize(); } public void
CausePulse() { Pulse(); } } } ' COM client (event sink) ' This Visual Basic 6.0 client creates an instance of the
Button class and ' implements the event sink interface. The WithEvents directive ' registers the sink interface
pointer with the source. Public WithEvents myButton As Button Private Sub Class_Initialize() Dim o As
Object Set o = New Button Set myButton = o End Sub ' Events and methods are matched by name and
signature. Private Sub myButton_Click(ByVal x As Long, ByVal y As Long) MsgBox "Click event" End Sub
Private Sub myButton_Resize() MsgBox "Resize event" End Sub Private Sub myButton_Pulse() End Sub
Há duas maneiras para personalizar um wrapper Callable Runtime (RCW). Se você pode
modificar a fonte interface Definition Language (IDL), você pode aplicar atributos de arquivo (tlb)
de biblioteca Tipo e importar a biblioteca de tipos Como alternativa, você pode aplicar atributos
específicos interop-a tipos importados e gerar um novo conjunto. Suporte para personalizar RCWs
padrão é limitado por esses atributos.
Para modificar a fonte IDL

1. Se aplicam atributos TLB a bibliotecas, tipos, membros, e parâmetros. Use a custom
palavra-chave e um valor de atributo para alterar metadados. Aplicando atributos TLB, você
pode:
o Especifique o nome de um tipo COM importados, em vez de permitir que o Utilitário
de Importação para selecionar o nome de acordo com regras conversão padrão gerenciado.
o Definir um espaço para nome de destino para os tipos em uma biblioteca com
explicitamente.
2. Compilar o código fonte IDL.
3. Gerar um conjunto do arquivo resultante de biblioteca tipo ou de um arquivo de biblioteca
de vínculo dinâmico (DLL) que contém o tipo que pretende implementar.
Para modificar um conjunto importados
1. Importe o arquivo de biblioteca tipo. Do Importador da biblioteca Tipo (TLBIMP.exe) uso
para gerar um conjunto DLL.
2. Criar um arquivo de texto do conjunto importado usando o Disassembler MSIL
(Ildasm.exe).
3. Aplicar Atributos de interoperabilidade ao arquivo de texto.
4. Gerar um novo conjunto do arquivo de texto modificada usando o Assembler MSIL
(Ilasm.exe).
Ativação livre registro-para componentes baseado em .NET é apenas um pouco mais complicado
que ele é para componentes COM. A instalação requer dois manifestos:
• Aplicativos COM devem ter um manifesto de aplicativo estilo Win32-para identificar o

componente gerenciado.

• Componentes baseado em .NET devem ter um manifesto componente para ativação
informações necessárias em tempo de execução.
Este tópico descreve como associar um manifesto de aplicativo a um aplicativo; associar um

manifesto componente a um componente; e incorporar um manifesto componente em um
conjunto.
Para criar um manifesto de aplicativo

1. Usando um editor XML, criar (ou modificar) manifesto de aplicativo pertencentes ao
aplicativo do COM que é interoperar com um ou mais componentes gerenciados.
2. Insira o cabeçalho padrão a seguir no início do arquivo:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <assembly xmlns="urn:schemas-
microsoft-com:asm.v1" manifestVersion="1.0">
Para informações sobre elementos manifesto e seus atributos, procure por " Reference
Manifests Application " na Biblioteca do MSDN.
3. Identificar o proprietário do manifesto. No exemplo a seguir, myComApp Versão 1 possui o
arquivo de manifesto.
microsoft-com:asm.v1" manifestVersion="1.0"> <assemblyIdentity type="win32"
name="myOrganization.myDivision.myComApp" version="1.0.0.0" processorArchitecture="x86" />
4. Identificar conjuntos de módulos (assemblies) dependentes. No exemplo a seguir,

myComApp depende da myManagedComp.
name="myOrganization.myDivision.myComApp" version="1.0.0.0" processorArchitecture="x86"
publicKeyToken="8275b28176rcbbef" /> <dependency> <dependentAssembly> <assemblyIdentity
type="win32" name="myOrganization.myDivision.myManagedComp" version="6.0.0.0"
processorArchitecture="X86" publicKeyToken="8275b28176rcbbef" language="*" />
</dependentAssembly> </dependency> </assembly>
5. Salvar e nomear o arquivo de manifesto. O nome de um manifesto de aplicativo é o nome

do conjunto executável seguido pela extensão.manifest. Por exemplo, o nome arquivo
manifesto do aplicativo para myComApp.exe é myComApp.exe.manifest
Você pode instalar um manifesto de aplicativo no mesmo diretório como o aplicativo COM. Como
alternativa, você pode adicioná-lo como um recurso para arquivo.exe do aplicativo. Para obter
mais informações, procure por " conjuntos lado a lado na Biblioteca do MSDN ".
Para criar um manifesto componente
1. Usando um editor XML, criar um manifesto componente para descrever o conjunto

gerenciado.
3. Identificar o proprietário do arquivo. O <assemblyIdentity> elemento do elemento

<dependentAssembly> no arquivo de manifesto de aplicativo deve corresponder ao nome

no manifesto do componente. No exemplo a seguir, myManagedComp Versão 1.2.3.4 possui
o arquivo de manifesto.
microsoft-com:asm.v1" manifestVersion="1.0"> <assemblyIdentity
name="myOrganization.myDivision.myManagedComp" version="1.2.3.4" />
publicKeyToken="8275b28176rcbbef"
4. Identificar cada classe no conjunto. Use o <clrClass> elemento para identificar

exclusivamente cada classe no conjunto de módulos (assembly) gerenciado. O elemento,
que é um subelemento do elemento <assembly> tem dos atributos descritos na tabela a
seguir.
Atributo Descrição Required

Clsid O identificador que especifica a classe para ser ativado. Sim
description Seqüência que informe ao usuário sobre o componente. Uma Não
seqüência vazia é o padrão.
name Uma seqüência de caracteres que representa a classe gerenciada. Sim
ProgID O identificador a ser usado para ativação vinculados as. Não
threadingModel O modelo de segmentação com. é "Both" o valor padrão. Não
runtimeVersion Este atributo é ignorado. Se o Runtime não está carregado, a Não
versão mais recente será carregada antes da classe é ativado.
Caso contrário, a versão atualmente carregado é usada.
tlbid O identificador da biblioteca de tipos que contém informações sobre Não
a classe tipo.
5. Todas as marcas de atributo diferenciam maiúsculas de minúsculas. Você pode obter

CLSIDs, ProgIDs, segmentação modelos, e a versão de tempo de execução, exibindo a
biblioteca de tipos exportada para o conjunto com o ObjectViewer OLE / com (Oleview.exe).
6. O manifesto componente a seguir identifica uma classe única com dois métodos.
7. <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <assembly xmlns="urn:schemas-
publicKeyToken="8275b28176rcbbef" <clrClass clsid="{65722BE6-3449-4628-ABD3-
74B6864F9739}" progid="myManagedComp.testClass1" threadingModel="Both"
name="myManagedComp.testClass1" runtimeVersion="v1.0.3705"> </clrClass> <clrClass
clsid="{367221D6-3559-3328-ABD3-45B6825F9732}" progid="myManagedComp.testClass2"
threadingModel="Both" name="myManagedComp.testClass2" runtimeVersion="v1.0.3705">
</clrClass> <file name="MyManagedComp.dll"> </file> </assembly>
8. Salvar e nomear o arquivo de manifesto. O nome do componente um manifesto é o nome

da biblioteca do conjunto seguida pela extensão.manifest. Por exemplo, o
myManagedComp.dll é myManagedComp.manifest.
Você deve incorporar o manifesto componente como um recurso no conjunto.
Para incorporar um manifesto componente em um conjunto gerenciado

RT_MANIFEST 1 myManagedComp.manifest
Nesta instrução myManagedComp.manifest é o nome do manifesto componente sendo
incorporado. Para este exemplo, o nome de arquivo script é myresource.rc.
rc myresource.rc
3. Compilar arquivo de origem do conjunto novamente e especifique o arquivo de recurso
usando a /win32res opção:
/win32res:myresource.res
Novamente, myresource.res é o nome do arquivo de recurso contendo recurso incorporado.
O procedimento e exemplo a seguir demonstram como um aplicativo gerenciado, usando

plataforma chamar, pode imprimir o valor o identificador de cada janela para o computador local.
Especificamente, o procedimento e exemplo use a EnumWindows função a que o guiará pela
lista de janelas e uma função de retorno de chamada gerenciado (denominada CallBack) para
imprimir o valor do identificador de janela.
Para implementar uma função de retorno de chamada

1. Examine a assinatura para a EnumWindows função antes passar mais com a
implementação. Possui EnumWindows a assinatura a seguir:
BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
Uma pista que essa função requer um retorno de chamada é a presença do argumento
lpEnumFunc. É comum para ver o lp prefixo (ponteiro longo) combinado com o Func
sufixo do nome do argumentos que se um ponteiro para uma função de retorno de
chamada. Para obter documentação sobre funções Win32, consulte Microsoft Platform
SDK.
2. Crie a função de retorno de chamada gerenciado. O exemplo declara um tipo delegate,
que utiliza dois argumentos chamado CallBack, (hwnd e lparam.) O primeiro argumento é
um identificador para a janela; o segundo argumento é definido pelo aplicativo. Nesta
versão, ambos os argumentos devem ser inteiros.
Funções de retorno de chamada geralmente retornam valores diferentes de zero para
indicar êxito e zero para indicar falha. Este exemplo explicitamente define o valor de retorno
para true para continuar a enumeração.
3. Criar um representante e transfira-como um argumento para a EnumWindows função.
Chamar plataforma converte o representante em um formato de retorno de chamada
familiarizado automaticamente.
4. Verifique o coletor de lixo que não não recuperou o representante antes a função de
retorno de chamada conclua seu trabalho. Quando você passar um representante como um
parâmetro, ou passar um representante contido como um campo em uma estrutura, ela
permanece uncollected para a duração da chamada. Portanto, como é o caso no seguinte
exemplo de enumeração, a função de retorno de chamada completa seu trabalho antes da
chamada retorna e não requer nenhuma ação adicional pelo chamador gerenciado.
Se, no entanto, a função de retorno de chamada pode ser chamada depois retorna a
chamada, o chamador gerenciado deverá executar etapas para garantir que o
representante permanece uncollected até terminar a função de retorno de chamada. Para

obter informações detalhadas sobre como evitar coleta de lixo, consulte Interoperabilidade
Marshaling COM Invoke Platform.
Exemplo
C#
using System; using System.Runtime.InteropServices; public delegate bool CallBack(int hwnd, int lParam);
public class EnumReportApp { [DllImport("user32")] public static extern int EnumWindows(CallBack x, int
y); public static void Main() { CallBack myCallBack = new CallBack(EnumReportApp.Report);
EnumWindows(myCallBack, 0); } public static bool Report(int hwnd, int lParam) { Console.Write("Window
handle is "); Console.WriteLine(hwnd); return true; } }
Como: Mapear HRESULTs e exceções
Métodos com Relatar Erros, retornando HRESULTs; Métodos .NET relatá-los por organizando
exceções. Tempo de Execução trata a transição entre os dois. Cada classe de exceção no .NET
Framework mapeia para um HRESULT.
Classes de exceção definida pelo usuário podem especificar qualquer HRESULT é apropriado.
Essas classes de exceção dinamicamente podem alterar o HRESULT a ser retornado quando a
exceção é gerada, definindo o HResult campo no objeto de exceção. Informações adicionais
sobre a exceção é fornecidas para o cliente por meio da IErrorInfo interface, que é implementado
no objeto .NET durante o processo não gerenciado.
Se você criar uma classe que estende System.Exception, deve definir o campo HRESULT
durante construção. Caso contrário, a classe base atribui o valor HRESULT. Você pode mapear
novas classes de exceção para um HRESULT existente, fornecendo o valor no construtor a
exceção é.
Observe que o Runtime às vezes ignorará uma HRESULT casos em onde há um IErrorInfo
presente no segmento. Este comportamento pode ocorrer em casos onde. e HRESULT o
IErrorInfo não representam o mesmo erro
Para criar uma nova classe de exceção e mapeá-lo para um HRESULT

• Use o seguinte código para criar uma nova classe de exceção chamado NoAccessException
e mapeá-lo para o HRESULT E_ACCESSDENIED.
C++
Class NoAccessException : public ApplicationException { NoAccessException () { HResult =

E_ACCESSDENIED; } } CMyClass::MethodThatThrows { throw new NoAccessException(); }
Você pode encontrar um programa (em qualquer linguagem de programação) que usa um código
tanto gerenciados e não gerenciados ao mesmo tempo. Por exemplo, o empacotador
personalizado no exemplo de código a seguir usa o Marshal.ThrowExceptionForHR(int
HResult) método para acionar uma exceção com um valor HRESULT específico. O método
procura o HRESULT e gera o tipo de exceção apropriado. Por exemplo, o HRESULT no
fragmento de código a seguir gera ArgumentException.
C++
CMyClass::MethodThatThrows { Marshal.ThrowExceptionForHR(COR_E_ARGUMENT); }
A tabela a seguir fornece o mapeamento completo de cada HRESULT à sua classe de exceção
comparável no .NET Framework.

HRESULT Exceção .NET
MSEE_E_APPDOMAINUNLOADED AppDomainUnloadedException
COR_E_APPLICATION ApplicationException
COR_E_ARGUMENT ou E_INVALIDARG ArgumentException
COR_E_ARGUMENTOUTOFRANGE ArgumentOutOfRangeException
COR_E_ARITHMETIC ou ArithmeticException
ERROR_ARITHMETIC_OVERFLOW
COR_E_ARRAYTYPEMISMATCH ArrayTypeMismatchException
COR_E_BADIMAGEFORMAT ou BadImageFormatException
ERROR_BAD_FORMAT
COR_E_COMEMULATE_ERROR COMEmulateException
COR_E_CONTEXTMARSHAL ContextMarshalException
COR_E_CORE CoreException
NTE_FAIL CryptographicException
COR_E_DIRECTORYNOTFOUND ou DirectoryNotFoundException
ERROR_PATH_NOT_FOUND
COR_E_DIVIDEBYZERO DivideByZeroException
COR_E_DUPLICATEWAITOBJECT DuplicateWaitObjectException
COR_E_ENDOFSTREAM EndOfStreamException
COR_E_TYPELOAD EntryPointNotFoundException
COR_E_EXCEPTION Exceção
COR_E_EXECUTIONENGINE ExecutionEngineException
COR_E_FIELDACCESS FieldAccessException
COR_E_FILENOTFOUND ou FileNotFoundException
ERROR_FILE_NOT_FOUND
COR_E_FORMAT FormatException
COR_E_INDEXOUTOFRANGE IndexOutOfRangeException
COR_E_INVALIDCAST ou E_NOINTERFACE InvalidCastException
COR_E_INVALIDCOMOBJECT InvalidComObjectException
COR_E_INVALIDFILTERCRITERIA InvalidFilterCriteriaException
COR_E_INVALIDOLEVARIANTTYPE InvalidOleVariantTypeException
COR_E_INVALIDOPERATION InvalidOperationException
COR_E_IO IOException
COR_E_MEMBERACCESS AccessException
COR_E_METHODACCESS MethodAccessException

COR_E_MISSINGFIELD MissingFieldException
COR_E_MISSINGMANIFESTRESOURCE MissingManifestResourceException
COR_E_MISSINGMEMBER MissingMemberException
COR_E_MISSINGMETHOD MissingMethodException
COR_E_MULTICASTNOTSUPPORTED MulticastNotSupportedException
COR_E_NOTFINITENUMBER NotFiniteNumberException
E_NOTIMPL NotImplementedException
COR_E_NOTSUPPORTED NotSupportedException
OrE_POINTER COR_E_NULLREFERENCE NullReferenceException
COR_E_OUTOFMEMORY ou OutOfMemoryException
E_OUTOFMEMORY
COR_E_OVERFLOW OverflowException
COR_E_PATHTOOLONG ou PathTooLongException
ERROR_FILENAME_EXCED_RANGE
COR_E_RANK RankException
COR_E_REFLECTIONTYPELOAD ReflectionTypeLoadException
COR_E_REMOTING RemotingException
COR_E_SAFEARRAYTYPEMISMATCH SafeArrayTypeMismatchException
COR_E_SECURITY SecurityException
COR_E_SERIALIZATION SerializationException
OrERROR_STACK_OVERFLOW StackOverflowException
COR_E_STACKOVERFLOW
COR_E_SYNCHRONIZATIONLOCK SynchronizationLockException
COR_E_SYSTEM SystemException
COR_E_TARGET TargetException
COR_E_TARGETINVOCATION TargetInvocationException
COR_E_TARGETPARAMCOUNT TargetParameterCountException
COR_E_THREADABORTED ThreadAbortException
COR_E_THREADINTERRUPTED ThreadInterruptedException
COR_E_THREADSTATE ThreadStateException
COR_E_THREADSTOP ThreadStopException
COR_E_TYPELOAD TypeLoadException
COR_E_TYPEINITIALIZATION TypeInitializationException
COR_E_VERIFICATION VerificationException
COR_E_WEAKREFERENCE WeakReferenceException

COR_E_VTABLECALLSNOTSUPPORTED VTableCallsNotSupportedException
Todos os outros HRESULTs COMException
Para recuperar informações de erro estendidas, o cliente gerenciado deve examinar os campos do
objeto de exceção que foi gerado. Para o objeto de exceção para fornecer informações úteis
sobre um erro, o objeto COM deve implementa a IErrorInfo interface. Tempo de Execução utiliza
as informações fornecidas por IErrorInfo para inicializar o objeto de exceção.
Se o objeto COM não oferece suporte IErrorInfo, o Runtime Inicializa um objeto de exceção com
valores padrão. A tabela a seguir lista cada campo associado a um objeto de exceção e identifica
a fonte de informações padrão quando o objeto com oferece suporte IErrorInfo.
Campo Exceção Fonte de informações de com

ErrorCode HRESULT retornado da chamada.
HelpLink Se IErrorInfo->HelpContext diferente de zero, a seqüência é formada pelas
concatenação IErrorInfo->GetHelpFile e " # ". é e IErrorInfo-
>GetHelpContext Caso contrário a seqüência é retornada de IErrorInfo-
>GetHelpFile.
InnerException Sempre uma referência nula (Nothing no Visual Basic.)
Message Seqüência de caracteres retornada de IErrorInfo->GetDescription.
(Mensagem)
Origem Seqüência de caracteres retornada de IErrorInfo->GetSource.
StackTrace O rastreamento da pilha.
TargetSite O nome do método que retornados a falha HRESULT.
Campos exceção, como Message, Source a StackOverflowException., e StackTrace não estão

disponíveis para
O Importador da biblioteca Tipo (TLBIMP.exe) converte assinaturas método com a maioria em

assinaturas gerenciadas. No entanto, vários tipos requer informações adicionais que você pode
especificar, editando o conjunto de interoperabilidade. Este tópico descreve como editar um
conjunto de interoperabilidade. O Empacotamento alterações tópico identifica vários casos que
exigem que você para editar o conjunto de interoperabilidade e descreve as alterações
necessárias.
Para especificar empacotamento alterações no Microsoft intermediários idioma (MSIL)

1. Gerar conjunto interoperacional inicial usando TLBIMP.exe. Por exemplo, para produzir um
conjunto chamado New.dll de New. TLB, digite o seguinte comando no prompt de comando:
tlbimp New.tlb /out:New.dll
2. No prompt de comando, digite o seguinte comando para produzir MSIL para o conjunto:
ildasm New.dll /out:new.il

3. Editar o MSIL conforme necessário.
4. No prompt de comando, digite o seguinte comando para produzir a sintaxe apropriada
definindo um novo New.dll:
ilasm New.il /dll
Gera Visual Studio 2005 um conjunto interoperacional que contém metadados quando você
adiciona uma referência a uma biblioteca de tipos determinado. Se um conjunto interoperacional
primário estiver disponível, Visual Studio usará o conjunto existente antes de gerar um novo
conjunto de interoperabilidade.
Para adicionar uma referência a uma biblioteca de tipos

1. Instale o arquivo exe ou dll com em seu computador, a menos que um instalar.exe do
Windows executa a instalação para você.
2. No menu Project, selecione References.
3. Selecione a COM guia.
4. Selecionar a biblioteca de tipos na lista Available References, ou procure o arquivo TLB.
5. Clique em OK.
Framework, não Consulte Tratamento e Raising eventos. Para obter detalhes específicos que se
aplicam a nesta seção, consulte Consumir eventos na mesma seção.
Um cliente .NET (coletor de eventos) pode receber eventos criados por um servidor COM
existente (origem de evento). Interoperabilidade com gera os representantes necessários nos
metadados que forem incluídos no seu cliente gerenciado. Uma assinatura de representante
importados compreende a interface de evento do coletor, um sublinhado, o nome de evento, e a
palavra EventHandler: SinkEventInterface _ EventName EventHandler.
Observe que objetos com eventos em um cliente .NET que elevar exigir duas coleções Garbage
Collector (GC) antes que são lançadas. Isso ocorre quando o ciclo de referência que ocorre entre
objetos COM e clientes gerenciados. Caso você precise explicitamente liberar um objeto com você
deve chamar o Collect método duas vezes.
Para interoperar com uma fonte de eventos COM existente

1. Obter Conjunto de Módulos (Assembly o) de interoperabilidade primária para o servidor
COM se os tipos com forem a ser compartilhada por outros aplicativos. Um conjunto de
interoperabilidade primário contém metadados que representa a biblioteca de tipos
convertido e é assinado no editor.
Observação
Se o conjunto de interoperabilidade primário é não disponível ou se o conjunto for a ser usado de

forma privada, você pode importar a biblioteca de tipos usando API equivalente ou a Importador
da biblioteca Tipo (TLBIMP.exe) um.
2. O processo de conversão gera um representante para cada evento; no entanto, você só

precisa para coletar os eventos de seu interesse.

3. Você pode usar um navegador de metadados, como para identificar eventos
representantes. o Disassembler MSIL (Ildasm.exe),
4. Consumir eventos da fonte de eventos COM da mesma maneira que consome eventos de
uma origem de evento gerenciado.
Exemplo
O exemplo a seguir demonstra como abrir uma janela do Internet Explorer e Wire eventos criados
pelo InternetExplorer Objeto para manipuladores de eventos implementado no código gerenciado.
Definições de tipos Internet Explorer (incluindo representantes de evento) são importadas como
metadados do SHDocVw.dll. O exemplo recpetores o TitleChange evento.
C#
namespace InternetExplorer { using System; using System.Runtime.InteropServices; using SHDocVw; public
class Explorer { public static void Main() { Explorer explorer = new Explorer(); explorer.Run(); } public void
Run() { Object o = null; String s; try { // Starts the browser. m_IExplorer = new
SHDocVw.InternetExplorer(); } catch(Exception e) { Console.WriteLine("Exception when creating Internet
Explorer object {0}", e); return; } // Wires your event handlers to m_IExplorer. SetAllEvents(); try { // Goes
to the home page. m_WebBrowser = (IWebBrowserApp) m_IExplorer; m_WebBrowser.Visible = true;
m_WebBrowser.GoHome(); // Starts navigating to different URLs. Console.Write("Enter URL (or enter to
quit): "); s = Console.ReadLine(); while (s != "" && m_IExplorer != null && m_WebBrowser != null) {
m_WebBrowser.Navigate(s, ref o, ref o, ref o, ref o); Console.Write("Enter URL (or enter to quit): "); s =
Console.ReadLine(); } m_WebBrowser.Quit(); } catch(Exception sE) { if (m_IExplorer == null &&
m_WebBrowser == null) { Console.WriteLine("Internet Explorer has gone away"); } else {
Console.WriteLine("Exception happens {0}", sE); } } } // Uses the += syntax for adding delegates to events.
void SetAllEvents() { if (m_IExplorer != null) { // Title Change event // DWebBrowserEvents2 is the name of
the sink event //interface. // TitleChange is the name of the event. //
DWebBrowserEvents2_TitleChangeEventHandler is the // delegate name assigned by TlbImp.exe.
DWebBrowserEvents2_TitleChangeEventHandler DTitleChangeE = new
DWebBrowserEvents2_TitleChangeEventHandler(OnTitleChange); m_IExplorer.TitleChange +=
DTitleChangeE; } } /////////////////////////////////////////////////////////////////////// // Define
event handlers. // Document title changed static void OnTitleChange(String Text) { Console.WriteLine("Title
changes to {0}", Text); } ////////////////////////////////////////////////////////////////////////// //
The following are class fields. static private SHDocVw.InternetExplorer m_IExplorer = null; static private
IWebBrowserApp m_WebBrowser = null; } }
Se você optar por declarar tipos com manualmente no código fonte gerenciado, o melhor lugar
para começar é com uma biblioteca Arquivo ou tipo interface Definition Language (IDL) existente.
Quando você não tem o arquivo IDL ou não é possível gerar um arquivo de biblioteca Tipo, você
pode simular os tipos com criando declarações gerenciadas e exportar o conjunto resultante para
uma biblioteca de tipos.
Para simular com tipos de fonte gerenciado

1. Declarar os tipos em um idioma que seja compatível o com comum especificação (cls)
idioma e compilar o arquivo.
2. Exportar o conjunto que contém os tipos com o Tipo Exporter da biblioteca (TlbExp.exe).

3. Usar a biblioteca de tipos com exportado como uma base para declarar tipos gerenciados
orientado com.
Para criar um invólucro Callable Runtime (RCW)
1. Supondo que você tiver um arquivo IDL ou arquivo biblioteca Tipo, decidir quais classes e
interfaces você deseja incluir no RCW personalizado. Você pode excluir qualquer tipos que
você não pretende usar diretamente ou indiretamente em seu aplicativo.
2. Criar um arquivo de origem em um idioma compatível com CLS e declarar os tipos.
Consulte Biblioteca tipo para resumo de conversão assembly Para uma descrição completa
do processo de conversão de importação. Efetivamente, quando você cria um RCW
personalizado, você está executando a atividade de conversão fornecida pelo tipo
manualmente o Importador da biblioteca Tipo (TLBIMP.exe). O Exemplo que segue este
tipos mostra procedimento em um arquivo de biblioteca IDL ou tipo e seus tipos
correspondentes no código C#.
3. Quando as declarações estiverem concluídas, compile o arquivo como você compila
qualquer outro código de fonte gerenciado.
4. Como com os tipos importados com TLBIMP.exe, algumas exigem informações adicionais
que você pode adicionar diretamente a seu código. Para obter detalhes, consulte Como
editar conjuntos Interop:.
Exemplo
O código a seguir mostra um exemplo da interface e ISATestSATest Classe em IDL e os tipos

Arquivo de biblioteca IDL ou tipo
[ object, uuid(40A8C65D-2448-447A-B786-64682CBEF133), dual, helpstring("ISATest Interface"),

pointer_default(unique) ] interface ISATest : IDispatch { [id(1), helpstring("method InSArray")] HRESULT
InSArray([in] SAFEARRAY(int) *ppsa, [out,retval] int *pSum); }; [ uuid(116CCA1E-7E39-4515-9849-
90790DA6431E), helpstring("SATest Class") ] coclass SATest { [default] interface ISATest; };
Wrapper no código fonte gerenciado
C#
using System; using System.Runtime.InteropServices; using System.Runtime.CompilerServices;
[assembly:Guid("E4A992B8-6F5C-442C-96E7-C4778924C753")]
[assembly:ImportedFromTypeLib("SAServerLib")] namespace SAServer { [ComImport] [Guid("40A8C65D-
2448-447A-B786-64682CBEF133")] [TypeLibType(TypeLibTypeFlags.FLicensed)] public interface ISATest {
[DispId(1)] //[MethodImpl(MethodImplOptions.InternalCall, //
MethodCodeType=MethodCodeType.Runtime)] int InSArray( [MarshalAs(UnmanagedType.SafeArray,
SafeArraySubType=VarEnum.VT_I4)] ref int[] param ); } [ComImport] [Guid("116CCA1E-7E39-4515-9849-
90790DA6431E")] [ClassInterface(ClassInterfaceType.None)]
[TypeLibType(TypeLibTypeFlags.FCanCreate)] public class SATest : ISATest { [DispId(1)]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)] extern int
ISATest.InSArray( [MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_I4)] ref int[]
param ); } }

Você deverá registrar todos os adquirida primário conjuntos interoperabilidade no seu computador
de desenvolvimento antes você pode referi-las com Microsoft Visual Studio 2005. O Visual Studio
procurará e usa um conjunto interoperacional primário na primeira vez que você referência um tipo
de uma biblioteca de tipos COM. Se Visual Studio não é possível localizar conjunto de módulos
(assembly o) de interoperabilidade primária associado à biblioteca tipo, ele solicitará que você a
adquiri-lo ou oferece para criar um conjunto de interoperabilidade. Do Importador da biblioteca
Tipo (TLBIMP.exe) da mesma forma, também usa o Registro para localizar conjuntos de
interoperabilidade primárias.
Embora ele não seja necessário para registrar conjuntos de interoperabilidade primárias a menos
que você pretende usar Visual Studio, registro oferece duas vantagens:
• Um conjunto de interoperabilidade primário registrado claramente está marcado sob a

chave de registro da biblioteca de tipos original. Registro é a melhor maneira de se localizar um
conjunto de interoperabilidade primário no seu computador.
• Você pode evitar acidentalmente gerar e usando um novo conjunto interoperacional se, em
algum momento no futuro, você usar o Visual Studio para fazer referência a um tipo para as
quais você tem Conjunto de Módulos (Assembly não registrado um) de interoperabilidade
primária.
Do Ferramenta de registro do conjunto (RegAsm.exe) uso para registrar um conjunto

Para registrar um conjunto interoperacional primário

regasm assemblyname
Neste comando, assemblyname é o nome de arquivo do conjunto que está registrado.
RegAsm.exe adiciona uma entrada para o conjunto de interoperabilidade primário sob a
mesma chave de Registro como a biblioteca tipo original.
Exemplo
O exemplo a seguir registra o CompanyA.UtilLib.dll conjunto de módulos (assembly) de

interoperabilidade primária.
regasm CompanyA.UtilLib.dll
Opcionalmente, você pode dispor mais de uma versão de uma biblioteca de tipos. Por exemplo,
você pode indicar um conjunto de interoperabilidade primário que oferece suporte tipo versões de
biblioteca 1.0 e 1.1.
Para ajustar várias versões de uma biblioteca de tipos

1. Importar um arquivo de biblioteca tipo:

(Ildasm.exe):
ildasm LibUtil.dll /out:LibUtil.il
3. Usando um editor de texto, insira um atributo segundo PrimaryInteropAssemblyAttribute

abaixo o atributo adicionado por TLBIMP.exe. Incluir os números de versão primária e
secundária que representam a segunda versão de biblioteca tipo.
4. Gerar e assinar um novo conjunto do arquivo de texto modificado por meio do Assembler
MSIL (Ilasm.exe):
ilasm LibUtil.il /dll /key:CompanyA.snk
Como Desserializar um Objeto
Quando você desserializar um objeto, o formato transporte determina você se irá criar um objeto
fluxo ou arquivo. Após o formato de transporte é determinado, você pode chamar ou Deserialize
métodos, conforme necessário. o Serialize
Para desserializar um objeto

1. Construir usando um XmlSerializer para desserializar o tipo de objeto.
2. Chame o Deserialize método para produzir uma réplica do objeto. Quando deserializing,
você deve convertido o objeto retornado para o tipo de original, como mostra o exemplo a
seguir, que deserializes o objeto em um arquivo (embora ele também pôde ser
desserializado em um fluxo).
C#
MySerializableClass myObject; // Construct an instance of the XmlSerializer with the type // of object
that is being deserialized. XmlSerializer mySerializer = new
XmlSerializer(typeof(MySerializableClass)); // To read the file, create a FileStream. FileStream
myFileStream = new FileStream("myFileName.xml", FileMode.Open); // Call the Deserialize method
and cast to the object type. myObject = (MySerializableClass) mySerializer.Deserialize(myFileStream)
Como Usar Ferramenta de Definição de Esquema XML para Gerar Classes e Documentos de
Esquema XML
A ferramenta definição de esquema XML (XSD.exe) permite que você para gerar um esquema
XML que descreve uma classe ou para gerar a classe definido por um esquema XML. Os
procedimentos a seguir mostram como executar essas operações.
Para gerar classes que estão em conformidade com um esquema específico

1. Abra um prompt de comando.
2. Passar o Esquema XML como um argumento para a ferramenta definição de esquema
XML, que cria um conjunto de classes que precisamente correspondem ao Esquema XML,
por exemplo:
xsd mySchema.xsd
A ferramenta só pode processar esquemas que fazem referência a W3C (World Wide Web
Consortium) XML Especificação de março de 2001 16. Em outras palavras, o espaço para
nome Esquema XML deve estar " http://www.w3.org/2001/XMLSchema " que mostrado no
exemplo a seguir.
<?xml version="1.0" encoding="utf-8"?> <xs:schema attributeFormDefault="qualified"
elementFormDefault="qualified" targetNamespace=""
xmlns:xs="http://www.w3.org/2001/XMLSchema">
3. Modificar as classes COM métodos, propriedades, ou campos, conforme necessário. Para

obter mais informações sobre como modificar uma classe com atributos, consulte
Controlando a serialização XML usando atributos e Atributos que controlam serialização
SOAP codificado.

Geralmente é útil para examinar o esquema do no fluxo XML que é gerado quando as instâncias
de uma classe (ou classes) são serializados. Por exemplo, você pode publicar o esquema para
outros usuários a ser usado, ou você poderá compará-lo a um esquema com o qual você está
tentando se atingir conformity.
Para gerar um documento de esquema XML de um conjunto de classes
1. Compilar a Classe ou Classes em uma DLL.

2. Abra um prompt de comando.
3. Passar a DLL como um argumento para XSD.exe, por exemplo:
xsd MyFile.dll
O esquema (ou esquemas) serão gravadas, começando com " a schema0.xsd " Nome.
Como Especificar um Nome de Elemento Alternativo para um Fluxo XML
Exemplo do código
Usando você pode gerar mais de um fluxo XML com o mesmo conjunto de classes. o
XmlSerializer Convém fazer isso porque dois serviços XML da Web diferentes exigem as mesmas
informações básicas, com apenas pequenas diferenças. Por exemplo, imagine dois serviços XML
da Web que processam pedidos de livros, e assim ambos requerem números ISBN. One service
uses the tag <ISBN> while the second uses the tag <BookID>. Você ter uma classe denominada
Book que contém um campo chamado ISBN. Por padrão, quando uma instância da classe Book for
serializado, ele poderá, usar o nome membro (ISBN) como o nome do elemento marca. Para o
primeiro serviço XML da Web, este é conforme esperado. Mas para enviar o fluxo XML para o
serviço da Web XML segundo, você deve substituir a serialização para que seja BookID nome
elemento a marca na.
Para criar um fluxo XML com um nome de elemento alternativo

1. Criar uma instância da classe XmlElementAttribute.
2. Definir para " BookID ". da ElementName a XmlElementAttribute
3. Criar uma instância da classe XmlAttributes.
4. Adicione o XmlElementAttribute objeto para a coleção acessada através da XmlElements
propriedade do XmlAttributes.
5. Criar uma instância da classe XmlAttributeOverrides.
6. Adicionar para o XmlAttributeOverrides, passando o tipo de objeto para substituir e o nome
do membro seja substituído. o XmlAttributes
7. Criar uma instância da classe XmlSerializer com XmlAttributeOverrides.
8. Cria uma instância da classe Book, e serializado ou desserializar-lo.
Exemplo
C#
public class SerializeOverride() { // Creates an XmlElementAttribute with the alternate name.
XmlElementAttribute myElementAttribute = new XmlElementAttribute();
myElementAttribute.ElementName = "BookID"; XmlAttributes myAttributes = new XmlAttributes();
myAttributes.XmlElements.Add(myElementAttribute); XmlAttributeOverrides myOverrides = new
XmlAttributeOverrides(); myOverrides.Add(typeof(Book), "ISBN", myAttributes); XmlSerializer
mySerializer = new XmlSerializer(typeof(Book), myOverrides) Book b = new Book(); b.ISBN = "123456789"

// Creates a StreamWriter to write the XML stream to. StreamWriter writer = new
StreamWriter("Book.xml"); mySerializer.Serialize(writer, b); }
Se parecer o fluxo XML pode com o seguinte.
<Book> <BookID>123456789</BookID> </Book>
Como: Controlar serialização de classes derivadas
Usando o XmlElementAttribute atributo para alterar o nome de um elemento XML é a única

maneira não para personalizar serialização objeto. Você também pode personalizar o fluxo XML,
derivar de uma classe existente e instruindo a XmlSerializer instância como serializar a nova
classe.
Por exemplo, fornecido uma Book classe, você pode derivar a partir dele e criar uma ExpandedBook
classe que tenha mais de algumas propriedades No entanto, você deverá instruir para aceitar o
tipo derivado quando serializing ou deserializing. o XmlSerializer Isso pode ser feito, criando uma
XmlElementAttribute instância e definindo sua Type propriedade para o tipo classe derivada.
Adicionar a uma XmlAttributes instância. o XmlElementAttribute Em seguida, adicione a uma
XmlAttributeOverrides instância, especifica o tipo seja substituído e o nome do membro que aceite
a classe derivada. o XmlAttributes Isso é mostrado no exemplo a seguir.
Exemplo
C#
public class Orders { public Book[] Books; } public class Book { public string ISBN; } public class
ExpandedBook:Book { public bool NewEdition; } public class Run { public void SerializeObject(string
filename) { // Each overridden field, property, or type requires // an XmlAttributes instance. XmlAttributes
attrs = new XmlAttributes(); // Creates an XmlElementAttribute instance to override the // field that returns
Book objects. The overridden field // returns Expanded objects instead. XmlElementAttribute attr = new
XmlElementAttribute(); attr.ElementName = "NewBook"; attr.Type = typeof(ExpandedBook); // Adds the
element to the collection of elements. attrs.XmlElements.Add(attr); // Creates the XmlAttributeOverrides
instance. XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides(); // Adds the type of the class
that contains the overridden // member, as well as the XmlAttributes instance to override it // with, to the
XmlAttributeOverrides. attrOverrides.Add(typeof(Orders), "Books", attrs); // Creates the XmlSerializer
using the XmlAttributeOverrides. XmlSerializer s = new XmlSerializer(typeof(Orders), attrOverrides); //
Writing the file requires a TextWriter instance. TextWriter writer = new StreamWriter(filename); // Creates
the object to be serialized. Orders myOrders = new Orders(); // Creates an object of the derived type.
ExpandedBook b = new ExpandedBook(); b.ISBN= "123456789"; b.NewEdition = true; myOrders.Books =
new ExpandedBook[]{b}; // Serializes the object. s.Serialize(writer,myOrders); writer.Close(); } public void
DeserializeObject(string filename) { XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
XmlAttributes attrs = new XmlAttributes(); // Creates an XmlElementAttribute to override the // field that
returns Book objects. The overridden field // returns Expanded objects instead. XmlElementAttribute attr =
new XmlElementAttribute(); attr.ElementName = "NewBook"; attr.Type = typeof(ExpandedBook); // Adds
the XmlElementAttribute to the collection of objects. attrs.XmlElements.Add(attr);
attrOverrides.Add(typeof(Orders), "Books", attrs); // Creates the XmlSerializer using the
XmlAttributeOverrides. XmlSerializer s = new XmlSerializer(typeof(Orders), attrOverrides); FileStream fs =
new FileStream(filename, FileMode.Open); Orders myOrders = (Orders) s.Deserialize(fs);
Console.WriteLine("ExpandedBook:"); // The difference between deserializing the overridden // XML
document and serializing it is this: To read the derived // object values, you must declare an object of the

derived type // and cast the returned object to it. ExpandedBook expanded; foreach(Book b in
myOrders.Books) { expanded = (ExpandedBook)b; Console.WriteLine( expanded.ISBN + "\n" +
expanded.NewEdition); } } }
Como: Serializar um objeto como um fluxo XML codificado por SOAP
Exemplo do código
Porque uma mensagem SOAP é criado usando XML, o XmlSerializer pode ser usado para
serializar classes e gerar mensagens SOAP codificado. O XML resultante obedeça à seção 5 do
documento " simples Protocolo de acesso a objetos " (SOAP) 1.1 W3C (World Wide Web
Consortium) (www.w3.org). Quando você está criando um serviço XML da Web que se comunica
através mensagens SOAP, você pode personalizar o fluxo XML aplicando um conjunto de
atributos SOAP especial às classes e membros de classes Para obter uma lista de atributos,
consulte Atributos que controlam serialização SOAP codificado.
Para serializar um objeto como um fluxo codificado SOAP-XML

1. Criar a classe usando o Ferramenta de definição do esquema XML (XSD.exe).
2. Aplicar um ou mais dos atributos especial encontrado no System.Xml.Serialization.
Consulte a lista em " atributos que serialização SOAP Encoded Controle. "
3. Criar, criando um novo SoapReflectionImporter, e chamar o ImportTypeMapping
método com o tipo de classe serializado. um XmlTypeMapping
O exemplo de código a seguir chama o ImportTypeMapping método da classe
SoapReflectionImporter para criar um XmlTypeMapping.
C#
// Serializes a class named Group as a SOAP message. XmlTypeMapping myTypeMapping = (new
SoapReflectionImporter(). ImportTypeMapping(typeof(Group));
4. Criar uma instância de classe XmlSerializer, passando para o XmlSerializer Construtor. o

XmlTypeMapping
C#
XmlSerializer mySerializer = new XmlSerializer(myTypeMapping);
5. Chamar ou Deserialize Método. o Serialize

Exemplo
C#
// Serializes a class named Group as a SOAP message. XmlTypeMapping myTypeMapping = (new
SoapReflectionImporter().ImportTypeMapping(typeof(Group)); XmlSerializer mySerializer = new
XmlSerializer(myTypeMapping);
Como Particionar Dados Serializados
Dois problemas que ocorrem quando enviar grandes conjuntos de dados em mensagens do
serviço da Web são:
1. Um conjunto de trabalho grande devido a buffer pelo mecanismo de serialização

(memória).
2. O consumo de largura de banda inordinate devido a inflation % 33 após a codificação
Base64.

Para resolver esses problemas, implementar a IXmlSerializable interface para controlar a
serialização e a desserialização. Especificamente, implementar e ReadXml métodos para chunk
os dados. o WriteXml
Para implementar reunir do lado do servidor

1. No computador servidor, o método Web deve desativar o buffer ASP.NET e retornar um
tipo que implementa IXmlSerializable.
2. O tipo que implementa IXmlSerializable chunks os dados no método WriteXml.
Para implementar o processamento do lado do cliente
1. Alterar o método da Web em para retornar o tipo que implementa IXmlSerializable o proxy
cliente. Você pode usar fazer isso automaticamente, mas isso não é mostrado aqui. para
um SchemaImporterExtension
2. Implementar o ReadXml método para ler os dados em partes fluxo e gravar os bytes em
disco. Essa implementação também aumenta eventos andamento que podem ser usados
por um controle gráfico, como uma barra de progresso.
Exemplo
O exemplo de código a seguir mostra o método web no cliente que desativa o buffer do ASP.NET.
Ele também mostra a implementação do lado do cliente da interface IXmlSerializable que chunks
os dados no método WriteXml.
C#
[WebMethod] [System.Web.Services.Protocols.SoapDocumentMethodAttribute (ParameterStyle=
SoapParameterStyle.Bare)] public SongStream DownloadSong(DownloadAuthorization Authorization, string
filePath) { // Turn off response buffering. System.Web.HttpContext.Current.Response.Buffer = false; //
Return a song. SongStream song = new SongStream(filePath); return song; }
...[XmlSchemaProvider("MySchema")] public class SongStream : IXmlSerializable { private const string ns =
"http://demos.Contoso.com/webservices"; private string filePath; public SongStream(){ } public
SongStream(string filePath) { this.filePath = filePath; } // This is the method named by the
XmlSchemaProviderAttribute applied to the type. public static XmlQualifiedName
MySchema(XmlSchemaSet xs) { // This method is called by the framework to get the schema for this type. //
We return an existing schema from disk. XmlSerializer schemaSerializer = new
XmlSerializer(typeof(XmlSchema)); string xsdPath = null; // NOTE: replace the string with your own path.
xsdPath = System.Web.HttpContext.Current.Server.MapPath("SongStream.xsd"); XmlSchema s =
(XmlSchema)schemaSerializer.Deserialize( new XmlTextReader(xsdPath), null); xs.XmlResolver = new
XmlUrlResolver(); xs.Add(s); return new XmlQualifiedName("songStream", ns); } void
IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) { // This is the chunking code. // ASP.NET
buffering must be turned off for this to work. int bufferSize = 4096; char[] songBytes = new char[bufferSize];
FileStream inFile = File.Open(this.filePath, FileMode.Open, FileAccess.Read); long length = inFile.Length;
// Write the file name. writer.WriteElementString("fileName", ns,
Path.GetFileNameWithoutExtension(this.filePath)); // Write the size. writer.WriteElementString("size", ns,
length.ToString()); // Write the song bytes. writer.WriteStartElement("song", ns); StreamReader sr = new
StreamReader(inFile, true); int readLen = sr.Read(songBytes, 0, bufferSize); while (readLen > 0) {
writer.WriteStartElement("chunk", ns); writer.WriteChars(songBytes, 0, readLen);
writer.WriteEndElement(); writer.Flush(); readLen = sr.Read(songBytes, 0, bufferSize); }
writer.WriteEndElement(); inFile.Close(); } System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
{ throw new System.NotImplementedException(); } void IXmlSerializable.ReadXml(System.Xml.XmlReader

reader) { throw new System.NotImplementedException(); } } ...public class SongFile : IXmlSerializable {
public static event ProgressMade OnProgress; public SongFile() { } private const string ns =
"http://demos.teched2004.com/webservices"; public static string MusicPath; private string filePath; private
double size; void IXmlSerializable.ReadXml(System.Xml.XmlReader reader) {
reader.ReadStartElement("DownloadSongResult", ns); ReadFileName(reader); ReadSongSize(reader);
ReadAndSaveSong(reader); reader.ReadEndElement(); } void ReadFileName(XmlReader reader) { string
fileName = reader.ReadElementString("fileName", ns); this.filePath = Path.Combine(MusicPath,
Path.ChangeExtension(fileName, ".mp3")); } void ReadSongSize(XmlReader reader) { this.size =
Convert.ToDouble(reader.ReadElementString("size", ns)); } void ReadAndSaveSong(XmlReader reader) {
FileStream outFile = File.Open( this.filePath, FileMode.Create, FileAccess.Write); string songBase64; byte[]
songBytes; reader.ReadStartElement("song", ns); double totalRead=0; while(true) { if
(reader.IsStartElement("chunk", ns)) { songBase64 = reader.ReadElementString(); totalRead +=
songBase64.Length; songBytes = Convert.FromBase64String(songBase64); outFile.Write(songBytes, 0,
songBytes.Length); outFile.Flush(); if (OnProgress != null) { OnProgress(100 * (totalRead / size)); } } else {
break; } } outFile.Close(); reader.ReadEndElement(); } [PermissionSet(SecurityAction.Demand,
Name="FullTrust")] public void Play() { System.Diagnostics.Process.Start(this.filePath); }
System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema() { throw new
System.NotImplementedException(); } public void WriteXml(XmlWriter writer) { throw new
System.NotImplementedException(); } }
• O código usa espaços para nome a seguir: System.,
System.XmlSystem.Web.Services.Protocols,
System.Web.ServicesSystem.Runtime.Serialization, System.Xml.Serialization e
System.Xml.Schema
Como: Serializar um objeto
Para serializar um objeto, primeiro criar o objeto que está para ser serializado e definir suas
propriedades públicas e campos. Para fazer isso, você deve determinam o formato de transporte
em que o fluxo XML é para ser armazenado, como um fluxo ou como um arquivo. Por exemplo, se
o fluxo XML deve ser salvo em um formulário permanente, criar um FileStream objeto.
Observação
Para obter mais exemplos de serialização XML, consulte Exemplos de serialização XML.
Para um objeto serializado

1. Crie o objeto e defina suas propriedades e campos pública.
2. Construir usando um XmlSerializer o tipo de objeto. Para obter mais informações, consulte
os XmlSerializer construtores de classe.
3. Chame o Serialize método para gerar um fluxo XML ou uma representação em arquivo de
propriedades públicas do objeto e campos. O exemplo a seguir cria um arquivo.
C#
MySerializableClass myObject = new MySerializableClass(); // Insert code to set properties and fields
of the object. XmlSerializer mySerializer = new XmlSerializer(typeof(MySerializableClass)); // To

write to a file, create a StreamWriter object. StreamWriter myWriter = new
StreamWriter("myFileName.xml"); mySerializer.Serialize(myWriter, myObject); myWriter.Close();
Como Qualificar um Elemento XML e Nomes Atributos XML
Code Example
Estão espaços para nome XML contidos, as instâncias da classe XmlSerializerNamespaces deve
conformidade com a especificação W3C (World Wide Web Consortium) (www.w3.org) chamado "
Namespaces em XML. "
Espaços para nome XML fornecem um método para qualificação os nomes de elementos XML e
atributos XML em documentos XML. Um nome qualificado consiste de um prefixo e um nome
local, separados por dois-pontos. O prefixo funciona apenas como um espaço reservado; ele é
mapeado para um URI que especifica um espaço para nome. A combinação de espaço para
nome URI universalmente gerenciado e o nome local produz um nome que é garantida seja
universalmente exclusivo.
Criando uma instância do XmlSerializerNamespaces e adicionando os pares espaço para nome

para o objeto, você pode especificar os prefixos usados em um documento XML.
Para criar nomes qualificado em um documento XML

1. Criar uma instância da classe XmlSerializerNamespaces.
2. Adicionar todos os prefixos e pares espaço para nome para o XmlSerializerNamespaces.
3. Aplicar o atributo apropriado System.Xml.Serialization a cada membro ou classe que é
possível serializar em um documento XML. o XmlSerializer
Os atributos disponíveis são: XmlAnyElementAttribute.,
XmlElementAttributeXmlAttributeAttribute, XmlArrayItemAttributeXmlArrayAttribute,
XmlRootAttribute e XmlTypeAttribute
4. Defina a Namespace propriedade de cada atributo como um dos valores de espaço para
nome a XmlSerializerNamespaces.
5. Passar o XmlSerializerNamespaces. para o Serialize método da XmlSerializer
Exemplo
O exemplo a seguir cria e adiciona dois pares prefixo e espaço para nome ao objeto. an
XmlSerializerNamespaces, O código cria um XmlSerializer que é usado para serializar uma
instância da classe Books. O código chama o Serialize método com o XML para conter espaços
para nome prefixed permitindo o XmlSerializerNamespaces.
C#
using System; using System.IO; using System.Xml; using System.Xml.Serialization; public class Run { public
static void Main() { Run test = new Run(); test.SerializeObject("XmlNamespaces.xml"); } public void
SerializeObject(string filename) { XmlSerializer mySerializer = new XmlSerializer(typeof(Books)); // Writing
a file requires a TextWriter. TextWriter myWriter = new StreamWriter(filename); // Creates an
XmlSerializerNamespaces and adds two // prefix-namespace pairs. XmlSerializerNamespaces
myNamespaces = new XmlSerializerNamespaces(); myNamespaces.Add("books",
"http://www.cpandl.com"); myNamespaces.Add("money", "http://www.cohowinery.com"); // Creates a
Book. Book myBook = new Book(); myBook.TITLE = "A Book Title"; Price myPrice = new Price();
myPrice.price = (decimal) 9.95; myPrice.currency = "US Dollar"; myBook.PRICE = myPrice; Books myBooks
= new Books(); myBooks.Book = myBook; mySerializer.Serialize(myWriter,myBooks,myNamespaces);

myWriter.Close(); } } public class Books { [XmlElement(Namespace = "http://www.cohowinery.com")]
public Book Book; } [XmlType(Namespace ="http://www.cpandl.com")] public class Book {
[XmlElement(Namespace = "http://www.cpandl.com")] public string TITLE; [XmlElement(Namespace
="http://www.cohowinery.com")] public Price PRICE; }
Como: Substituir serialização de SOAP XML codificado
Exemplo do código
O processo para substituir a serialização de XML de objetos como mensagens SOAP é

semelhante para o processo para substituir a serialização de XML padrão. Para obter informações
sobre substituição padrão serialização XML, consulte Como Especificar um Nome de Elemento
Alternativo para um Fluxo XML.
Para substituir a serialização de objetos como mensagens SOAP

1. Criar uma instância da classe SoapAttributeOverrides.
2. Criar para cada membro da classe que está sendo serializado. um SoapAttributes
3. Criar uma instância de uma ou mais dos atributos que afetam a serialização de XML,
conforme apropriado, para o membro sendo serializado. Para obter mais informações,
consulte " atributos que codificado serialização SOAP controle ".
4. Defina a propriedade de SoapAttributes apropriado para o atributo criado na etapa 3.
5. Adicionar SoapAttributes a SoapAttributeOverrides.
6. Criar um XmlTypeMapping usando o SoapAttributeOverrides. Use o
SoapReflectionImporter.ImportTypeMapping método.
7. Criar um XmlSerializer usando XmlTypeMapping.
8. Serializado ou desserializar o objeto.
Exemplo
O exemplo de código a seguir serializes um arquivo em duas maneiras: primeiro, sem substituindo
o comportamento a XmlSerializer classe, e em segundo lugar, por substituindo o comportamento.
O exemplo contém uma classe denominada Group com vários membros. Diversos atributos,, como
o SoapElementAttribute, que foi. aplicado a membros de classe Quando a classe é serializado com
o SerializeOriginal método, os atributos controlar o conteúdo da mensagem SOAP. Quando o
SerializeOverride método é chamado, o comportamento do para esses atributos (conforme
adequado). seja substituído, criando vários atributos e definição das propriedades da XmlSerializer
uma SoapAttributes
C#
using System; using System.IO; using System.Xml; using System.Xml.Serialization; using
System.Xml.Schema; public class Group { [SoapAttribute (Namespace = "http://www.cpandl.com")] public
string GroupName; [SoapAttribute(DataType = "base64Binary")] public Byte [] GroupNumber;
[SoapAttribute(DataType = "date", AttributeName = "CreationDate")] public DateTime Today;
[SoapElement(DataType = "nonNegativeInteger", ElementName = "PosInt")] public string PostitiveInt; //
This is ignored when serialized unless it is overridden. [SoapIgnore] public bool IgnoreThis; public
GroupType Grouptype; [SoapInclude(typeof(Car))] public Vehicle myCar(string licNumber) { Vehicle v;
if(licNumber == "") { v = new Car(); v.licenseNumber = "!!!!!!"; } else { v = new Car(); v.licenseNumber =
licNumber; } return v; } } public abstract class Vehicle { public string licenseNumber; public DateTime
makeDate; } public class Car: Vehicle { } public enum GroupType { // These enums can be overridden. small,

large } public class Run { public static void Main() { Run test = new Run();
test.SerializeOriginal("SoapOriginal.xml"); test.SerializeOverride("SoapOverrides.xml");
test.DeserializeOriginal("SoapOriginal.xml"); test.DeserializeOverride("SoapOverrides.xml"); } public void
SerializeOriginal(string filename) { // Creates an instance of the XmlSerializer class. XmlTypeMapping
myMapping = (new SoapReflectionImporter().ImportTypeMapping( typeof(Group))); XmlSerializer
mySerializer = new XmlSerializer(myMapping); // Writing the file requires a TextWriter. TextWriter writer
= new StreamWriter(filename); // Creates an instance of the class that will be serialized. Group myGroup =
new Group(); // Sets the object properties. myGroup.GroupName = ".NET"; Byte [] hexByte = new
Byte[2]{Convert.ToByte(100), Convert.ToByte(50)}; myGroup.GroupNumber = hexByte; DateTime myDate
= new DateTime(2002,5,2); myGroup.Today = myDate; myGroup.PostitiveInt= "10000";
myGroup.IgnoreThis=true; myGroup.Grouptype= GroupType.small; Car thisCar =(Car)
myGroup.myCar("1234566"); // Prints the license number just to prove the car was created.
Console.WriteLine("License#: " + thisCar.licenseNumber + "\n"); // Serializes the class and closes the
TextWriter. mySerializer.Serialize(writer, myGroup); writer.Close(); } public void SerializeOverride(string
filename) { // Creates an instance of the XmlSerializer class // that overrides the serialization. XmlSerializer
overRideSerializer = CreateOverrideSerializer(); // Writing the file requires a TextWriter. TextWriter writer
= new StreamWriter(filename); // Creates an instance of the class that will be serialized. Group myGroup =
new Group(); // Sets the object properties. myGroup.GroupName = ".NET"; Byte [] hexByte = new
Byte[2]{Convert.ToByte(100), Convert.ToByte(50)}; myGroup.GroupNumber = hexByte; DateTime myDate
= new DateTime(2002,5,2); myGroup.Today = myDate; myGroup.PostitiveInt= "10000";
myGroup.IgnoreThis=true; myGroup.Grouptype= GroupType.small; Car thisCar =(Car)
myGroup.myCar("1234566"); // Serializes the class and closes the TextWriter.
overRideSerializer.Serialize(writer, myGroup); writer.Close(); } public void DeserializeOriginal(string
filename) { // Creates an instance of the XmlSerializer class. XmlTypeMapping myMapping = (new
SoapReflectionImporter().ImportTypeMapping( typeof(Group))); XmlSerializer mySerializer = new
XmlSerializer(myMapping); TextReader reader = new StreamReader(filename); // Deserializes and casts the
object. Group myGroup; myGroup = (Group) mySerializer.Deserialize(reader);
Console.WriteLine(myGroup.GroupName); Console.WriteLine(myGroup.GroupNumber[0]);
Console.WriteLine(myGroup.GroupNumber[1]); Console.WriteLine(myGroup.Today);
Console.WriteLine(myGroup.PostitiveInt); Console.WriteLine(myGroup.IgnoreThis); Console.WriteLine(); }
public void DeserializeOverride(string filename) { // Creates an instance of the XmlSerializer class.
XmlSerializer overRideSerializer = CreateOverrideSerializer(); // Reading the file requires a TextReader.
TextReader reader = new StreamReader(filename); // Deserializes and casts the object. Group myGroup;
myGroup = (Group) overRideSerializer.Deserialize(reader); Console.WriteLine(myGroup.GroupName);
Console.WriteLine(myGroup.GroupNumber[0]); Console.WriteLine(myGroup.GroupNumber[1]);
Console.WriteLine(myGroup.Today); Console.WriteLine(myGroup.PostitiveInt);
Console.WriteLine(myGroup.IgnoreThis); } private XmlSerializer CreateOverrideSerializer() {
SoapAttributeOverrides mySoapAttributeOverrides = new SoapAttributeOverrides(); SoapAttributes
soapAtts = new SoapAttributes(); SoapElementAttribute mySoapElement = new SoapElementAttribute();
mySoapElement.ElementName = "xxxx"; soapAtts.SoapElement = mySoapElement;
mySoapAttributeOverrides.Add(typeof(Group), "PostitiveInt", soapAtts); // Overrides the IgnoreThis
property. SoapIgnoreAttribute myIgnore = new SoapIgnoreAttribute(); soapAtts = new SoapAttributes();
soapAtts.SoapIgnore = false; mySoapAttributeOverrides.Add(typeof(Group), "IgnoreThis", soapAtts); //
Overrides the GroupType enumeration. soapAtts = new SoapAttributes(); SoapEnumAttribute xSoapEnum =
new SoapEnumAttribute(); xSoapEnum.Name = "Over1000"; soapAtts.SoapEnum = xSoapEnum; // Adds
the SoapAttributes to the // mySoapAttributeOverridesrides.

mySoapAttributeOverrides.Add(typeof(GroupType), "large", soapAtts); // Creates a second enumeration and
adds it. soapAtts = new SoapAttributes(); xSoapEnum = new SoapEnumAttribute(); xSoapEnum.Name =
"ZeroTo1000"; soapAtts.SoapEnum = xSoapEnum; mySoapAttributeOverrides.Add(typeof(GroupType),
"small", soapAtts); // Overrides the Group type. soapAtts = new SoapAttributes(); SoapTypeAttribute
soapType = new SoapTypeAttribute(); soapType.TypeName = "Team"; soapAtts.SoapType = soapType;
mySoapAttributeOverrides.Add(typeof(Group),soapAtts); // Creates an XmlTypeMapping that is used to
create an instance // of the XmlSerializer class. Then returns the XmlSerializer. XmlTypeMapping
myMapping = (new SoapReflectionImporter(
mySoapAttributeOverrides)).ImportTypeMapping(typeof(Group)); XmlSerializer ser = new
XmlSerializer(myMapping); return ser; } }
Como Analisar Dígitos Unicode
O Padrão Unicode define valores de código de dígitos em vários scripts. Por exemplo, valores
código no intervalo 09E6 U + a + U 09EF especificam Bengali dígitos de 0 a 9, e valores código no
intervalo U + FF10 a + U FF19 Especificar dígitos de 0 a 9 largura total. No entanto, somente os
dígitos Unicode que o .NET Framework analisa como decimais são dígitos ASCII de 0 a 9,
especificado pelo U + 0030 através u+0039 os valores de código. O .NET Framework analisa
todos os outros dígitos Unicode como caracteres. Portanto, uma tentativa de analisar uma
seqüência de Bengali dígitos no intervalo 09E6 U + a + U 09EF usando o Decimal.Parse método
throws uma exceção.
O exemplo de código a seguir usa o Decimal.Parse método para analisar seqüências de valores
de código Unicode que especificam dígitos em scripts diferentes. As tentativas para analisar
dígitos ASCII e dígitos ASCII especificado como valores de código Unicode êxito. As tentativas
para analisar os valores código Unicode de largura total dígitos, dígitos indo-arábico, e dígitos
Bengali falhar e Acione uma exceção.
Exemplo
C#
using System; public class TestClass { public static void Main() { // Parses a string of ASCII digits 1-5. String
strDigits = "12345"; // Parsing succeeds. Parse(strDigits); // Parses a string of ASCII Digits 1-5 specified //
as Unicode code values. String strUdigits = "\u0031\u0032\u0033\u0034\u0035"; // Parsing succeeds.
Parse(strUdigits); // Parses a string of Fullwidth digits 1-5 specified as // Unicode code values. String
strFdigits = "\uFF11\uFF12\uFF13\uFF14\uFF15"; // Parsing fails. Parse(strFdigits); // Parses a string of
Arabic-Indic digits 1-5 specified as // Unicode code values. String strAdigits =
"\u0661\u0662\u0663\u0664\u0665"; // Parsing fails. Parse(strAdigits); // Parses a string of Bengali digits
1-5 specified as // Unicode code values. String strBdigits = "\u09E7\u09E8\u09E9\u09EA\u09EB"; //
Parsing fails. Parse(strBdigits); } public static void Parse(String str) { try { Decimal dc = Decimal.Parse(str);
Console.WriteLine("Parsing string {0} succeeded: {1}\n",str, dc); } catch (Exception e) {
Console.WriteLine("Parsing string {0} failed", str); Console.WriteLine(e.ToString());
Console.WriteLine("\n"); } } }
Como Criar Culturas Personalizadas
The predefined cultures provided with the .NET Framework and the Windows operating system
provide information such as the language and calendar used in a country/region, and the text
conventions used to format, parse, and compare strings, dates, and numbers. No entanto, você
pode criar uma cultura personalizados se o cultures predefinidas não fornecer as informações seu
aplicativo requer.

Para definir e criar uma cultura personalizado
1. Use um CultureAndRegionInfoBuilder objeto para definir e nomear a cultura personalizado.

A cultura personalizada pode ser um totalmente novo cultura, ou pode ser uma cultura que
substitui uma cultura .NET Framework ou localidade do Windows existente.
Para novos cultures, você pode preencher as CultureAndRegionInfoBuilder propriedades
do objeto com um objeto existente CultureInfo e o LoadDataFromCultureInfo método, e um
objeto existente RegionInfo e o LoadDataFromRegionInfo método. Para cultures
substituição, as CultureAndRegionInfoBuilder propriedades do objeto automaticamente
são preenchidos nas propriedades da cultura está sendo substituída.
2. Modificar as propriedades do objeto CultureAndRegionInfoBuilder para satisfazer os
requisitos de seu aplicativo.
3. Chame o Register método para registrar a cultura personalizado. O processo de registro
executa essas tarefas:
o Cria um arquivo.nlp que contém as informações definido no objeto
CultureAndRegionInfoBuilder.
o Armazena o arquivo.nlp no diretório sistema %WINDIR%\Globalization em seu
computador, que significa as informações cultura persistir mesmo se ele estiver desativado
em seu computador. Você deve ter privilégios administrativos no computador onde a cultura
personalizado está registrado porque o arquivo.nlp está armazenado em um diretório do
sistema.
o Prepara o .NET Framework para pesquisar o diretório sistema
%WINDIR%\Globalization em vez de um cache interno na próxima vez não há uma
solicitação para criar o novo cultura personalizado.
A cultura personalizado agora tem o mesmo status de qualquer predefinido cultura .NET
Framework ou Windows localidade no seu computador. A cultura personalizado está
disponível até você remover o arquivo.nlp correspondente do seu computador com o
Unregister método.
4. Especificar o nome do seu cultura personalizado em um CultureInfo construtor de classe
para criar uma instância do que cultura personalizada em seu aplicativo.
Exemplo
O exemplo de código a seguir usa a CultureAndRegionInfoBuilder classe para definir e registrar

uma cultura personalizado chamado " x traço US--, amostra " e então cria um CultureInfo objeto
para a cultura " x traço US--" amostras. O exemplo de código também mostra algumas
propriedades correspondentes do e CultureInfo Objetos. o CultureAndRegionInfoBuilder
C#
// This example demonstrates the System.Globalization.Culture- // AndRegionInfoBuilder Register method.
// Compile this code example with a reference to sysglobl.dll. using System; using System.Globalization;
class Sample { public static void Main() { CultureAndRegionInfoBuilder cib = null; try { // Create a
CultureAndRegionInfoBuilder object named "x-en-US-sample". Console.WriteLine("Create and explore the
CultureAndRegionInfoBuilder...\n"); cib = new CultureAndRegionInfoBuilder( "x-en-US-sample",
CultureAndRegionModifiers.None); // Populate the new CultureAndRegionInfoBuilder object with culture
information. CultureInfo ci = new CultureInfo("en-US"); cib.LoadDataFromCultureInfo(ci); // Populate the
new CultureAndRegionInfoBuilder object with region information. RegionInfo ri = new RegionInfo("US");
cib.LoadDataFromRegionInfo(ri); // Display some of the properties of the CultureAndRegionInfoBuilder
object. Console.WriteLine("CultureName:. . . . . . . . . . {0}", cib.CultureName);
Console.WriteLine("CultureEnglishName: . . . . . . {0}", cib.CultureEnglishName);

Console.WriteLine("CultureNativeName:. . . . . . . {0}", cib.CultureNativeName); Console.WriteLine("GeoId:.
. . . . . . . . . . . . {0}", cib.GeoId); Console.WriteLine("IsMetric: . . . . . . . . . . . {0}", cib.IsMetric);
Console.WriteLine("ISOCurrencySymbol:. . . . . . . {0}", cib.ISOCurrencySymbol);
Console.WriteLine("RegionEnglishName:. . . . . . . {0}", cib.RegionEnglishName);
Console.WriteLine("RegionName: . . . . . . . . . . {0}", cib.RegionName);
Console.WriteLine("RegionNativeName: . . . . . . . {0}", cib.RegionNativeName);
Console.WriteLine("ThreeLetterISOLanguageName: . . {0}", cib.ThreeLetterISOLanguageName);
Console.WriteLine("ThreeLetterISORegionName: . . . {0}", cib.ThreeLetterISORegionName);
Console.WriteLine("ThreeLetterWindowsLanguageName: {0}", cib.ThreeLetterWindowsLanguageName);
Console.WriteLine("ThreeLetterWindowsRegionName: . {0}", cib.ThreeLetterWindowsRegionName);
Console.WriteLine("TwoLetterISOLanguageName: . . . {0}", cib.TwoLetterISOLanguageName);
Console.WriteLine("TwoLetterISORegionName: . . . . {0}", cib.TwoLetterISORegionName);
Console.WriteLine(); // Register the custom culture. Console.WriteLine("Register the custom culture...");
cib.Register(); // Display some of the properties of the custom culture. Console.WriteLine("Create and
explore the custom culture...\n"); ci = new CultureInfo("x-en-US-sample"); Console.WriteLine("Name: . . . . .
. . . . . . . . {0}", ci.Name); Console.WriteLine("EnglishName:. . . . . . . . . . {0}", ci.EnglishName);
Console.WriteLine("NativeName: . . . . . . . . . . {0}", ci.NativeName);
Console.WriteLine("TwoLetterISOLanguageName: . . . {0}", ci.TwoLetterISOLanguageName);
Console.WriteLine("ThreeLetterISOLanguageName: . . {0}", ci.ThreeLetterISOLanguageName);
Console.WriteLine("ThreeLetterWindowsLanguageName: {0}", ci.ThreeLetterWindowsLanguageName);
Console.WriteLine("\nNote:\n" + "Use the example in the Unregister method topic to remove the custom
culture."); } catch (Exception e) { Console.WriteLine(e); } } } /* This code example produces the following
results: Create and explore the CultureAndRegionInfoBuilder... CultureName:. . . . . . . . . . x-en-US-sample
CultureEnglishName: . . . . . . English (United States) CultureNativeName:. . . . . . . English (United States)
GeoId:. . . . . . . . . . . . . 244 IsMetric: . . . . . . . . . . . False ISOCurrencySymbol:. . . . . . . USD
RegionEnglishName:. . . . . . . United States RegionName: . . . . . . . . . . x-en-US-sample RegionNativeName: . .
. . . . . United States ThreeLetterISOLanguageName: . . eng ThreeLetterISORegionName: . . . USA
ThreeLetterWindowsLanguageName: ENU ThreeLetterWindowsRegionName: . USA
TwoLetterISOLanguageName: . . . en TwoLetterISORegionName: . . . . US Register the custom culture...
Create and explore the custom culture... Name: . . . . . . . . . . . . . x-en-US-sample EnglishName:. . . . . . . . . .
English (United States) NativeName: . . . . . . . . . . English (United States) TwoLetterISOLanguageName: . . .
en ThreeLetterISOLanguageName: . . eng ThreeLetterWindowsLanguageName: ENU Note: Use the example
in the Unregister method topic to remove the custom culture. */
Como Definir e Executar Métodos Dinâmicos
Os procedimentos a seguir mostram como definir e executar um método dinâmico simples e um

método dinâmico vinculado a uma instância de uma classe. Para obter mais informações sobre
métodos dinâmicos, consulte a DynamicMethod classe e Reflexo Emit dinâmico cenários método.
Para definir e executar um método dinâmico

1. Declare um tipo delegate para executar o método. Considere usar um representante
genérico para minimizar o número de tipos de representante necessárias para declarar. O
código a seguir declara dois tipos de representante que podem ser usados para o SquareIt
método, e um deles é genérico.
C#

private delegate long SquareItInvoker(int input); private delegate TReturn OneParameter<TReturn,
TParameter0> (TParameter0 p0);
2. Criar uma matriz que especifica os tipos de parâmetro para o método dinâmico. Neste
exemplo, o único parâmetro está um int. (Integer), para que tenha apenas um elemento da
matriz no Visual Basic
C#
Type[] methodArgs = {typeof(int)};
3. Criar um DynamicMethod. No exemplo do método é chamado SquareIt.
Observação
Ele não é necessário para dar nomes métodos Dinâmico, e eles não podem ser chamados pelo
nome. Vários métodos dinâmicos podem ter o mesmo nome. No entanto, o nome aparece em
pilhas de chamada e pode ser útil para depuração.
4. O tipo do valor de retorno é especificado como long. O método está associado ao módulo
que contém a Example classe, que contém o código de exemplo. Qualquer módulo
carregado pode ser especificado. O método dinâmico age como um módulo - nível static
método no Visual Basic). (Shared
C#
DynamicMethod squareIt = new DynamicMethod( "SquareIt", typeof(long), methodArgs,
typeof(Example).Module);
5. Emitir o corpo de método. Neste exemplo, um ILGenerator objeto é usado para emitir a
linguagem intermediária Microsoft (MSIL). Como alternativa, um DynamicILInfo objeto pode
ser usado em conjunto com geradores de código não gerenciado para emitir o corpo de
método um DynamicMethod.
O MSIL, neste exemplo carrega o argumento, que é para um long, duplicatas. na pilha,
converte-e multiplica os dois números an int, o long, Isso deixa o resultado quadrado na
pilha, e o método tem a ver tudo é retorno.
C#
ILGenerator il = squareIt.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Conv_I8);
il.Emit(OpCodes.Dup); il.Emit(OpCodes.Mul); il.Emit(OpCodes.Ret);
6. Criar uma instância do representante (declarado na etapa 1) que representa o método

dinâmico chamando o CreateDelegate método. Criar o representante conclui o método, e
qualquer tentativa adicional para alterar o método — por exemplo, adicionando mais MSIL
— são ignorados. O código a seguir cria o representante e chama-lo, usando um
representante genérico.
C#
OneParameter<long, int> invokeSquareIt = (OneParameter<long, int>)
squareIt.CreateDelegate(typeof(OneParameter<long, int>)); Console.WriteLine("123456789 squared
= {0}", invokeSquareIt(123456789));
Para definir e executar um método dinâmico que esteja vinculado ao objeto

1. Declare um tipo delegate para executar o método. Considere usar um representante
genérico para minimizar o número de tipos de representante necessárias para declarar. O
código a seguir declara um tipo genérico de representante que pode ser usado para

executar qualquer método com um parâmetro e um valor de retorno, ou um método com
dois parâmetros e um valor de retorno se o representante estiver vinculado a um objeto.
C#
private delegate TReturn OneParameter<TReturn, TParameter0> (TParameter0 p0);
2. Criar uma matriz que especifica os tipos de parâmetro para o método dinâmico. Se o
representante que representa o método deve ser vinculado a um objeto, o primeiro
parâmetro deve corresponder ao tipo o representante está vinculado. Neste exemplo, não
são dois parâmetros, do tipo Example e tipo int (Integer no Visual Basic.)
C#
Type[] methodArgs2 = { typeof(Example), typeof(int) };
3. Criar um DynamicMethod. Não, neste exemplo o método tem nome. O tipo do valor de
retorno é especificado como int (Integer no Visual Basic.) O método tem acesso aos
membros da classe Example privada e protegidos.
C#
DynamicMethod multiplyHidden = new DynamicMethod( "", typeof(int), methodArgs2,
typeof(Example));
4. Emitir o corpo de método. Neste exemplo, um ILGenerator objeto é usado para emitir a
linguagem intermediária Microsoft (MSIL). Como alternativa, um DynamicILInfo objeto
pode ser usado em conjunto com geradores de código não gerenciado para emitir o corpo
de método um DynamicMethod.
O MSIL, neste exemplo carrega o primeiro argumento, que é uma instância da classe
Example, e ele usa para carregar o valor de um campo particular da instância do tipo int. O
segundo argumento é carregado e os dois números são multiplicados. Se o resultado for
maior do que int o valor será truncado e os bits mais significativos serão descartados. O
método retorna, com o valor de retorno na pilha.
C#
ILGenerator ilMH = multiplyHidden.GetILGenerator(); ilMH.Emit(OpCodes.Ldarg_0); FieldInfo
testInfo = typeof(Example).GetField("test", BindingFlags.NonPublic | BindingFlags.Instance);
ilMH.Emit(OpCodes.Ldfld, testInfo); ilMH.Emit(OpCodes.Ldarg_1); ilMH.Emit(OpCodes.Mul);
ilMH.Emit(OpCodes.Ret);
5. Criar uma instância do representante (declarado na etapa 1) que representa o método

dinâmico ao chamar a CreateDelegate sobrecarga método. Criar o representante conclui o
método, e qualquer tentativa adicional para alterar o método — por exemplo, adicionando
mais MSIL — são ignorados.
Observação
Você pode chamar o CreateDelegate método várias vezes para criar representantes vinculados a
outras instâncias do tipo de destino.
6. O código a seguir vincula o método a uma nova instância da classe Example cujo campo
particular de teste é definido para 42. Isto é, sempre que o representante for chamado a
instância do Example é passado para o primeiro parâmetro do método.
7. O representante OneParameter é usado porque o primeiro parâmetro do método sempre
receberá a instância do Example. Quando o representante é invocado, somente o parâmetro
segundo é necessário.
C#

OneParameter<int, int> invoke = (OneParameter<int, int>) multiplyHidden.CreateDelegate(
typeof(OneParameter<int, int>), new Example(42) ); Console.WriteLine("3 * test = {0}", invoke(3));
Exemplo
O exemplo de código a seguir demonstra um método dinâmico simples e um método dinâmico

vinculado a uma instância de uma classe.
O método dinâmico simples leva um argumento, um inteiro de 32 bits, e retorna o quadrado 64

bits do que inteiro. Um representante genérico é usado para chamar o método.
O segundo método dinâmico tem dois parâmetros, do tipo Example e tipo int (Integer no Visual
Basic.) Quando o método dinâmico for criado, ela está vinculada a uma instância do Example,
usando um representante genérico que tem um argumento do tipo int. O representante não tem
um argumento do tipo Example porque o primeiro parâmetro do método sempre receberá a
instância do Example limite. Quando o representante é invocado, somente o int argumento é
fornecido. Este método dinâmico acessa um campo particular da classe Example e retorna o
produto do campo particular e o int argumento.
O exemplo de código define representantes podem ser usadas para executar os métodos.
C#
using System; using System.Reflection; using System.Reflection.Emit; public class Example { // The
following constructor and private field are used to // demonstrate a method bound to an object. private int
test; public Example(int test) { this.test = test; } // Declare delegates that can be used to execute the
completed // SquareIt dynamic method. The OneParameter delegate can be // used to execute any method
with one parameter and a return // value, or a method with two parameters and a return value // if the
delegate is bound to an object. // private delegate long SquareItInvoker(int input); private delegate TReturn
OneParameter<TReturn, TParameter0> (TParameter0 p0); public static void Main() { // Example 1: A
simple dynamic method. // // Create an array that specifies the parameter types for the // dynamic method.
In this example the only parameter is an // int, so the array has only one element. // Type[] methodArgs =
{typeof(int)}; // Create a DynamicMethod. In this example the method is // named SquareIt. It is not
necessary to give dynamic // methods names. They cannot be invoked by name, and two // dynamic methods
can have the same name. However, the // name appears in calls stacks and can be useful for // debugging. //
// In this example the return type of the dynamic method // is long. The method is associated with the
module that // contains the Example class. Any loaded module could be // specified. The dynamic method is
like a module-level // static method. // DynamicMethod squareIt = new DynamicMethod( "SquareIt",
typeof(long), methodArgs, typeof(Example).Module); // Emit the method body. In this example ILGenerator
is used // to emit the MSIL. DynamicMethod has an associated type // DynamicILInfo that can be used in
conjunction with // unmanaged code generators. // // The MSIL loads the argument, which is an int, onto
the // stack, converts the int to a long, duplicates the top // item on the stack, and multiplies the top two
items on the // stack. This leaves the squared number on the stack, and // all the method has to do is return.
// ILGenerator il = squareIt.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Conv_I8);
il.Emit(OpCodes.Dup); il.Emit(OpCodes.Mul); il.Emit(OpCodes.Ret); // Create a delegate that represents
the dynamic method. // Creating the delegate completes the method, and any further // attempts to change
the method (for example, by adding more // MSIL) are ignored. The following code uses a generic // delegate
that can produce delegate types matching any // single-parameter method that has a return type. //
OneParameter<long, int> invokeSquareIt = (OneParameter<long, int>)
squareIt.CreateDelegate(typeof(OneParameter<long, int>)); Console.WriteLine("123456789 squared = {0}",

invokeSquareIt(123456789)); // Example 2: A dynamic method bound to an instance. // // Create an array
that specifies the parameter types for a // dynamic method. If the delegate representing the method // is to
be bound to an object, the first parameter must // match the type the delegate is bound to. In the following //
code the bound instance is of the Example class. // Type[] methodArgs2 = { typeof(Example), typeof(int) };
// Create a DynamicMethod. In this example the method has no // name. The return type of the method is
int. The method // has access to the protected and private data of the // Example class. // DynamicMethod
multiplyHidden = new DynamicMethod( "", typeof(int), methodArgs2, typeof(Example)); // Emit the
method body. In this example ILGenerator is used // to emit the MSIL. DynamicMethod has an associated
type // DynamicILInfo that can be used in conjunction with // unmanaged code generators. // // The MSIL
loads the first argument, which is an instance of // the Example class, and uses it to load the value of a //
private instance field of type int. The second argument is // loaded, and the two numbers are multiplied. If
the result // is larger than int, the value is truncated and the most // significant bits are discarded. The
method returns, with // the return value on the stack. // ILGenerator ilMH =
multiplyHidden.GetILGenerator(); ilMH.Emit(OpCodes.Ldarg_0); FieldInfo testInfo =
typeof(Example).GetField("test", BindingFlags.NonPublic | BindingFlags.Instance);
ilMH.Emit(OpCodes.Ldfld, testInfo); ilMH.Emit(OpCodes.Ldarg_1); ilMH.Emit(OpCodes.Mul);
ilMH.Emit(OpCodes.Ret); // Create a delegate that represents the dynamic method. // Creating the delegate
completes the method, and any further // attempts to change the method for example, by adding more //
MSIL are ignored. // // The following code binds the method to a new instance // of the Example class
whose private test field is set to 42. // That is, each time the delegate is invoked the instance of // Example is
passed to the first parameter of the method. // // The delegate OneParameter is used, because the first //
parameter of the method receives the instance of Example. // When the delegate is invoked, only the second
parameter is // required. // OneParameter<int, int> invoke = (OneParameter<int, int>)
multiplyHidden.CreateDelegate( typeof(OneParameter<int, int>), new Example(42) ); Console.WriteLine("3
* test = {0}", invoke(3)); } } /* This code example produces the following output: 123456789 squared =
15241578750190521 3 * test = 126 */
• O código contém as instruções C# using (Imports. no Visual Basic) necessário para
compilação
• Há referências do conjunto adicionais são necessárias.
• Compilar o código na linha de comando usando csc.exe, vbc.exe, ou CL.exe. Para
compilar o código no Visual Studio, coloque-o em um modelo de projeto de aplicativo de
console.
Como Examinar e Instanciar Tipos Genéricos com Reflexão
Informações sobre tipos genéricos são obtidas no mesmo modo como informações sobre outros
tipos: examinando um Type objeto que representa o tipo genérico. A diferença princípio é que um
tipo genérico tem uma lista de Type objetos que representam seus parâmetros tipo genérico. O
primeiro procedimento nesta seção examina tipos genéricos.
Você pode criar um Type objeto que representa um tipo construído pelos argumentos Tipo de
ligação com os parâmetros Tipo de uma definição de tipo genérico. O segundo procedimento
demonstra isso.
Para examinar um tipo genérico e seus parâmetros tipo

1. Obter uma instância do Type que representa o tipo genérico. No código a seguir, o tipo é
obtido usando o operador C# typeof (GetType no Visual Basic, typeid no Visual C++.)
Consulte o Type tópico de classe para outras maneiras de se obter um Type objeto.
Observe que no restante deste procedimento, o tipo está contido em um parâmetro método
chamado t.
C#
Type d1 = typeof(Dictionary<,>);
2. Use a IsGenericType propriedade para determinar se o tipo é genérico, e use a

IsGenericTypeDefinition propriedade para determinar se o tipo é uma definição de tipo
genérico.
C#
Console.WriteLine(" Is this a generic type? {0}", t.IsGenericType); Console.WriteLine(" Is this a
generic type definition? {0}", t.IsGenericTypeDefinition);
3. Obter uma matriz que contém os argumentos Tipo genérico, usando o

GetGenericArguments método.
C#
Type[] typeParameters = t.GetGenericArguments();
4. Para cada argumento Tipo, determinar se ela é um parâmetro tipo (por exemplo, em uma
definição de tipo genérico) ou um tipo que foi especificado para um parâmetro de tipo (por
exemplo, em um tipo construído), usando a IsGenericParameter propriedade.
C#
Console.WriteLine(" List {0} type arguments:", typeParameters.Length); foreach( Type tParam in
typeParameters ) { if (tParam.IsGenericParameter) { DisplayGenericParameter(tParam); } else {
Console.WriteLine(" Type argument: {0}", tParam); } }
5. No sistema do tipo, um parâmetro tipo genérico é representado por uma instância do Type,
exatamente como são tipos comuns. O código a seguir exibe a posição de um Type objeto
que representa um parâmetro tipo genérico Nome e parâmetro. A posição de parâmetro é
trivial informações aqui; ele é de mais interesse quando você está examinando um
parâmetro tipo que foi usado como um argumento Tipo de outro tipo genérico.
C#
private static void DisplayGenericParameter(Type tp) { Console.WriteLine(" Type parameter: {0}
position {1}", tp.Name, tp.GenericParameterPosition);
6. Determinar a restrição tipo base e as restrições de interface de um parâmetro tipo

genérico, usando o GetGenericParameterConstraints método para obter todas as restrições
em uma única matriz. Restrições não são garantidas para estar em uma ordem específica.
C#
Type classConstraint = null; foreach(Type iConstraint in tp.GetGenericParameterConstraints()) { if
(iConstraint.IsInterface) { Console.WriteLine(" Interface constraint: {0}", iConstraint); } } if
(classConstraint != null) { Console.WriteLine(" Base type constraint: {0}", tp.BaseType); } else
Console.WriteLine(" Base type constraint: None");
7. Use a GenericParameterAttributes propriedade para descobrir as restrições especiais em

um parâmetro, tipo, como solicitar que seja um tipo de referência. A propriedade também
inclui valores que representam variância, que você pode mascarar logoff como mostrado no
código o seguir.
C#

GenericParameterAttributes sConstraints = tp.GenericParameterAttributes &
GenericParameterAttributes.SpecialConstraintMask;
8. Os atributos de restrição especiais são sinalizadores, e o mesmo sinalizador

(System.Reflection.GenericParameterAttributes.None. restrições também representa não
covariância ou contravariance) não especiais que representa Assim, para testar para um
dos seguintes condições você deve usar a máscara apropriada. Nesse caso, usar
System.Reflection.GenericParameterAttributes.SpecialConstraintMask para isolar os
sinalizadores de restrição especial.
C#
if (sConstraints == GenericParameterAttributes.None) { Console.WriteLine(" No special
constraints."); } else { if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.DefaultConstructorConstraint)) { Console.WriteLine(" Must have a
parameterless constructor."); } if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.ReferenceTypeConstraint)) { Console.WriteLine(" Must be a reference
type."); } if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.NotNullableValueTypeConstraint)) { Console.WriteLine(" Must be a
non-nullable value type."); } }
Construir uma instância de um tipo genérico
Um tipo genérico é como um modelo. Você não pode criar instâncias dela a menos que você
especifique reais tipos para seus parâmetros tipo genérico. Para fazer isso em tempo de
execução, usar reflexo, requer o MakeGenericType método.
Para construir uma instância de um tipo genérico
1. Obter um Type objeto que representa o tipo genérico. O código a seguir obtém o tipo
Dictionary genérico de duas maneiras diferentes: por meio do
System.Type.GetType(System.String) método sobrecarregar com uma seqüência que
descreve o tipo, e por chamar o GetGenericTypeDefinition método com o tipo
Dictionary<String, Example> construído no Visual Basic). (Dictionary(Of String, Example) O
MakeGenericType método requer uma definição de tipo genérico.
C#
// Use the typeof operator to create the generic type // definition directly. To specify the generic type
definition, // omit the type arguments but retain the comma that separates // them. Type d1 =
typeof(Dictionary<,>); // You can also obtain the generic type definition from a // constructed class.
In this case, the constructed class // is a dictionary of Example objects, with String keys.
Dictionary<string, Example> d2 = new Dictionary<string, Example>(); // Get a Type object that
represents the constructed type, // and from that get the generic type definition. The // variables d1
and d4 contain the same type. Type d3 = d2.GetType(); Type d4 = d3.GetGenericTypeDefinition();
2. Construir uma matriz de argumentos Tipo para substituir para os parâmetros tipo. A matriz
deve conter o número correto de Type Objetos, na mesma ordem em que aparecem na
lista de parâmetros tipo. Neste caso, a chave (primeiro parâmetro tipo) seja do tipo String, e
os valores no dicionário são instâncias de uma classe denominada Example.
C#
Type[] typeArgs = {typeof(string), typeof(Example)};
3. Chame o MakeGenericType método ao vincular os argumentos Tipo com os parâmetros

Tipo e construir o tipo.

C#
Type constructed = d1.MakeGenericType(typeArgs);
4. Use a CreateInstance sobrecarga método para criar um objeto do tipo construído. O código
a seguir armazena duas instâncias da classe Example no objeto resultante Dictionary<String,
Example>.
C#
object o = Activator.CreateInstance(constructed);
Exemplo
O exemplo de código a seguir define um DisplayGenericType método para examinar a definições

tipo genérico e construídos tipos usados no código e exibir suas informações. Mostra como usar o
DisplayGenericType método a IsGenericType, IsGenericParameter., e GenericParameterPosition
propriedades e o GetGenericArguments método
O exemplo também define um DisplayGenericParameter método para examinar um parâmetro tipo

genérico e exibir suas restrições.
O exemplo de código define um conjunto de tipos de teste, incluindo um tipo genérico que ilustra
restrições de parâmetro, tipo e mostra como para exibir informações sobre esses tipos.
O exemplo constrói um tipo a partir da Dictionary classe, criando uma matriz de argumentos Tipo
e chamar o MakeGenericType método. Compara o Type objeto construído uso
MakeGenericType com um Type objeto obtido usando typeof o programa (GetType. no Visual
Basic), demonstrar que eles sejam os mesmos Da mesma forma, o programa usa o
GetGenericTypeDefinition método para obter a definição do tipo construído, tipo genérico e
compara-o para o Type objeto que representa a Dictionary classe.
C#
using System; using System.Reflection; using System.Collections.Generic; using
System.Security.Permissions; // Define an example interface. public interface ITestArgument {} // Define an
example base class. public class TestBase {} // Define a generic class with one parameter. The parameter //
has three constraints: It must inherit TestBase, it must // implement ITestArgument, and it must have a
parameterless // constructor. public class Test<T> where T : TestBase, ITestArgument, new() {} // Define a
class that meets the constraints on the type // parameter of class Test. public class TestArgument : TestBase,
ITestArgument { public TestArgument() {} } public class Example { // The following method displays
information about a generic // type. private static void DisplayGenericType(Type t) {
Console.WriteLine("\r\n {0}", t); Console.WriteLine(" Is this a generic type? {0}", t.IsGenericType);
Console.WriteLine(" Is this a generic type definition? {0}", t.IsGenericTypeDefinition); // Get the generic
type parameters or type arguments. Type[] typeParameters = t.GetGenericArguments(); Console.WriteLine("
List {0} type arguments:", typeParameters.Length); foreach( Type tParam in typeParameters ) { if
(tParam.IsGenericParameter) { DisplayGenericParameter(tParam); } else { Console.WriteLine(" Type
argument: {0}", tParam); } } } // The following method displays information about a generic // type
parameter. Generic type parameters are represented by // instances of System.Type, just like ordinary types.
private static void DisplayGenericParameter(Type tp) { Console.WriteLine(" Type parameter: {0} position
{1}", tp.Name, tp.GenericParameterPosition); Type classConstraint = null; foreach(Type iConstraint in
tp.GetGenericParameterConstraints()) { if (iConstraint.IsInterface) { Console.WriteLine(" Interface
constraint: {0}", iConstraint); } } if (classConstraint != null) { Console.WriteLine(" Base type constraint: {0}",
tp.BaseType); } else Console.WriteLine(" Base type constraint: None"); GenericParameterAttributes

sConstraints = tp.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask; if
(sConstraints == GenericParameterAttributes.None) { Console.WriteLine(" No special constraints."); } else {
if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.DefaultConstructorConstraint)) { Console.WriteLine(" Must have a
parameterless constructor."); } if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.ReferenceTypeConstraint)) { Console.WriteLine(" Must be a reference type."); }
if (GenericParameterAttributes.None != (sConstraints &
GenericParameterAttributes.NotNullableValueTypeConstraint)) { Console.WriteLine(" Must be a non-
nullable value type."); } } } [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")] public
static void Main() { // Two ways to get a Type object that represents the generic // type definition of the
Dictionary class. // // Use the typeof operator to create the generic type // definition directly. To specify the
generic type definition, // omit the type arguments but retain the comma that separates // them. Type d1 =
typeof(Dictionary<,>); // You can also obtain the generic type definition from a // constructed class. In this
case, the constructed class // is a dictionary of Example objects, with String keys. Dictionary<string,
Example> d2 = new Dictionary<string, Example>(); // Get a Type object that represents the constructed
type, // and from that get the generic type definition. The // variables d1 and d4 contain the same type. Type
d3 = d2.GetType(); Type d4 = d3.GetGenericTypeDefinition(); // Display information for the generic type
definition, and // for the constructed type Dictionary<String, Example>. DisplayGenericType(d1);
DisplayGenericType(d2.GetType()); // Construct an array of type arguments to substitute for // the type
parameters of the generic Dictionary class. // The array must contain the correct number of types, in // the
same order that they appear in the type parameter // list of Dictionary. The key (first type parameter) // is of
type string, and the type to be contained in the // dictionary is Example. Type[] typeArgs = {typeof(string),
typeof(Example)}; // Construct the type Dictionary<String, Example>. Type constructed =
d1.MakeGenericType(typeArgs); DisplayGenericType(constructed); object o =
Activator.CreateInstance(constructed); Console.WriteLine("\r\nCompare types obtained by different
methods:"); Console.WriteLine(" Are the constructed types equal? {0}", (d2.GetType()==constructed));
Console.WriteLine(" Are the generic definitions equal? {0}",
(d1==constructed.GetGenericTypeDefinition())); // Demonstrate the DisplayGenericType and //
DisplayGenericParameter methods with the Test class // defined above. This shows base, interface, and
special // constraints. DisplayGenericType(typeof(Test<>)); } }
compilação
console.
Como Definir um Método genérico com Emissão de Reflexão
O primeiro procedimento mostra como criar um método genérico simples com dois parâmetros
tipo, e como aplicar restrições de classe, restrições interface, e restrições especiais com os
parâmetros tipo.
O segundo procedimento mostra como para emitir o corpo método, e como usar os parâmetros do
método genérico do tipo para criar instâncias de tipos genéricos e para chamar seus métodos.

O procedimento terceiro mostra como chamar o método genérico.
Importante
Um método é não genérico apenas porque ela pertence a um tipo genérico e usa os parâmetros
Tipo do mesmo tipo. Um método é somente se tiver sua própria lista de Parâmetro tipo genérico.
Um método genérico pode aparecer em um tipo nongeneric, como no exemplo. Para obter um
exemplo de um método nongeneric em um tipo genérico, consulte Como Definir um Tipo Genérico
com Emissão de Reflexão.
Para definir um método genérico

1. Antes de começar, ela é útil para examinar como o método genérico aparece quando
gravados usando uma linguagem de alto nível. O código a seguir é incluído no código de
exemplo para este tópico, juntamente com código para chamar o método genérico. O
método tem dois parâmetros Tipo, TInput e TOutput, o segundo dos quais deve ser um tipo
de referência (new deve ter um construtor sem parâmetros (class).),, e deve implementar
ICollection(Of TInput) em C#) (ICollection<TInput> Esta restrição interface assegura que o
System.Collections.Generic.ICollection.Add( método pode ser usado para adicionar
elementos à coleção TOutput que cria o método. O método tem um parâmetro formal, input,.
que é uma matriz de TInput O método cria um conjunto de tipo TOutput e copia os
elementos de input à coleção.
C#
public static TOutput Factory<TInput, TOutput>(TInput[] tarray) where TOutput : class,
ICollection<TInput>, new() { TOutput ret = new TOutput(); ICollection<TInput> ic = ret; foreach
(TInput t in tarray) { ic.Add(t); } return ret; }
2. Definir um conjunto dinâmico e pertence a um módulo dinâmico para conter o tipo o

método genérico. Nesse caso, o conjunto tem somente um módulo, nomeado
DemoMethodBuilder1, e o nome do módulo é o mesmo como o nome do conjunto mais uma
extensão. Neste exemplo, o conjunto é salvo no disco e também executado, para
System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave for especificado. Você pode
usar para examinar DemoMethodBuilder1.dll e para compará-lo para o idioma intermediário
Microsoft (MSIL) para o método mostrado na etapa 1. o Disassembler MSIL (Ildasm.exe)
C#
AssemblyName asmName = new AssemblyName("DemoMethodBuilder1"); AppDomain domain =
AppDomain.CurrentDomain; AssemblyBuilder demoAssembly =
domain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave); // Define the
module that contains the code. For an // assembly with one module, the module name is the //
assembly name plus a file extension. ModuleBuilder demoModule =
demoAssembly.DefineDynamicModule(asmName.Name, asmName.Name+".dll");
3. Define o tipo o método genérico pertence. O tipo não tem a ser genérico. Um método
genérico pode pertencer a qualquer um tipo genérico ou nongeneric. Neste exemplo, o tipo
é uma classe, é não genéricas, e é nomeado DemoType.
C#
TypeBuilder demoType = demoModule.DefineType("DemoType", TypeAttributes.Public);
4. Definir o método genérico. Se os tipos de parâmetros formais Um do método genérico

forem especificados por tipo genérico parâmetros do método genérico, use a DefineMethod
sobrecarga método para definir o método. Os parâmetros tipo genérico do método ainda
não estão definidos, para que você não pode especificar os tipos de parâmetros formais do

método na chamada para DefineMethod. Neste exemplo, o método é chamado Factory. O
método é público e static no Visual Basic (Shared).
C#
MethodBuilder factory = demoType.DefineMethod("Factory", MethodAttributes.Public |
MethodAttributes.Static);
5. Definir os parâmetros de DemoMethod tipo genérico ao passar uma matriz de seqüências

de caracteres que contém os nomes dos parâmetros para o
System.Reflection.Emit.MethodBuilder.DefineGenericParameters(System.String[]) método.
Isso torna o método um método genérico. O código a seguir faz Factory um método com
parâmetros TInput tipo genérico e TOutput. Para facilitar a leitura, o código variáveis com
esses nomes são criados para conter os GenericTypeParameterBuilder objetos que
representam os parâmetros dois tipo.
C#
string[] typeParameterNames = {"TInput", "TOutput"}; GenericTypeParameterBuilder[]
typeParameters = factory.DefineGenericParameters(typeParameterNames);
GenericTypeParameterBuilder TInput = typeParameters[0]; GenericTypeParameterBuilder TOutput
= typeParameters[1];
6. Opcionalmente, adicionar restrições especiais aos parâmetros tipo. Restrições especiais

são adicionadas usando o SetGenericParameterAttributes método. Neste exemplo, TOutput
é restrito para ser um tipo de referência e para que um construtor sem parâmetros.
C#
TOutput.SetGenericParameterAttributes( GenericParameterAttributes.ReferenceTypeConstraint |
GenericParameterAttributes.DefaultConstructorConstraint);
7. Opcionalmente, Adicionar Classe e interface restrições aos parâmetros tipo. Neste

exemplo, parâmetro TOutput type está restrita a tipos que implementam o ICollection(Of
TInput) em C#.) interface (ICollection<TInput> Isso assegura que o Add método pode ser
usado para adicionar elementos.
C#
Type icoll = typeof(ICollection<>); Type icollOfTInput = icoll.MakeGenericType(TInput); Type[]
constraints = {icollOfTInput}; TOutput.SetInterfaceConstraints(constraints);
8. Definir parâmetros do método, usando o SetParameters método formais. Neste exemplo, o

Factory método tem um parâmetro, uma matriz de TInput. Esse tipo é criado por chamada o
MakeArrayType método em que o GenericTypeParameterBuilder representa TInput. O
argumento do SetParameters é uma matriz de Type objetos.
C#
Type[] parms = {TInput.MakeArrayType()}; factory.SetParameters(parms);
9. Definir o tipo de retorno para o método, usando o SetReturnType método. Neste exemplo,
uma instância do TOutput será retornada.
C#
factory.SetReturnType(TOutput);
10. Emitir o método corpo, usando ILGenerator. Para obter detalhes, consulte o procedimento
To Emit the Method Body de acompanhamento.
Importante

Quando você emitir chamadas para métodos de tipos genéricos e os argumentos os tipo desses
tipos são parâmetros tipo do método genérico, você deve usar o static GetConstructor,
GetMethod., e GetField overloads método da classe TypeBuilder para obter formas dos métodos
construído O procedimento de acompanhamento de emissor o corpo de método demonstra isso.
11. Conclua o tipo que contém o método e salvar o conjunto. O procedimento To Invoke the
Generic Method acompanha mostra duas maneiras de chamar o método concluído.
C#
// Complete the type. Type dt = demoType.CreateType(); // Save the assembly, so it can be examined
with Ildasm.exe. demoAssembly.Save(asmName.Name+".dll");
Para emitir o corpo de método

1. Obter um gerador de código e declarar variáveis locais e rótulos. O DeclareLocal método é
usado para declarar variáveis locais. O Factory método tem quatro variáveis locais: retVal.
Ele é convertido em ICollection(Of TInput)), input para manter a matriz de entrada de TInput
objetos, e index para percorrer a matriz para armazenar o novo TOutput que é retornado
pelo método, ic para manter o TOutput quando em C# (ICollection<TInput> O método
também tem dois rótulos, uma para inserir o loop (enterLoop. (loopAgain), definição usando o
DefineLabel método) e outra para a parte superior do loop
A primeira coisa o método não é para carregar seu argumento usando Ldarg_0 OpCode e
para armazenar-na variável input local usando Stloc_S OpCode.
C#
ILGenerator ilgen = factory.GetILGenerator(); LocalBuilder retVal = ilgen.DeclareLocal(TOutput);
LocalBuilder ic = ilgen.DeclareLocal(icollOfTInput); LocalBuilder input =
ilgen.DeclareLocal(TInput.MakeArrayType()); LocalBuilder index = ilgen.DeclareLocal(typeof(int));
Label enterLoop = ilgen.DefineLabel(); Label loopAgain = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Stloc_S, input);
2. Emitir código para criar uma instância do TOutput, usando a sobrecarga método genérico
do método System.Activator.CreateInstance. Usar essa sobrecarga requer o tipo
especificado para que um construtor sem parâmetros, que é a razão para adicionar essa
restrição para TOutput. Criar o método genérico construído, passagem TOutput para
MakeGenericMethod. Após emissor código para chamar o método, emitir código para
armazená-lo na variável retVal usando Stloc_S o local
C#
MethodInfo createInst = typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes);
MethodInfo createInstOfTOutput = createInst.MakeGenericMethod(TOutput);
ilgen.Emit(OpCodes.Call, createInstOfTOutput); ilgen.Emit(OpCodes.Stloc_S, retVal);
3. Emitir código para convertido para ICollection(Of TInput) o novo TOutput objeto e armazená-
lo na variável ic local.
C#
ilgen.Emit(OpCodes.Ldloc_S, retVal); ilgen.Emit(OpCodes.Box, icollOfTInput);
ilgen.Emit(OpCodes.Castclass, icollOfTInput); ilgen.Emit(OpCodes.Stloc_S, ic);
4. Obter um MethodInfo representando o System.Collections.Generic.ICollection.Add(

método. O método está agindo em um ICollection(Of TInput). (ICollection<TInput>), portanto,
ele é necessário para passar o Add método específico para esse tipo construído em C#
Você não pode usar o GetMethod método para obter isso MethodInfo diretamente do
icollOfTInput, porque GetMethod não tem suporte em um tipo que tenha sido construído

com um GenericTypeParameterBuilder. Em vez disso, chame MethodInfo no icoll, que
contém a definição tipo genérico para a ICollection interface genérico. Do MethodInfo
usamos o GetMethod static método para produzir para o tipo construído. O código a seguir
demonstra isso.
C#
MethodInfo mAddPrep = icoll.GetMethod("Add"); MethodInfo mAdd =
TypeBuilder.GetMethod(icollOfTInput, mAddPrep);
5. Emitir código para inicializar a index variável, ao carregar um inteiro de 32 bits 0 e

armazená-lo na variável. Emitir código para filial para o rótulo enterLoop. Este rótulo ainda
não tiver sido marcado, porque ele está dentro do loop. Código para o loop é emitted na
próxima etapa.
C#
// Initialize the count and enter the loop. ilgen.Emit(OpCodes.Ldc_I4_0);
ilgen.Emit(OpCodes.Stloc_S, index); ilgen.Emit(OpCodes.Br_S, enterLoop);
6. Emitir código para o loop. A primeira etapa é para marcar a parte superior do loop, por
chamada MarkLabel com o loopAgain rótulo. Agora instruções filial que usam o rótulo será
Branch a esse ponto no código. A próxima etapa é para empurrar o TOutput objeto,
convertido em ICollection(Of TInput), na pilha. Ele não é necessário imediatamente, mas
precisa fazer na posição para chamar o Add método. Em seguida a matriz de entrada é
empurrada na pilha, em seguida, a index variável que contém o índice atual para a matriz. O
Ldelem código operação aparece o Índice e a matriz desativar a pilha e coloca o elemento
matriz indexada na pilha. Agora a pilha está pronta para a chamada para o
System.Collections.Generic.ICollection.Add( método, que é exibido à coleção e o novo
elemento desativar a pilha e adiciona o elemento para a coleção.
O restante do código no loop Incrementa o índice e testa para ver se o loop For concluído:.
O índice e um inteiro de 32 bits são 1 pressionado na pilha e adicionado, deixando a soma
na Pilha; a soma é armazenada na index é MarkLabel chamado para definir este ponto
como o ponto de entrada para o loop. O índice é carregado novamente. A matriz de entrada
é pressionado na pilha, e Ldlen é emitted para obter seu tamanho. O índice e o
comprimento são agora na pilha, e Clt é emitted para compará-las. Se o índice for menor
que o comprimento, Brtrue_S ramificações volta para o início do loop.
C#
ilgen.MarkLabel(loopAgain); ilgen.Emit(OpCodes.Ldloc_S, ic); ilgen.Emit(OpCodes.Ldloc_S, input);
ilgen.Emit(OpCodes.Ldloc_S, index); ilgen.Emit(OpCodes.Ldelem, TInput);
ilgen.Emit(OpCodes.Callvirt, mAdd); ilgen.Emit(OpCodes.Ldloc_S, index);
ilgen.Emit(OpCodes.Ldc_I4_1); ilgen.Emit(OpCodes.Add); ilgen.Emit(OpCodes.Stloc_S, index);
ilgen.MarkLabel(enterLoop); ilgen.Emit(OpCodes.Ldloc_S, index); ilgen.Emit(OpCodes.Ldloc_S,
input); ilgen.Emit(OpCodes.Ldlen); ilgen.Emit(OpCodes.Conv_I4); ilgen.Emit(OpCodes.Clt);
ilgen.Emit(OpCodes.Brtrue_S, loopAgain);
7. Emitir código para empurrar o TOutput objeto na Pilha e retornar do método. As variáveis
retVal locais e ic ambos contiverem referências ao novo TOutput; ic é usada apenas para
acessar o System.Collections.Generic.ICollection.Add( método.
C#
ilgen.Emit(OpCodes.Ldloc_S, retVal); ilgen.Emit(OpCodes.Ret);
Para chamar o método genérico

1. é Factory uma definição Método genérico. A fim de chamá-lo, você deve atribuir tipos aos
seus parâmetros tipo genérico. Use o MakeGenericMethod método para fazer isso. O

código a seguir cria um método genérico construído, especificando String para TInput e
List(Of String). (List<string>) para TOutput, em C# e exibe uma representação de seqüência
do método
C#
MethodInfo m = dt.GetMethod("Factory"); MethodInfo bound =
m.MakeGenericMethod(typeof(string), typeof(List<string>)); // Display a string representing the
bound method. Console.WriteLine(bound);
2. Para chamar a vinculados as método, use o Invoke método. O código a seguir cria uma
matriz de Object, contendo uma matriz de seqüências de caracteres, como seu único
elemento e passa-como lista de argumentos do método genérico. O primeiro parâmetro do
Invoke é uma referência nula porque o método é static. O valor de retorno é convertido em
List(Of String), e o primeiro elemento é exibido.
C#
object o = bound.Invoke(null, new object[]{arr}); List<string> list2 = (List<string>) o;
Console.WriteLine("The first element is: {0}", list2[0]);
3. Para chamar o método usando um representante, você deve ter um representante que
corresponda a assinatura do método genérico construído Uma maneira fácil para fazer isso
é para criar um representante genérico. O código a seguir cria uma instância do
representante D genérico definida no código de exemplo, usando a
System.Delegate.CreateDelegate(System.Type,System.Reflection.MethodInfo) sobrecarga
método, e chama o representante. Representantes executar melhor que vinculados as
chamadas.
C#
Type dType = typeof(D<string, List <string>>); D<string, List <string>> test; test = (D<string, List
<string>>) Delegate.CreateDelegate(dType, bound); List<string> list3 = test(arr);
Console.WriteLine("The first element is: {0}", list3[0]);
4. O método emitted também pode ser chamado de um programa que se refere ao conjunto
salvo.
Exemplo
O exemplo de código a seguir cria um tipo nongeneric, DemoType,. com um método genérico,
Factory Este método tem dois parâmetros tipo genérico, TInput Para especificar um tipo de entrada
e TOutput Para especificar um tipo de saída. O TOutput parâmetro TYPE está restrita para
implementar ICollection<TInput> (ICollection(Of TInput). no Visual Basic), para ser um tipo de
referência, e para que um construtor sem parâmetros
O método tem um parâmetro formal, que é uma matriz de TInput. O método retorna uma instância
TOutput que contém todos os elementos da matriz de entrada. Pode TOutput ser qualquer tipo a
coleção genérica que implementa a ICollection interface genérico.
Quando o código é executado, o conjunto dinâmico é salvo como DemoGenericMethod1.dll, e

pode ser examinado usando o Disassembler MSIL (Ildasm.exe).
Observação
Uma boa maneira para aprender a emitir código é para gravar um programa que executa a tarefa
você está tentando se emitir, e use o Disassembler para examinar o MSIL produzido pelo
compilador Visual Basic, C#, ou Visual C++.

O exemplo de código inclui código de fonte que é equivalente ao método emitted. O método
emitted é chamado vinculados as e também usando um representante genérico declarada no
exemplo de código.
C#
using System; using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; //
Declare a generic delegate that can be used to execute the // finished method. // public delegate TOut
D<TIn, TOut>(TIn[] input); class GenericMethodBuilder { // This method shows how to declare, in Visual
Basic, the generic // method this program emits. The method has two type parameters, // TInput and
TOutput, the second of which must be a reference type // (class), must have a parameterless constructor
(new()), and must // implement ICollection<TInput>. This interface constraint // ensures that
ICollection<TInput>.Add can be used to add // elements to the TOutput object the method creates. The
method // has one formal parameter, input, which is an array of TInput. // The elements of this array are
copied to the new TOutput. // public static TOutput Factory<TInput, TOutput>(TInput[] tarray) where
TOutput : class, ICollection<TInput>, new() { TOutput ret = new TOutput(); ICollection<TInput> ic = ret;
foreach (TInput t in tarray) { ic.Add(t); } return ret; } public static void Main() { // The following shows the
usage syntax of the C# // version of the generic method emitted by this program. // Note that the generic
parameters must be specified // explicitly, because the compiler does not have enough // context to infer the
type of TOutput. In this case, TOutput // is a generic List containing strings. // string[] arr = {"a", "b", "c",
"d", "e"}; List<string> list1 = GenericMethodBuilder.Factory<string, List <string>>(arr);
Console.WriteLine("The first element is: {0}", list1[0]); // Creating a dynamic assembly requires an
AssemblyName // object, and the current application domain. // AssemblyName asmName = new
AssemblyName("DemoMethodBuilder1"); AppDomain domain = AppDomain.CurrentDomain;
AssemblyBuilder demoAssembly = domain.DefineDynamicAssembly(asmName,
AssemblyBuilderAccess.RunAndSave); // Define the module that contains the code. For an // assembly with
one module, the module name is the // assembly name plus a file extension. ModuleBuilder demoModule =
demoAssembly.DefineDynamicModule(asmName.Name, asmName.Name+".dll"); // Define a type to
contain the method. TypeBuilder demoType = demoModule.DefineType("DemoType",
TypeAttributes.Public); // Define a public static method with standard calling // conventions. Do not specify
the parameter types or the // return type, because type parameters will be used for // those types, and the
type parameters have not been // defined yet. // MethodBuilder factory =
demoType.DefineMethod("Factory", MethodAttributes.Public | MethodAttributes.Static); // Defining
generic type parameters for the method makes it a // generic method. To make the code easier to read, each
// type parameter is copied to a variable of the same name. // string[] typeParameterNames = {"TInput",
"TOutput"}; GenericTypeParameterBuilder[] typeParameters =
factory.DefineGenericParameters(typeParameterNames); GenericTypeParameterBuilder TInput =
typeParameters[0]; GenericTypeParameterBuilder TOutput = typeParameters[1]; // Add special constraints.
// The type parameter TOutput is constrained to be a reference // type, and to have a parameterless
constructor. This ensures // that the Factory method can create the collection type. //
TOutput.SetGenericParameterAttributes( GenericParameterAttributes.ReferenceTypeConstraint |
GenericParameterAttributes.DefaultConstructorConstraint); // Add interface and base type constraints. //
The type parameter TOutput is constrained to types that // implement the ICollection<T> interface, to
ensure that // they have an Add method that can be used to add elements. // // To create the constraint, first
use MakeGenericType to bind // the type parameter TInput to the ICollection<T> interface, // returning the
type ICollection<TInput>, then pass // the newly created type to the SetInterfaceConstraints // method. The
constraints must be passed as an array, even if // there is only one interface. // Type icoll =

typeof(ICollection<>); Type icollOfTInput = icoll.MakeGenericType(TInput); Type[] constraints =
{icollOfTInput}; TOutput.SetInterfaceConstraints(constraints); // Set parameter types for the method. The
method takes // one parameter, an array of type TInput. Type[] parms = {TInput.MakeArrayType()};
factory.SetParameters(parms); // Set the return type for the method. The return type is // the generic type
parameter TOutput. factory.SetReturnType(TOutput); // Generate a code body for the method. // ------------
----------------------- // Get a code generator and declare local variables and // labels. Save the input array to a
local variable. // ILGenerator ilgen = factory.GetILGenerator(); LocalBuilder retVal =
ilgen.DeclareLocal(TOutput); LocalBuilder ic = ilgen.DeclareLocal(icollOfTInput); LocalBuilder input =
ilgen.DeclareLocal(TInput.MakeArrayType()); LocalBuilder index = ilgen.DeclareLocal(typeof(int)); Label
enterLoop = ilgen.DefineLabel(); Label loopAgain = ilgen.DefineLabel(); ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Stloc_S, input); // Create an instance of TOutput, using the generic method // overload
of the Activator.CreateInstance method. // Using this overload requires the specified type to have // a
parameterless constructor, which is the reason for adding // that constraint to TOutput. Create the
constructed generic // method by passing TOutput to MakeGenericMethod. After // emitting code to call the
method, emit code to store the // new TOutput in a local variable. // MethodInfo createInst =
typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes); MethodInfo createInstOfTOutput =
createInst.MakeGenericMethod(TOutput); ilgen.Emit(OpCodes.Call, createInstOfTOutput);
ilgen.Emit(OpCodes.Stloc_S, retVal); // Load the reference to the TOutput object, cast it to //
ICollection<TInput>, and save it. // ilgen.Emit(OpCodes.Ldloc_S, retVal); ilgen.Emit(OpCodes.Box,
icollOfTInput); ilgen.Emit(OpCodes.Castclass, icollOfTInput); ilgen.Emit(OpCodes.Stloc_S, ic); // Loop
through the array, adding each element to the new // instance of TOutput. Note that in order to get a
MethodInfo // for ICollection<TInput>.Add, it is necessary to first // get the Add method for the generic
type defintion, // ICollection<T>.Add. This is because it is not possible // to call GetMethod on
icollOfTInput. The static overload of // TypeBuilder.GetMethod produces the correct MethodInfo for // the
constructed type. // MethodInfo mAddPrep = icoll.GetMethod("Add"); MethodInfo mAdd =
TypeBuilder.GetMethod(icollOfTInput, mAddPrep); // Initialize the count and enter the loop.
ilgen.Emit(OpCodes.Ldc_I4_0); ilgen.Emit(OpCodes.Stloc_S, index); ilgen.Emit(OpCodes.Br_S,
enterLoop); // Mark the beginning of the loop. Push the ICollection // reference on the stack, so it will be in
position for the // call to Add. Then push the array and the index on the // stack, get the array element, and
call Add (represented // by the MethodInfo mAdd) to add it to the collection. // // The other ten instructions
just increment the index // and test for the end of the loop. Note the MarkLabel // method, which sets the
point in the code where the // loop is entered. (See the earlier Br_S to enterLoop.) //
ilgen.MarkLabel(loopAgain); ilgen.Emit(OpCodes.Ldloc_S, ic); ilgen.Emit(OpCodes.Ldloc_S, input);
ilgen.Emit(OpCodes.Ldloc_S, index); ilgen.Emit(OpCodes.Ldelem, TInput); ilgen.Emit(OpCodes.Callvirt,
mAdd); ilgen.Emit(OpCodes.Ldloc_S, index); ilgen.Emit(OpCodes.Ldc_I4_1); ilgen.Emit(OpCodes.Add);
ilgen.Emit(OpCodes.Stloc_S, index); ilgen.MarkLabel(enterLoop); ilgen.Emit(OpCodes.Ldloc_S, index);
ilgen.Emit(OpCodes.Ldloc_S, input); ilgen.Emit(OpCodes.Ldlen); ilgen.Emit(OpCodes.Conv_I4);
ilgen.Emit(OpCodes.Clt); ilgen.Emit(OpCodes.Brtrue_S, loopAgain); ilgen.Emit(OpCodes.Ldloc_S, retVal);
ilgen.Emit(OpCodes.Ret); // Complete the type. Type dt = demoType.CreateType(); // Save the assembly, so
it can be examined with Ildasm.exe. demoAssembly.Save(asmName.Name+".dll"); // To create a constructed
generic method that can be // executed, first call the GetMethod method on the completed // type to get the
generic method definition. Call MakeGenericType // on the generic method definition to obtain the
constructed // method, passing in the type arguments. In this case, the // constructed method has string for
TInput and List<string> // for TOutput. // MethodInfo m = dt.GetMethod("Factory"); MethodInfo bound =
m.MakeGenericMethod(typeof(string), typeof(List<string>)); // Display a string representing the bound
method. Console.WriteLine(bound); // Once the generic method is constructed, // you can invoke it and pass

in an array of objects // representing the arguments. In this case, there is only // one element in that array,
the argument 'arr'. // object o = bound.Invoke(null, new object[]{arr}); List<string> list2 = (List<string>) o;
Console.WriteLine("The first element is: {0}", list2[0]); // You can get better performance from multiple
calls if // you bind the constructed method to a delegate. The // following code uses the generic delegate D
defined // earlier. // Type dType = typeof(D<string, List <string>>); D<string, List <string>> test; test =
(D<string, List <string>>) Delegate.CreateDelegate(dType, bound); List<string> list3 = test(arr);
Console.WriteLine("The first element is: {0}", list3[0]); } } /* This code example produces the following
output: The first element is: a System.Collections.Generic.List`1[System.String]
Factory[String,List`1](System.String[]) The first element is: a The first element is: a */
compilação
console.
Como Usar Assinatura Completa para Dar a um Assembly Dinâmico um Nome Forte
Um conjunto dinâmico pode ser fornecido um nome de alta segurança usando assinatura parcial
ou completo assinatura. Do AssemblyName para assinatura parcial, a chave pública deve ser
especificada no passado para o DefineDynamicAssembly método. O Common Language Runtime
aloca o espaço dentro do arquivo executável (PE) portátil para um BLOB de assinatura nome de
alta segurança, mas na verdade não não assinar o conjunto. O conjunto resultante pode
totalmente entrar em uma etapa Post-Processing usando ferramentas fornecidas no SDK do .NET
Framework.
Para completo assinatura, um par de chaves pública / particular deve ser fornecido. Essas
entidades são normalmente armazenadas em um arquivo ou disco ou em um recipiente de chave
Propriedade por uma API criptografia Cryptographic Provider (CSP) Service. Chaves de baixa
segurança são geralmente gerado pelo CSPs baseados em software e exportado para um arquivo
para que eles podem ser verificados em sistemas de gerenciamento de código de fonte durante o
desenvolvimento do projeto. Chaves de alta segurança geralmente são gerados por hardware que
geralmente ajuda a evitar exportação das teclas para razões de segurança. Tais pares de chaves
só podem ser acessados indiretamente por um recipiente de chave. O par de chaves nome de alta
segurança é especificado usando a System.Reflection.StrongNameKeyPair classe.
O exemplo a seguir demonstra uso completo assinatura para dar um conjunto dinâmico um nome
de alta segurança.
Exemplo
C#
FileStream fs = new FileStream("SomeKeyPair.snk", FileMode.Open); StrongNameKeyPair kp = new
StrongNameKeyPair(fs); fs.Close(); AssemblyName an = new AssemblyName(); an.KeyPair = kp;
AppDomain appDomain = Thread.GetDomain(); AssemblyBuilder ab =
appDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave);
Como Carregar Assemblies no Contexto Somente de Reflexão

O contexto de carga somente Reflection-permite-lhe examinar Conjuntos compilados a outras
plataformas ou de outras versões do .NET Framework. Código carregado neste contexto somente
pode ser examinado; ele não pode ser executado. Isso significa que objetos não podem ser
criados, porque os construtores não podem ser executadas. Porque o código não pode ser
executado, Dependências não são carregadas automaticamente. Caso você precise examiná-los,
você deve carregá-los você mesmo.
Para carregar um conjunto no contexto de carga somente Reflection-

1. Use a ReflectionOnlyLoad sobrecarga método para carregar o conjunto fornecido seu
nome de exibição, ou o ReflectionOnlyLoadFrom método para carregar o conjunto fornecido
seu caminho. Se o conjunto for uma imagem binária, use a ReflectionOnlyLoad sobrecarga
método.
Observação
Não use o contexto somente Reflection-para carregar uma versão de mscorlib.dll de uma versão
do .NET Framework diferente da versão no contexto de execução.
2. Se o conjunto possui dependências, o ReflectionOnlyLoad método não carregará-los.

Caso você precise examiná-los, você deve carregá-los você mesmo,.
3. Determinar se um conjunto é carregado do contexto somente Reflection-usando
propriedade do conjunto ReflectionOnly.
4. Se atributos foram aplicados para o conjunto ou a tipos no conjunto, examine esses
atributos, usando a CustomAttributeData classe para assegurar que nenhuma tentativa é
realizada para executar código em um contexto somente Reflection-. Use a sobrecarga do
System.Reflection.CustomAttributeData.GetCustomAttributes(System.Reflection.Assembly)
método apropriada para obter CustomAttributeData objetos que representam os atributos
aplicados a um conjunto, membro, Módulo, ou parâmetro.
Observação
Atributos aplicados para o conjunto ou seu conteúdo para podem ser definidos no conjunto, ou
que pode ser definida em outro conjunto carregado do contexto somente Reflection-. Não é
possível saber antecipadamente onde os atributos são definidos.
Exemplo
O exemplo de código a seguir mostra como examinar os atributos aplicados a um conjunto

carregado do contexto somente Reflection-.
O exemplo de código define um atributo com dois Construtores e uma propriedade personalizado.
O atributo é aplicado ao conjunto, para um tipo declarado no conjunto, para um método do tipo, e
para um parâmetro do método. Quando executado, o conjunto carrega próprio para o contexto
somente Reflection-e exibe informações sobre os atributos personalizados que foram aplicadas
para ele e para os tipos e membros que ele contém.
Observação
Para simplificar exemplo de código, o conjunto carrega e examina próprio. Normalmente, você não
deve esperar localizar o mesmo conjunto carregado no contexto de execução e o contexto
somente Reflection-.

C#
using System; using System.Reflection; using System.Collections.Generic; // The example attribute is
applied to the assembly. [assembly:Example(ExampleKind.ThirdKind, Note="This is a note on the
assembly.")] // An enumeration used by the ExampleAttribute class. public enum ExampleKind { FirstKind,
SecondKind, ThirdKind, FourthKind }; // An example attribute. The attribute can be applied to all // targets,
from assemblies to parameters. // [AttributeUsage(AttributeTargets.All)] public class ExampleAttribute :
Attribute { // Data for properties. private ExampleKind kindValue; private string noteValue; // Constructors.
The parameterless constructor (.ctor) calls // the constructor that specifies ExampleKind, and supplies the //
default value. // public ExampleAttribute(ExampleKind initKind) { kindValue = initKind; } public
ExampleAttribute() : this(ExampleKind.FirstKind) {} // Properties. The Note property must be read/write,
so that it // can be used as a named parameter. // public ExampleKind Kind { get { return kindValue; }}
public string Note { get { return noteValue; } set { noteValue = value; } } } // The example attribute is applied
to the test class. // [Example(ExampleKind.SecondKind, Note="This is a note on the class.")] public class
Test { // The example attribute is applied to a method, using the // parameterless constructor and supplying
a named argument. // The attribute is also applied to the method parameter. // [Example(Note="This is a
note on a method.")] public void TestMethod([Example] object arg) { } // Main() gets objects representing
the assembly, the test // type, the test method, and the method parameter. Custom // attribute data is
displayed for each of these. // public static void Main() { Assembly asm =
Assembly.ReflectionOnlyLoad("Source"); Type t = asm.GetType("Test"); MethodInfo m =
t.GetMethod("TestMethod"); ParameterInfo[] p = m.GetParameters(); Console.WriteLine("\r\nAttributes
for assembly: {0}", asm); ShowAttributeData(CustomAttributeData.GetCustomAttributes(asm));
Console.WriteLine("\r\nAttributes for type: {0}", t);
ShowAttributeData(CustomAttributeData.GetCustomAttributes(t)); Console.WriteLine("\r\nAttributes for
member: {0}", m); ShowAttributeData(CustomAttributeData.GetCustomAttributes(m));
Console.WriteLine("\r\nAttributes for parameter: {0}", p);
ShowAttributeData(CustomAttributeData.GetCustomAttributes(p[0])); } private static void
ShowAttributeData( IList<CustomAttributeData> attributes) { foreach( CustomAttributeData cad in
attributes ) { Console.WriteLine(" {0}", cad); Console.WriteLine(" Constructor: {0}", cad.Constructor);
Console.WriteLine(" Constructor arguments:"); foreach( CustomAttributeTypedArgument cata in
cad.ConstructorArguments ) { Console.WriteLine(" Type: {0} Value: {1}", cata.ArgumentType, cata.Value); }
Console.WriteLine(" Named arguments:"); foreach( CustomAttributeNamedArgument cana in
cad.NamedArguments ) { CustomAttributeTypedArgument cata = cana.TypedValue; Console.WriteLine("
MemberInfo: {0}", cana.MemberInfo); Console.WriteLine(" Type: {0} Value: {1}", cata.ArgumentType,
cata.Value); } } } } /* This code example produces output similar to the following: Attributes for assembly:
source, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null [ExampleAttribute((ExampleKind)2, Note
= "This is a note on the assembly.")] Constructor: Void .ctor(ExampleKind) Constructor arguments: Type:
ExampleKind Value: 2 Named arguments: MemberInfo: System.String Note Type: System.String Value: This
is a note on the assembly. [System.Runtime.CompilerServices.CompilationRelaxationsAttribute((Int32)8)]
Constructor: Void .ctor(Int32) Constructor arguments: Type: System.Int32 Value: 8 Named arguments:
Attributes for type: Test [ExampleAttribute((ExampleKind)1, Note = "This is a note on the class.")]
Constructor: Void .ctor(ExampleKind) Constructor arguments: Type: ExampleKind Value: 1 Named
arguments: MemberInfo: System.String Note Type: System.String Value: This is a note on the class.
Attributes for member: Void TestMethod(System.Object) [ExampleAttribute(Note = "This is a note on a
method.")] Constructor: Void .ctor() Constructor arguments: Named arguments: MemberInfo: System.String

Note Type: System.String Value: This is a note on a method. Attributes for parameter: System.Object arg
[ExampleAttribute()] Constructor: Void .ctor() Constructor arguments: Named arguments: */
Como Definir um Tipo Genérico com Emissão de Reflexão
Este tópico mostra como criar um tipo genérico simples com parâmetros dois tipo, como aplicar
restrições de classe, restrições de interface, e restrições especiais aos parâmetros tipo, e como
criar membros que usam os parâmetros os tipo de classe como tipos de parâmetro e tipos de
retorno.
Importante
Um método é não genérico apenas porque ela pertence a um tipo genérico e usa os parâmetros
Tipo do mesmo tipo. Um método é somente se tiver sua própria lista de Parâmetro tipo genérico.
A maioria dos métodos em tipos genéricos são não genéricos, como no exemplo. Para obter um
exemplo de emissor um método genérico, consulte Como Definir um Método genérico com
Emissão de Reflexão.
Para definir um tipo genérico

1. Definir um conjunto dinâmico chamado GenericEmitExample1. Neste exemplo, o conjunto é
executado e salvo no disco, para
System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave for especificado.
C#
AppDomain myDomain = AppDomain.CurrentDomain; AssemblyName myAsmName = new
AssemblyName("GenericEmitExample1"); AssemblyBuilder myAssembly =
myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave);
2. Definir um módulo dinâmico. Formado um conjunto de módulos executáveis. Para um

conjunto de módulo único, o nome do módulo é o mesmo como o nome do conjunto, e o
nome do arquivo é o nome do módulo mais uma extensão.
C#
ModuleBuilder myModule = myAssembly.DefineDynamicModule(myAsmName.Name,
myAsmName.Name + ".dll");
3. Definir uma classe. Neste exemplo, a classe é chamada Sample.

C#
TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
4. Definir os parâmetros de Sample tipo genérico ao passar uma matriz de seqüências de

caracteres que contém os nomes dos parâmetros para o
System.Reflection.Emit.TypeBuilder.DefineGenericParameters(System.String[]) método.
Isso torna a classe um tipo genérico. O valor de retorno é uma matriz de
GenericTypeParameterBuilder objetos que representam os parâmetros Tipo, que podem
ser usados em seu código emitted.
No código a seguir, Sample se torna um tipo genérico com parâmetros TFirst Tipo e TSecond.
Para facilitar a leitura, o código cada GenericTypeParameterBuilder é colocada em uma
variável com o mesmo nome como o parâmetro de tipo.
C#

string[] typeParamNames = {"TFirst", "TSecond"}; GenericTypeParameterBuilder[] typeParams =
myType.DefineGenericParameters(typeParamNames); GenericTypeParameterBuilder TFirst =
typeParams[0]; GenericTypeParameterBuilder TSecond = typeParams[1];
5. Adicionar restrições especiais aos parâmetros tipo. Neste exemplo, parâmetro TFirst tipo é
restrito para tipos que tenham construtor sem parâmetros, e para tipos de referência.
C#
TFirst.SetGenericParameterAttributes( GenericParameterAttributes.DefaultConstructorConstraint |
GenericParameterAttributes.ReferenceTypeConstraint);
6. Opcionalmente, Adicionar Classe e interface restrições aos parâmetros tipo. Neste

exemplo, parâmetro TFirst tipo é restrito aos tipos que derivar da classe base representado
pelo objeto Type contido na variável baseType, e que implementam as interfaces cujos tipos
estão contidas nas variáveis interfaceA e interfaceB. Consulte o exemplo de código para a
declaração e atribuição dessas variáveis.
C#
TSecond.SetBaseTypeConstraint(baseType); Type[] interfaceTypes = {interfaceA, interfaceB};
TSecond.SetInterfaceConstraints(interfaceTypes);
7. Definir um campo. Neste exemplo, o tipo do campo é especificado pelo parâmetro TFirst
tipo. Derivar GenericTypeParameterBuilder de Type, portanto, você pode utilizar
parâmetros tipo genérico em qualquer lugar um tipo pode ser usado.
C#
FieldBuilder exField = myType.DefineField("ExampleField", TFirst, FieldAttributes.Private);
8. Definir um método que usa os parâmetros Tipo do tipo genérico. Observe que esses
métodos são não genéricos a menos que tenham suas próprias listas de Parâmetro tipo. O
código a seguir define um static método (Shared. (List(Of TFirst)) que contém todos os
elementos da matriz que usa uma matriz de TFirst e retorna) no Visual Basic No Visual
Basic um List<TFirst> Para definir esse método, é necessário para criar o tipo List<TFirst>,
chamando MakeGenericType na definição tipo genérico, List<T>. (The T is omitted when
you use the typeof operator (GetType in Visual Basic) to get the generic type definition.) O
tipo de parâmetro é criado, usando o MakeArrayType método.
C#
Type listOf = typeof(List<>); Type listOfTFirst = listOf.MakeGenericType(TFirst); Type[]
mParamTypes = {TFirst.MakeArrayType()}; MethodBuilder exMethod =
myType.DefineMethod("ExampleMethod", MethodAttributes.Public | MethodAttributes.Static,
listOfTFirst, mParamTypes);
9. Emitir o corpo de método. O corpo de método consiste de operação três três 8087 que
carregam a matriz entrada na pilha, chamar o List<TFirst> Construtor que leva
IEnumerable<TFirst> (que faz todo o trabalho de colocar os elementos entrados para a lista),
e retornar (deixando o novo List objeto na Pilha). A parte difícil do emissor esse código
estiver obtendo o construtor.
Não há suporte para o GetConstructor método no portanto, é possível para obter o
Construtor de List<TFirst> diretamente. a GenericTypeParameterBuilder, Primeiro, é
necessário para obter o construtor da definição List<T> do tipo genérico e que a converte
para chamar um método para o construtor correspondente de List<TFirst>.
Leva o construtor usado para este exemplo de código um IEnumerable<T>. Observe,
contudo, não a definição da interface genérica do IEnumerable tipo genérico que este é; em
vez disso, o parâmetro T do List<T> tipo deve ser substituído para o parâmetro T de tipo de
IEnumerable<T>. (This seems confusing only because both types have type parameters

named T. That Is Por que este exemplo de código usa os nomes TFirst e TSecond). Para
obter o tipo de argumento de construtor, inicie com a definição IEnumerable<T> tipo
genérico e chamada MakeGenericType com o primeiro parâmetro do List<T> tipo genérico.
A lista de argumentos de construtor deve ser passada como uma matriz, com apenas um
argumento, nesse caso.
Observação
A definição tipo genérico é expresso como IEnumerable<> Quando você usa o typeof operador em
C#, ou IEnumerable(Of ) Quando você usa o GetType operador no Visual Basic.
Agora é possível para obter o Construtor de List<T> chamando GetConstructor na

definição tipo genérico. Para converter esse construtor para o construtor de List<TFirst>,
secreta List<TFirst> correspondente e o Construtor de List<T> para o método estático
System.Reflection.Emit.TypeBuilder.GetConstructor(System.Type,System.Reflection.Constr
uctorInfo).
C#
ILGenerator ilgen = exMethod.GetILGenerator(); Type ienumOf = typeof(IEnumerable<>); Type
TfromListOf = listOf.GetGenericArguments()[0]; Type ienumOfT =
ienumOf.MakeGenericType(TfromListOf); Type[] ctorArgs = {ienumOfT}; ConstructorInfo ctorPrep
= listOf.GetConstructor(ctorArgs); ConstructorInfo ctor = TypeBuilder.GetConstructor(listOfTFirst,
ctorPrep); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Newobj, ctor);
ilgen.Emit(OpCodes.Ret);
10. Criar o tipo e salvar o arquivo.

C#
Type finished = myType.CreateType(); myAssembly.Save(myAsmName.Name+".dll");
11. Chamar o método. é ExampleMethod Não genéricas, mas o tipo ele pertence a é genérico;
portanto, a fim de obter uma MethodInfo que pode ser chamado ele é necessárias para criar
um tipo construído da definição do tipo para Sample. O tipo construído usa a Example classe,
que satisfaça as restrições em TFirst porque ele é um tipo de referência e tem um construtor
sem parâmetros padrão, e a ExampleDerived classe que satisfaça as restrições no TSecond.
(O código para ExampleDerived pode ser encontrado na seção a código exemplo.) Esses
dois tipos são passados para MakeGenericType para criar o tipo construído. O
MethodInfo então é obtida através do GetMethod método.
C#
Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)}; Type constructed =
finished.MakeGenericType(typeArgs); MethodInfo mi = constructed.GetMethod("ExampleMethod");
12. O código a seguir cria uma matriz de Example Objetos, coloca essa matriz em uma matriz
do tipo Object que representa os argumentos do método para ser chamado, e transmite-los
para o Invoke método. O primeiro argumento do método Invoke é uma referência nula
porque o método é static.
C#
Example[] input = {new Example(), new Example()}; object[] arguments = {input}; List<Example>
listX = (List<Example>) mi.Invoke(null, arguments); Console.WriteLine( "\nThere are {0} elements
in the List<Example>.", listX.Count);
Exemplo

O exemplo de código a seguir define uma classe nomeado Sample, junto com uma classe base e
duas interfaces. O programa define dois parâmetros tipo genérico para Sample, transformando-lo
em um tipo genérico. Parâmetros tipo são a única coisa que faz um tipo genérica. O programa
mostra isso, exibindo uma mensagem de teste antes e depois a definição de tipo os parâmetros.
O parâmetro TSecond tipo é usado para demonstrar restrições classe e interface, usando a classe
base e interfaces, e o parâmetro TFirst de tipo é usado para demonstrar restrições especiais.
O exemplo de código define um campo e um método usando parâmetros tipo a classe é para o
tipo de campo e para o parâmetro e retornar tipo do método.
Depois que a Sample classe foi criada, o método é chamado.
O programa inclui um método que lista informações sobre um tipo genérico, e um método que lista
as restrições especiais em um parâmetro tipo. Esses métodos são usados para exibir informações
sobre a classe concluída Sample.
Do Disassembler MSIL (Ildasm.exe) o programa salvar o módulo terminado em disco como

GenericEmitExample1.dll, para que você possa abri-lo com e examine o MSIL para a Sample classe.
C#
using System; using System.Reflection; using System.Reflection.Emit; using System.Collections.Generic; //
Define a trivial base class and two trivial interfaces // to use when demonstrating constraints. // public class
ExampleBase {} public interface IExampleA {} public interface IExampleB {} // Define a trivial type that can
substitute for type parameter // TSecond. // public class ExampleDerived : ExampleBase, IExampleA,
IExampleB {} public class Example { public static void Main() { // Define a dynamic assembly to contain the
sample type. The // assembly will not be run, but only saved to disk, so // AssemblyBuilderAccess.Save is
specified. // AppDomain myDomain = AppDomain.CurrentDomain; AssemblyName myAsmName = new
AssemblyName("GenericEmitExample1"); AssemblyBuilder myAssembly =
myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave); // An assembly
is made up of executable modules. For a single- // module assembly, the module name and file name are the
same // as the assembly name. // ModuleBuilder myModule =
myAssembly.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll"); // Get type objects
for the base class trivial interfaces to // be used as constraints. // Type baseType = typeof(ExampleBase);
Type interfaceA = typeof(IExampleA); Type interfaceB = typeof(IExampleB); // Define the sample type. //
TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public); Console.WriteLine("Type
'Sample' is generic: {0}", myType.IsGenericType); // Define type parameters for the type. Until you do this,
// the type is not generic, as the preceding and following // WriteLine statements show. The type parameter
names are // specified as an array of strings. To make the code // easier to read, each
GenericTypeParameterBuilder is placed // in a variable with the same name as the type parameter. //
string[] typeParamNames = {"TFirst", "TSecond"}; GenericTypeParameterBuilder[] typeParams =
myType.DefineGenericParameters(typeParamNames); GenericTypeParameterBuilder TFirst =
typeParams[0]; GenericTypeParameterBuilder TSecond = typeParams[1]; Console.WriteLine("Type 'Sample'
is generic: {0}", myType.IsGenericType); // Apply constraints to the type parameters. // // A type that is
substituted for the first parameter, TFirst, // must be a reference type and must have a parameterless //
constructor. TFirst.SetGenericParameterAttributes(
GenericParameterAttributes.DefaultConstructorConstraint |
GenericParameterAttributes.ReferenceTypeConstraint); // A type that is substituted for the second type //
parameter must implement IExampleA and IExampleB, and // inherit from the trivial test class

ExampleBase. The // interface constraints are specified as an array // containing the interface types.
TSecond.SetBaseTypeConstraint(baseType); Type[] interfaceTypes = {interfaceA, interfaceB};
TSecond.SetInterfaceConstraints(interfaceTypes); // The following code adds a private field named
ExampleField, // of type TFirst. FieldBuilder exField = myType.DefineField("ExampleField", TFirst,
FieldAttributes.Private); // Define a static method that takes an array of TFirst and // returns a List<TFirst>
containing all the elements of // the array. To define this method it is necessary to create // the type
List<TFirst> by calling MakeGenericType on the // generic type definition, List<T>. (The T is omitted with
// the typeof operator when you get the generic type // definition.) The parameter type is created by using
the // MakeArrayType method. // Type listOf = typeof(List<>); Type listOfTFirst =
listOf.MakeGenericType(TFirst); Type[] mParamTypes = {TFirst.MakeArrayType()}; MethodBuilder
exMethod = myType.DefineMethod("ExampleMethod", MethodAttributes.Public | MethodAttributes.Static,
listOfTFirst, mParamTypes); // Emit the method body. // The method body consists of just three opcodes, to
load // the input array onto the execution stack, to call the // List<TFirst> constructor that takes
IEnumerable<TFirst>, // which does all the work of putting the input elements into // the list, and to return,
leaving the list on the stack. The // hard work is getting the constructor. // // The GetConstructor method is
not supported on a // GenericTypeParameterBuilder, so it is not possible to get // the constructor of
List<TFirst> directly. There are two // steps, first getting the constructor of List<T> and then // calling a
method that converts it to the corresponding // constructor of List<TFirst>. // // The constructor needed
here is the one that takes an // IEnumerable<T>. Note, however, that this is not the // generic type
definition of IEnumerable<T>; instead, the // T from List<T> must be substituted for the T of //
IEnumerable<T>. (This seems confusing only because both // types have type parameters named T. That is
why this example // uses the somewhat silly names TFirst and TSecond.) To get // the type of the constructor
argument, take the generic // type definition IEnumerable<T> (expressed as // IEnumerable<> when you
use the typeof operator) and // call MakeGenericType with the first generic type parameter // of List<T>.
The constructor argument list must be passed // as an array, with just one argument in this case. // // Now it
is possible to get the constructor of List<T>, // using GetConstructor on the generic type definition. To get //
the constructor of List<TFirst>, pass List<TFirst> and // the constructor from List<T> to the static //
TypeBuilder.GetConstructor method. // ILGenerator ilgen = exMethod.GetILGenerator(); Type ienumOf =
typeof(IEnumerable<>); Type TfromListOf = listOf.GetGenericArguments()[0]; Type ienumOfT =
ienumOf.MakeGenericType(TfromListOf); Type[] ctorArgs = {ienumOfT}; ConstructorInfo ctorPrep =
listOf.GetConstructor(ctorArgs); ConstructorInfo ctor = TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);
ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Newobj, ctor); ilgen.Emit(OpCodes.Ret); // Create the
type and save the assembly. Type finished = myType.CreateType();
myAssembly.Save(myAsmName.Name+".dll"); // Invoke the method. // ExampleMethod is not generic, but
the type it belongs to is // generic, so in order to get a MethodInfo that can be invoked // it is necessary to
create a constructed type. The Example // class satisfies the constraints on TFirst, because it is a // reference
type and has a default constructor. In order to // have a class that satisfies the constraints on TSecond, //
this code example defines the ExampleDerived type. These // two types are passed to MakeGenericMethod to
create the // constructed type. // Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)}; Type
constructed = finished.MakeGenericType(typeArgs); MethodInfo mi =
constructed.GetMethod("ExampleMethod"); // Create an array of Example objects, as input to the generic //
method. This array must be passed as the only element of an // array of arguments. The first argument of
Invoke is // null, because ExampleMethod is static. Display the count // on the resulting List<Example>. //
Example[] input = {new Example(), new Example()}; object[] arguments = {input}; List<Example> listX =
(List<Example>) mi.Invoke(null, arguments); Console.WriteLine( "\nThere are {0} elements in the
List<Example>.", listX.Count); DisplayGenericParameters(finished); } private static void

DisplayGenericParameters(Type t) { if (!t.IsGenericType) { Console.WriteLine("Type '{0}' is not generic.");
return; } if (!t.IsGenericTypeDefinition) { t = t.GetGenericTypeDefinition(); } Type[] typeParameters =
t.GetGenericArguments(); Console.WriteLine("\nListing {0} type parameters for type '{1}'.",
typeParameters.Length, t); foreach( Type tParam in typeParameters ) { Console.WriteLine("\r\nType
parameter {0}:", tParam.ToString()); foreach( Type c in tParam.GetGenericParameterConstraints() ) { if
(c.IsInterface) { Console.WriteLine(" Interface constraint: {0}", c); } else { Console.WriteLine(" Base type
constraint: {0}", c); } } ListConstraintAttributes(tParam); } } // List the constraint flags. The
GenericParameterAttributes // enumeration contains two sets of attributes, variance and // constraints. For
this example, only constraints are used. // private static void ListConstraintAttributes(Type t) { // Mask off
the constraint flags. GenericParameterAttributes constraints = t.GenericParameterAttributes &
GenericParameterAttributes.SpecialConstraintMask; if ((constraints &
GenericParameterAttributes.ReferenceTypeConstraint) != GenericParameterAttributes.None) {
Console.WriteLine(" ReferenceTypeConstraint"); } if ((constraints &
GenericParameterAttributes.NotNullableValueTypeConstraint) != GenericParameterAttributes.None) {
Console.WriteLine(" NotNullableValueTypeConstraint"); } if ((constraints &
GenericParameterAttributes.DefaultConstructorConstraint) !=GenericParameterAttributes.None) {
Console.WriteLine(" DefaultConstructorConstraint"); } } } /* This code example produces the following
output: Type 'Sample' is generic: False Type 'Sample' is generic: True There are 2 elements in the
List<Example>. Listing 2 type parameters for type 'Sample[TFirst,TSecond]'. Type parameter TFirst:
ReferenceTypeConstraint DefaultConstructorConstraint Type parameter TSecond: Interface constraint:
IExampleA Interface constraint: IExampleB Base type constraint: ExampleBase */
compilação
console.

Explicações Passo-a-passo do .NET Framework
SDK
Passo-a-passo: Adicionando Marcas Inteligentes a um Componente do Windows Forms
Marcas inteligentes são semelhantes menu-Usuário elementos Interface (UI) que fornecer
comumente usadas opções em tempo de design. A maioria dos componentes padrão e controles
fornecidos com o .NET Framework contém marca inteligente e melhorias de verbo Designer. Os
procedimentos nessa explicação passo a passo mostram como para adicionar suporte de marca
inteligente à componentes e controles personalizados Você.
Você pode adicionar marcas inteligentes para componentes formulários janela às opções Design-
time de fornecimento comumente usado. Itens em um painel Marca Inteligente-logicamente são
agrupados por categoria, e ocorrências individuais DesignerActionMethodItem opcionalmente
podem ser duplicadas como entradas de verbo Designer. Muitos dos componentes padrão e
controles fornecidos com o .NET Framework conter marca inteligente e melhorias de verbo
Designer. Componente e autores controle personalizado também podem adicionar suporte de
marca inteligente, normalmente usando o modelo de envio.
Adicionar marcas inteligentes com o modelo de envio requer as seguintes adições ao projeto
componente:
• Implementação de uma classe, derivado DesignerActionList, que define a métodos e

propriedades que são alvos de itens de menu de marcas inteligentes. Esta classe também
pode fornecer um método substituído GetSortedActionItems que retorna uma matriz de
DesignerActionItem instâncias.
• A classe designer associado ao componente deve implementar a ActionLists propriedade.
Recuperar esta propriedade fornece a DesignerActionListCollection que contém todas as
DesignerActionList instâncias associadas a um único menu de marcas inteligentes.
Geralmente há apenas uma lista em tal uma coleção.
O procedimento a seguir demonstra como adicionar marcas inteligentes usando código de um

controle exemplo simples, ColorLabel,. que é derivado do controle Windows Forms Label padrão
Este controle tem um designer associado chamado ColorLabelDesigner.
Para copiar o código deste tópico como uma lista simples, consulte COMO: Anexar marcas
inteligentes para um componente de formulários do Windows.
Pré-requisitos
A fim de concluir este explicação passo a passo, será necessário:
• Permissões suficientes para poder para criar e executar projetos do aplicativo Windows
Forms no computador onde o .NET Framework é instalado.
Para implementar uma classe derivada de DesignerActionList
1. No mesmo espaço para nome que o componente, adicione a declaração para a classe
derivada de DesignerActionList.
C#

public class ColorLabelActionList : System.ComponentModel.Design.DesignerActionList
2. Adicionar um construtor a esta classe que leva uma instância do controle associado.
Fornecer um campo particular para manter uma referência a essa instância. Também
fornecer um campo particular para cache uma referência à DesignerActionService. Isso
será usado para atualizar a lista.
C#
private ColorLabel colLabel;
C#
private DesignerActionUIService designerActionUISvc = null;
C#
public ColorLabelActionList( IComponent component ) : base(component) { this.colLabel =
component as ColorLabel; // Cache a reference to DesignerActionUIService, so the //
DesigneractionList can be refreshed. this.designerActionUISvc =
GetService(typeof(DesignerActionUIService)) as DesignerActionUIService; }
3. Adicionar métodos e propriedades que você deseja associar aos itens de marcas
inteligentes. Métodos serão executados quando sua entrada de marca inteligente
correspondente é selecionada. Propriedades devem ter seções Getter para que seu valor
atual seja exibido; eles opcionalmente podem ter seções setter que use o GetProperties
método se seus valores tiverem que ser editável da entrada de marca inteligente
correspondente.
Observação
Como é o caso em todo o ambiente Design-time, uma propriedade é capaz de sendo editados
somente se um dos tipos base é fornecida pelo .NET Framework, o tipo pode ser convertido em
um tipo base por um fornecido TypeConverter, ou quando um personalizado UITypeEditor é
fornecido.
C#
public Color ForeColor { get { return colLabel.ForeColor; } set {
GetPropertyByName("ForeColor").SetValue(colLabel, value); } }
C#
// Boolean properties are automatically displayed with binary // UI (such as a checkbox). public bool
LockColors { get { return colLabel.ColorLocked; } set {
GetPropertyByName("ColorLocked").SetValue(colLabel, value); // Refresh the list.
this.designerActionUISvc.Refresh(this.Component); } }
C#
public void InvertColors() { Color currentBackColor = colLabel.BackColor; BackColor = Color.FromArgb(
255 - currentBackColor.R, 255 - currentBackColor.G, 255 - currentBackColor.B); Color currentForeColor
= colLabel.ForeColor; ForeColor = Color.FromArgb( 255 - currentForeColor.R, 255 - currentForeColor.G,
255 - currentForeColor.B); }
4. Opcionalmente, implementar uma versão do GetSortedActionItems método para retornar

uma matriz de DesignerActionItem instâncias, onde cada item está associado a uma
propriedade ou método criado na etapa anterior a substituído. Faça isso para alterar a

ordem dos itens, categorizá-los, ou opcionalmente mostrá-las. A lista também pode incluir
estáticos itens, como títulos grupo lógico.
C#
public override DesignerActionItemCollection GetSortedActionItems() {
DesignerActionItemCollection items = new DesignerActionItemCollection(); //Define static section
header entries. items.Add(new DesignerActionHeaderItem("Appearance")); items.Add(new
DesignerActionHeaderItem("Information")); //Boolean property for locking color selections.
items.Add(new DesignerActionPropertyItem("LockColors", "Lock Colors", "Appearance", "Locks the
color properties.")); if (!LockColors) { items.Add(new DesignerActionPropertyItem("BackColor",
"Back Color", "Appearance", "Selects the background color.")); items.Add(new
DesignerActionPropertyItem("ForeColor", "Fore Color", "Appearance", "Selects the foreground
color.")); //This next method item is also added to the context menu // (as a designer verb).
items.Add(new DesignerActionMethodItem(this, "InvertColors", "Invert Colors", "Appearance",
"Inverts the fore and background colors.", true)); } items.Add(new
DesignerActionPropertyItem("Text", "Text String", "Appearance", "Sets the display text.")); //Create
entries for static Information section. StringBuilder location = new StringBuilder("Location: ");
location.Append(colLabel.Location); StringBuilder size = new StringBuilder("Size: ");
size.Append(colLabel.Size); items.Add(new DesignerActionTextItem(location.ToString(),
"Information")); items.Add(new DesignerActionTextItem(size.ToString(), "Information")); return
items; }
Para atualizar a classe Designer associada para implementar a propriedade ActionLists

1. Localize a classe Designer para o controle. Se um não existir, crie uma classe designer e
associá-la para a classe de controle. Para obter mais informações sobre designers,
consulte Base classes do criador.
2. Como uma técnica de otimização, adicionar um campo particular do tipo
DesignerActionListCollection.
C#
private DesignerActionListCollection actionLists;
3. Adicionar a propriedade substituída ActionLists para retornar uma nova instância da

classe ColorLabelActionList que você criou anteriormente.
C#
public override DesignerActionListCollection ActionLists { get { if (null == actionLists) { actionLists =
new DesignerActionListCollection(); actionLists.Add( new ColorLabelActionList(this.Component)); }
return actionLists; } }
Comentários
Várias áreas do código merece uma explicação mais detalhada:
• Quando uma propriedade ou método na classe derivada de DesignerActionList

Alterações o estado do controle associado, essas alterações não devem ser feitas por
chamadas setter direta para propriedades do componente. Em vez disso, essas alterações
devem ser feitas através de adequadamente criado PropertyDescriptor um. Essa abordagem
indireta garante que desfazer de marcas inteligentes e UI atualize função ações corretamente.
• Dinamicamente você pode atualizar o painel de marca inteligente, chamando
System.ComponentModel.Design.DesignerActionUIService.Refresh(System.ComponentModel.
IComponent). Este processo pode ser usado para alterar dinamicamente o conteúdo do painel

de marca inteligente. No exemplo, as marcas inteligentes referentes ao alterar as cores são
condicionalmente incluídas de acordo com o estado da propriedade LockColors. Esta
propriedade Boolean também é associada a uma marca inteligente, portanto, o desenvolvedor
pode bloquear ou desbloquear a seleção de cores atual, pelo menos através do menu.
• Opcionalmente, uma entrada de tipo DesignerActionMethodItem de marca inteligente
pode ser incluída no menu de atalho para o controle associado, definindo o
includeAsDesignerVerb parâmetro no construtor para true. O.NET Framework implicitamente
cria um correspondente DesignerVerb e adiciona-ao menu de atalho para você. Neste
exemplo, o InvertColors item é tratado dessa maneira.
• Itens de marcas inteligentes são agrupados em um painel pela sua Category Propriedade,
que é definida no construtor para cada item. Se essa propriedade for não explicitamente
definida, ele é atribuído à categoria padrão. Cada item é ordenada no painel de marca
inteligente por categoria, depois pela ordem da ocorrência na matriz DesignerActionItem
retornado pela classe derivada da DesignerActionList classe. Este exemplo contém duas
categorias: Appearance e Information.
Observação
Não DesignerActionHeaderItem é fornecido para a segunda categoria.
• Uma entrada que exibe informações texto estático pode ser implementada usando um
DesignerActionTextItem ou um DesignerActionPropertyItem cujos associada propriedade
contém apenas um setter. Este exemplo usa a primeira abordagem.
Próximas etapas
Depois que você ter iniciado integrar o componente para o ambiente em tempo de design,
considere expandir o suporte de designer.
• Adicionar atributos a seu membros para facilitar a comunicação com o ambiente em tempo
de design. Para obter mais informações, consulte Atributos do Windows Forms controles.
• Gravar sua próprias designer personalizado. Para obter mais informações, consulte
COMO: Criar um controle de formulários do Windows que tira vantagem de recursos em tempo
de criação.
Passo-a-passo: Alterando a Mensagem SOAP Usando Extensões SOAP
Extensões SOAP pode ser inserido para a mensagem SOAP .NET Framework processamento
canal para modificar ou verificar uma mensagem de solicitação ou resposta SOAP enquanto ele
está sendo serializado ou desserializado, na Web em serviço ou cliente. Este tópico passo a
passo mostra como criar e executar uma extensão SOAP. Para uma figura de como extensões
SOAP funcionam,, bem como a ordem na qual SOAP métodos extensão são chamados no canal
de processamento de mensagem, consulte Modificação de mensagens SOAP usando extensões
SOAP.
Durante essa explicação passo a passo, você aprender como:
• Derivar de SoapExtension uma classe.

• Salvar referências para os Stream objetos que representam futuras mensagens SOAP
antes e depois a extensão SOAP tenha feito seu processamento.
• Inicializar dados específicos extensão SOAP.
• Processar mensagens SOAP durante o aplicável SoapMessageStage ou estágios.

Configurar a extensão SOAP a ser executada com métodos de serviço da Web específicos.
Pré-requisitos
Derivar de SoapExtension uma classe.
A classe que deriva de SoapExtension é a classe que executa a funcionalidade da extensão

SOAP. Isto é, se a extensão SOAP é uma criptografia extensão SOAP, então a classe que deriva
da classe SoapExtension executará a criptografia e descriptografia correspondente.
Salvar referências a objetos fluxo Representing mensagens SOAP futuros
Para modificar uma mensagem SOAP, você precisará obter uma referência ao fluxo que pode ser
usada para obter o conteúdo de futuras mensagens SOAP. Sua única oportunidade para obter
essa referência é para substituir o ChainStream método.
Para salvar referências a objetos fluxo representando SOAP futuras mensagens
1. Substituir o ChainStream método.

O ChainStream método tem a assinatura a seguir:
C#
public virtual Stream ChainStream(Stream stream)
2. Na ChainStream implementação, atribuir a Stream instância passado como um parâmetro.

Uma referência ao é passada para a ChainStream vez, antes de qualquer
SoapMessageStage. um Stream Isto Stream se refere ao XML da mensagem SOAP
depois extensões SOAP de prioridade mais baixa (consulte Configurar a extensão SOAP
para executar com métodos de serviço da Web para detalhes sobre prioridades extensão
SOAP) ter executado e suas alterações feitas a mensagem SOAP. Uma extensão SOAP
deve atribuir essa referência para um variável de membro para posterior acesso durante
quando uma extensão SOAP inspeciona ou modifica a mensagem SOAP. o
SoapMessageStage
O Stream deve modificar uma extensão SOAP. passada para ChainStream, no entanto,
não é o Stream
3. Na ChainStream implementação, instanciar um novo Stream, salvar uma referência a ele
em um variável de membro particular, e retornar a referência.
O exemplo a seguir demonstra uma implementação do método ChainStream comuns.
Para obter um exemplo de uma implementação do método ChainStream, comuns Consulte Como
implementar o método ChainStream para salvar referências a objetos do fluxo:.
Inicializar dados específicos extensão SOAP
A classe que deriva de SoapExtension tem dois métodos para inicializar dados, GetInitializer e
Initialize.
Agora que a infra-estrutura ASP.NET chama o GetInitializer método, e os parâmetros são

passados para o método, dependem do modo como a extensão SOAP é configurado. (See SOAP
Message Modification Using SOAP Extensions and Configure the SOAP Extension to Run with
Web Service Methods.
Para inicializar dados quando a extensão SOAP é configurada usando um atributo

1. Implementar o GetInitializer método usando a assinatura a seguir:
C#
public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute
attribute)
O LogicalMethodInfo fornece detalhes protótipo sobre o método de serviço da Web, como o

número de parâmetros e seus tipos de dados.
2. Se necessário, chame o Initialize método, passando o objeto retornado pela GetInitializer.
Para muitas SoapExtension implementações, o Initialize método pode ser deixado vazio.
Ao inicializar dados quando a extensão SOAP é configurado em um arquivo de configuração
1. Implementar o GetInitializer método com a assinatura a seguir:

C#
public override object GetInitializer(Type WebServiceType)
O Type parâmetro é o tipo da classe da classe que implementa o serviço da Web.

2. Se necessário, chame o Initialize método, passando o objeto retornado pela
GetInitializer. Para muitas SoapExtension implementações, o Initialize método pode ser
deixado vazio.
Para obter um exemplo de como inicializar dados quando uma extensão SOAP é configurado em
cache Consulte, Em cache Initialize dados quando uma extensão SOAP é configurado como:.
Processar o mensagens SOAP
A classe derivada de SoapExtension, no pedaço principais de implementação é o

ProcessMessage método. Este método é chamado várias vezes pelo ASP.NET em cada um dos
estágios definido na SoapMessageStage enumeração.
Para processar mensagens SOAP
• Implementar o método Abstract ProcessMessage.

A implementação do método ProcessMessage a seguir rastreia uma chamada para um
serviço da Web. Durante o rastreamento, os parâmetros ter sido serializado para XML, o XML
é gravado em um arquivo. Se indica o SoapMessageStage
C#
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case
SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: // Write the SOAP
message out to a file. WriteOutput( message ); break; case SoapMessageStage.BeforeDeserialize: // Write
the SOAP message out to a file. WriteInput( message ); break; case SoapMessageStage.AfterDeserialize:
break; default: throw new Exception("invalid stage"); } }
Configurar a extensão SOAP para executar com métodos Serviço da Web
Uma extensão SOAP pode ser configurado para ser executado usando um atributo personalizado
ou por modificar um arquivo de configuração. Um atributo personalizado é aplicada a um método
de serviço da Web. Quando um arquivo de configuração é usada, a extensão SOAP é executada
com os serviços da Web no escopo do arquivo de configuração. Para obter detalhes sobre como
arquivos de configuração funcionam, consulte Configurando aplicativos.

Para configurar uma extensão SOAP usando um atributo personalizado
1. Derivar de SoapExtensionAttribute uma classe.

2. Implementar duas propriedades de SoapExtensionAttribute: ExtensionType e Priority.
Uma extensão SOAP deve retornar o tipo da extensão SOAP na propriedade
ExtensionType. A Priority propriedade representa a prioridade relativa da extensão SOAP,
conforme explicado na aplicando o grupo prioridade na mensagem SOAP usando
extensões SOAP modificação.
3. Aplicar o atributo personalizado a cada método de serviço da Web desejado seja
executado com a extensão SOAP.
Para configurar uma extensão SOAP em um arquivo de configuração
1. Se ele estiver não estiver presente, adicione um soapExtensionTypes elemento XML

para a webServices seção do arquivo apropriado App.config ou Web.config.
2. Dentro do soapExtensionTypes elemento XML, adicionar um add elemento XML para
cada extensão SOAP que deve ser executado com cada serviço da Web no escopo do
arquivo de configuração.
O add elemento XML tem as seguintes propriedades.
o Tipo: Especifica o tipo da extensão SOAP e montagem ele reside em.
o Prioridade: especifica a prioridade relativa da extensão SOAP dentro de seu grupo.
o Grupo: Especifica o grupo uma extensão SOAP é um membro da.
Passo-a-passo: Construindo um XML Web Service Básico Usando ASP.NET
Desenvolver um serviço XML da Web usando o ASP.NET inicia com as seguintes etapas:
1. Criar um arquivo com um extensão de nome de arquivo.asmx e declarar um serviço da

Web dentro dela usando uma diretiva @WebService
2. Criar uma classe que implementa o serviço da Web. A classe opcionalmente pode derivar
a partir da WebService classe.
3. Opcionalmente, aplicar o WebServiceAttribute atributo a classe implementar o serviço da
Web.
4. Definir os métodos do serviço da Web que compõem a funcionalidade do serviço da Web.
Declarar um serviço da Web
Quando você cria um serviço XML da Web no ASP.NET, você posicione a diretiva necessário @
WebService na parte superior de um arquivo de texto com um extensão de nome de
arquivo.asmx. A presença do arquivo.asmx e a @ WebService diretiva correlacionar o endereço
URL do serviço da Web XML com sua implementação. Em seguida, você implementar a classe
serviço XML da Web que define os métodos e tipos de dados visível por clientes serviço XML da
Web. Finalmente, você adicionar seu lógica serviço XML Web a esses métodos para processar
solicitações de serviço XML Web e enviar respostas back. A classe serviço XML da Web você
definir podem ser incluídos diretamente no arquivo.asmx, ou em um arquivo separado. Se você
usar um arquivo separado, ele deve ser compilado em um conjunto. Opcionalmente, você pode
aplicar um WebService atributo para a classe implementar o serviço XML da Web. A classe que
implementa o serviço XML da Web pode derivar a partir da WebService classe.
Para declarar um serviço da Web cuja implementação reside no mesmo arquivo

• Adicionar uma @ WebService diretiva a parte superior de um arquivo com um extensão
de nome de arquivo.asmx, especificando a classe que implementa o serviço da Web e a
linguagem de programação que é usada na implementação.
O Class atributo pode ser definido para uma classe que reside no mesmo conjunto de módulos
(assembly) como a @ WebService diretiva ou para uma classe em um conjunto separado. Se
a classe residir em um conjunto separado, ele deve ser colocado no diretório \Bin no aplicativo
da Web onde o serviço da Web reside. O Language atributo pode ser definida, a C#, VB e JS,
quais se referem a C#, Visual Basic. NET, e JScript. NET, respectivamente.
O exemplo de código a seguir define o Language atributo da diretiva, e @ WebService Define
o Class atributo para Util, que reside no mesmo arquivo.
C#
<%@ WebService Language="C#" Class="Util" %>
Para declarar um serviço da Web cuja implementação reside em um conjunto
• Adicionar uma @ WebService diretiva a parte superior de um arquivo com uma

extensão.asmx, especificando a classe que implementa o serviço da Web, conjunto que
contém a implementação, e a linguagem de programação que é usada na implementação. Se
você usar um arquivo separado, ele deve ser compilado em um conjunto.
A diretiva a seguir @ WebService é a única linha em um arquivo com a extensão.asmx,
especificando que a MyName.MyWebService classe reside no conjunto MyAssembly dentro da
pasta \Bin do aplicativo da Web que está hospedando o serviço da Web.
C#
<%@ WebService Language="C#" Class="MyName.MyWebService,MyAssembly" %>
Observação
Se você não especificar um conjunto da @ WebService diretiva, então ASP.NET pesquisará pela
lista de conjuntos de módulos (assemblies) no diretório \Bin do aplicativo da Web que está
hospedando a hora do serviço na primeira Web o serviço da Web é acessada. Portanto, você
melhora o desempenho para o primeiro acesso, fornecendo o nome conjunto.
Derivar da classe WebService
Classes que implementam uma Web Serviço que foi criado usando o ASP.NET podem
opcionalmente derivar a partir da WebService classe para obter acesso a objetos ASP.NET
comuns, tais como Aplicativo, Sessão a, Usuário. e Contexto
Para derivar a partir da classe WebService e acessar ASP.NET comuns objetos
C#
<%@ WebService Language="C#" Class="Util" %> using System; using System.Web.Services; public class
Util: WebService
Aplicar o atributo WebService
Aplicar o atributo opcional WebService a uma classe que implementa um serviço da Web para
definir o padrão namespace para XML para o serviço da Web, que originalmente é
http://tempuri.org, juntamente com uma seqüência para descrever o serviço da Web.

É altamente recomendável que este espaço para nome padrão, que é http://tempuri.org, ser
alterado antes do XML Web Service seja feita publicamente consumo. This is important because
the XML Web service must be distinguished from other XML Web services that might inadvertently
use the namespace as the default (<http://tempuri.org/>).
Para definir o namespace para XML do qual um serviço da Web é um membro
• Aplicar um WebService atributo à classe que é implementar o serviço da Web, a

configuração da Namespace propriedade.
O exemplo de código a seguir define o namespace para XML para http://www.contoso.com/.
C#
<%@ WebService Language="C#" Class="Util" Debug=true%> using System.Web.Services; using System;
[WebService(Namespace="http://www.contoso.com/")] public class Util: WebService
Definindo métodos Serviço da Web
Métodos de uma classe que implementa uma Web não serviço fazer tem automaticamente a
capacidade de ser comunicadas com através da Web, mas com serviços da Web criados com
ASP.NET, é muito simples para adicionar esse recurso. Para adicionar esse recurso, aplique um
WebMethod Atributo ao métodos públicos. Métodos de um serviço da Web que pode ser
comunicadas com através da Web são chamados métodos Serviço da Web.
Para declarar um método de serviço da Web
1. Adicionar métodos públicos para a classe que é implementar o serviço da Web.

2. Aplicar o WebMethod atributo aos métodos pública que você deseja ser mapeados para
operações de serviço da Web.
O exemplo de código a seguir tem dois métodos públicos, um dos quais é um método de serviço
da Web. O Multiply método é um método de serviço da Web, porque ele tem um WebMethod
Atributo aplicado a ele.
C#
<%@ WebService Language="C#" Class="Util" %> using System.Web.Services; using System;
[WebService(Namespace="http://www.contoso.com/")] public class Util: WebService { [ WebMethod]
public long Multiply(int a, int b) { return a * b; } }
Passo-a-passo: Personalização para Dispositivos Específicos
Uma das vantagens de usar o criador Mobile ASP.NET é a capacidade para criar aplicativos que
se beneficiam dos recursos e considerações especiais para exibir conteúdo em seus dispositivos
de destino. Filtros dispositivo, técnicas templating, e propriedade recursos de substituição no
designer permitem que você pode personalizar seu aplicativo para processar controles de maneira
diferente para tipos de dispositivo específico. O seguinte conjunto de procedimentos leva você
durante o processo de criação de modelos e sobrescrever propriedades para um controle.
Nessa explicação passo a passo, você será adicionar um List controle a um formulário, definir um
filtro do dispositivo para uso com esse controle, aplicar o filtro para o controle, editar os modelos
para o controle, e aplique sobrescrever propriedades para o filtro do dispositivo.

Você pode executar as ações a seguir para qualquer controle que ofereça suporte modelos. Este
exemplo usa o List controle.
Para selecionar um filtro do dispositivo

1. Arraste o List controle de ou Panel controle em uma página móvel formulários da Web
ASP.NET. para a Toolbox uma Form
2. Selecione o controle, e no menu de atalho, escolha Templating Options. A Templating
Options caixa de diálogo será exibida.
3. Na lista Applied Device Filter drop-down, escolha o filtro do dispositivo que você deseja
configurar. Se você desejar editar a associar modelos com este filtro, clique no Close botão
e siga as etapas no Criando e editando modelos. Se o filtro que você deseja usar não
estiver na lista, clique no Edit botão para adicionar filtros para a lista de filtros do dispositivo
aplicado. Isso abrirá a Aplicado filtros do dispositivo caixa de diálogo.
4. Se você precisa para criar um novo filtro, clique no Edit botão. Na caixa Editor de filtro do
dispositivo de diálogo, faça o seguinte:
1. Clique no New Device Filter botão.
2. Digite o nome para o novo filtro; por exemplo, SmallDevice.
3. Defina a Tipo opção.
4. Definir do filtro Atributos. Se você estiver usando um filtro de comparação de
igualdade, você precisará especificar o atributo para comparar e o valor de
comparação. Se o filtro for um filtro de representante avaliador, especifique seu tipo e
método.
5. Do Up Arrow uso e Down Arrow Botões para definir a ordem na qual os filtros do
dispositivo são salvos no arquivo de configuração (web.config) do aplicativo.
6. Clique OK para salvar os filtros do dispositivo no arquivo de configuração do
aplicativo e fechar a Device Filter Editor caixa de diálogo.
5. Use a Available Device Filters Lista suspensa para selecionar o filtro do dispositivo ou
filtros que você deseja usar. A Available Device Filters lista mostra todos os filtros do
dispositivo definidos no nível do aplicativo.

6. Clique no Add to List botão. O filtro dispositivo selecionado é agora parte da lista Applied
Device Filters e pode ser usado para criar modelos.
7. No campo Argument, opcionalmente, digite em um valor para o argumento a ser usado
para o filtro de aplicado dispositivo selecionado. Para obter mais informações, consulte
Aplicar Filtros do dispositivo.
8. Do Up Arrow uso e Down Arrow Botões para ordenar os filtros aplicados do dispositivo.
Em tempo de execução, os filtros são testados um por um da parte superior à parte inferior.
O primeiro filtro que resulta em uma avaliação êxito do dispositivo determina quais modelos
serão usados.
Observação
O filtro aplicado do dispositivo denominado (Default) sempre resulta em uma avaliação com êxito.
Se estiver presente, este filtro bloqueia todas as outras avaliações abaixo na lista. Portanto, ela
deverá, logicamente aparecer como o último filtro do dispositivo na lista Applied Device Filters
drop-down. O (Default) filtro depois captura cada dispositivo que não corresponde a nenhum dos
filtros acima na lista. Para obter mais informações, consulte Introdução ao dispositivo filtros.
9. Clique OK para fechar a Applied Device Filters caixa de diálogo.
Agora a Templating Options caixa de diálogo está aberta, e você pode selecionar o filtro do
dispositivo que você deseja usar para editar os modelos.
Para definir opções templating
1. Use a Applied Device Filters lista para selecionar o filtro do dispositivo que você deseja
usar para editar os modelos.
2. Selecione um esquema de marcação. Nesse caso, para criar modelos para dispositivos de
destino esse navegador use um HTML, selecione Mobile HTML3.2 Template (esse é o
padrão).
Observação
As informações especificadas no campo Markup Schema é usado somente pelo designer e não
tem efeito em tempo de execução. O esquema fornecerá corretos IntelliSense Microsoft e sintaxe
check in Modo HTML.
3. Clique Close para fechar a Templating Options caixa de diálogo.
Agora o controle selecionado está pronto para modelo modo edição. Cada controle pode definir
vários modelos. Por exemplo, o List controle define os seguintes modelos:
• Modelo de cabeçalho
• Modelo rodapé
• Item template
• Modelo AlternatingItem
• Modelo separador
Para editar o modelo

1. Para este exemplo, selecione Edit Template no menu de atalho e depois escolha Header
and Footer Templates. Do Header Template o List controle na sua formulários da Web
móveis página exibe e Footer Template caixas.
2. Opcionalmente, digite texto literal para o cabeçalho na caixa Header Template, e para o
rodapé na caixa Footer Template . Como alternativa, você pode arrastar controles de ou
Footer Template caixas., como um Label controle, para o Toolbox, o Header Template
3. Selecione Item TemplatesEdit Template no menu de atalho. O List controle na sua
página de formulários da Web móvel exibe o modelo item e o modelo AlternatingItem. Se
você editar o modelo AlternatingItem, por exemplo, pode definir plano de fundo de itens
alternadas para ser uma cor diferente:
1. Você pode arrastar um controle de e configure as propriedades de controle que. tal
um Label controle, para o modelo item, o Toolbox, Por exemplo, você pode definir a
ForeColor propriedade com a cor que você deseja para o item texto ou o primeiro. e
cada indefinido item depois disso, se você também definir um modelo AlternatingItem
2. Você pode arrastar um controle de e configure as propriedades de controle que. tal
um Label controle, para o modelo AlternatingItem, o Toolbox, Por exemplo, você
pode definir a ForeColor propriedade com a cor que você deseja para o texto do
segundo item e cada item mesmo depois disso.
4. A partir do menu de atalho, selecione Edit Template, e escolha Separator Template. O
List controle na sua página de formulários da Web móvel exibe o modelo separador para
edição. Adicione conteúdo ou um controle para o modelo separador seguindo um destes
procedimentos:
o Type in a string of characters that you want to use for an item separator; for
example, hyphens (----------).
o Arraste um Image controle para o modelo e especifique um arquivo gráfico da Web
a ser usado como o separador item. Vincular a um arquivo gráfico do separador que você
deseja usar, utilizando a ImageUrl propriedade do controle Image.
5. Quando você tiver terminado, selecione End Template Editing no menu de atalho.
Para aplicar propriedade substitui para um filtro dispositivo específico
1. Na caixa Property Overrides de diálogo, o Applied Device Filter posicionamento em-

Para Baixo lista, clique no filtro do dispositivo que você deseja aplicar; por exemplo,
isHTML32.
2. Agora a Property Overrides caixa de diálogo mostra as propriedades que você pode
substituir. Configurar quaisquer propriedades que você deseja alterar para que o Applied
Device Filter esteja exibido na parte superior da caixa de diálogo.
A geração de descrição do serviço e classes proxy de um serviço da Web criados com ASP.NET
pode ser estendido por meio da criação e instalação de um extensão do formato da descrição do
serviço (SDFE). Especificamente, um SDFE pode adicionar elementos XML para o — descrição
do serviço o documento Descrição Serviços Web WSDL (linguagem para um serviço — da Web e
adicionar atributos personalizados para um método comunicação com um serviço da Web.
SDFEs são especialmente úteis quando uma extensão SOAP deve executar com um serviço da
Web e seus clientes; por padrão, sem informações sobre extensões SOAP são colocadas no
descrição do serviço ou proxy classes gerado para ele. Um exemplo de uma extensão SOAP que
devem executados no cliente e servidor é uma criptografia extensão SOAP. Se uma criptografia
extensão SOAP é executada no servidor para criptografar a resposta SOAP, o cliente deve ter a
extensão SOAP executando para descriptografar a mensagem. Um SDFE pode adicionar

elementos ao descrição do serviço para informar aos clientes que uma extensão SOAP deve
executar, e o SDFE pode estender o proxy classe processo geração para adicionar um atributo
personalizado para a classe proxy, que faz com a classe para executar a extensão SOAP.
Durante essa explicação passo a passo, você aprender como:
1. Definir o XML para adicionar ao descrição do serviço.

2. Criar uma classe SDFE por derivar a partir da ServiceDescriptionFormatExtension classe.
3. Escrever código para estender o processo de geração descrição do serviço.
4. Gravar código para estender o proxy classe processo geração.
5. Configurar o SDFE para executar em tanto o cliente e servidor.
Definir o XML e criar a classe SDFE
Os exemplos de código nessa explicação passo a passo envolver uma classe

ServiceDescriptionFormateExtension YMLOperationBinding para uma classe SoapExtension
YMLExtension. O código completo aparece no tópico How to personalizar as descrições do
serviço geração e classes proxy (código de exemplo).:
Para definir o XML para adicionar ao descrição do serviço
1. Decidir sobre o XML para adicionar ao descrição do serviço.

O exemplo de código a seguir é a parte de um descrição do serviço para que o exemplo
SDFE adiciona elementos XML. Especificamente, o exemplo SDFE declara um prefixo yml
namespace para XML do elemento raiz definitions de um documento WSDL, e aplica que
apareçam na ligação operation elementos espaço para nome para o yml:action elemento (e
elementos filho).
<definitions ... xmlns:yml="http://www.contoso.com/yml" > ... <binding name="HelloWorldSoap"
type="s0:HelloWorldSoap"> <soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" /> <operation name="SayHello"> <soap:operation
soapAction="http://tempuri.org/SayHello" style="document" /> <yml:action>
<yml:Reverse>true</yml:Reverse> </yml:action> </operation> ... </binding> ... </definitions>
2. Criar uma classe que deriva de ServiceDescriptionFormatExtension.

Ao usar Visual Studio. NET, adicione uma referência ao conjunto System.Web.Services .
Também adicionar ou Imports instrução para espaço para nome
System.Web.Services.Description para o arquivo. um using
O exemplo de código a seguir cria a YMLOperationBinding classe, que deriva de
ServiceDescriptionFormatExtension.
C#
public class YMLOperationBinding : ServiceDescriptionFormatExtension
3. Aplicar à classe. um XmlFormatExtensionAttribute

Este atributo especifica a etapa do processo de geração descrição do serviço, conhecido
como um ponto de extensão, no qual o SDFE executa. A tabela a seguir lista os pontos de
extensão definido e os elementos XML WSDL gerado durante cada ponto. Para o ponto de
extensão especificado, o elemento WSDL correspondente ficará o pai do elemento sendo
adicionado.
Ponto de extensão Descrição

ServiceDescription Corresponde ao elemento raiz definitions de um documento WSDL.
Types Corresponde ao elemento types delimitados pelo elemento raiz definitions.
Binding Corresponde ao elemento binding delimitados pelo elemento raiz

definitions.
OperationBinding Corresponde ao elemento operation delimitados pelo binding elemento.
InputBinding Corresponde ao elemento input delimitados pelo operation elemento.
OutputBinding Corresponde ao elemento output delimitados pelo operation elemento.
FaultBinding Corresponde ao elemento fault delimitados pelo operation elemento.
Port Corresponde ao elemento port delimitados pelo service elemento.
Operation Corresponde ao elemento operation delimitados pelo portType elemento.
Ao aplicar para a classe, você também especificar o nome do elemento XML e o

namespace para XML para conter os elementos XML para adicionar ao descrição do
serviço. um XmlFormatExtensionAttribute
O exemplo de código a seguir especifica que o YMLOperationBinding SDFE adiciona um
elemento XML chamado <action xmlns="http://www.contoso.com/yml"> para o descrição do
serviço durante o OperationBinding ponto de extensão. Para esse exemplo, o
http://www.contoso.com/yml namespace para XML é especificado mais tarde quando o
YMLOperationBinding.YMLNamespace campo é adicionado à classe.
C#
[XmlFormatExtension("action", YMLOperationBinding.YMLNamespace, typeof(OperationBinding))]
public class YMLOperationBinding : ServiceDescriptionFormatExtension
4. Opcionalmente, aplicar à classe para associar o prefixo namespace para XML ao

namespace para XML usado pelo SDFE. um XmlFormatExtensionPrefixAttribute
O exemplo de código a seguir especifica que o yml prefixo namespace para XML é
associado ao espaço para nome http://www.contoso.com/yml no elemento definitions do
descrição do serviço. Além disso, o prefixo é usada em elementos adicionados pelo SDFE
em vez do espaço para nome. Portanto, o elemento XML adicionadas para o descrição do
serviço na etapa 3 agora usa o prefixo do espaço para nome e assim o elemento
adicionado é <yml:action> em vez de <action xmlns="http://www.contoso.com/yml">.
C#
[XmlFormatExtension("action", YMLOperationBinding.YMLNamespace, typeof(OperationBinding))]
[XmlFormatExtensionPrefix("yml", YMLOperationBinding.YMLNamespace)] public class
YMLOperationBinding : ServiceDescriptionFormatExtension
5. Adicionar propriedades públicas e / ou campos à classe que representa o XML a ser

adicionado ao documento WSDL. Exemplo de código a seguir adiciona uma Reverse
propriedade pública que é serializado em um <yml:Reverse>value</yml:Reverse> elemento no
WSDL.

C#
private Boolean reverse; [XmlElement("Reverse")] public Boolean Reverse { get { return reverse; } set
{ reverse = value; } }
Estendendo a geração da descrição serviço e Proxy Client
Para estender o processo de geração WSDL, derivar uma classe a partir da

SoapExtensionReflector classe. Para estender a geração de proxy cliente processo, derivar uma
classe a partir da SoapExtensionImporter classe.
Para estender o processo de geração descrição do serviço
1. Criar uma classe que deriva de SoapExtensionReflector.

O exemplo de código a seguir cria a TraceReflector classe, que deriva de
SoapExtensionReflector.
C#
public class YMLReflector : SoapExtensionReflector
2. Substituir o ReflectMethod método, que é denominado durante a geração descrição do

serviço para cada método de serviço da Web.
O seguinte código exemplo substitui o ReflectMethod.
C#
public override void ReflectMethod()
3. Obter o valor da propriedade ReflectionContext da classe SoapExtensionReflector para

obter uma instância do ProtocolReflector.
A instância do ProtocolReflector fornece detalhes sobre o processo de geração WSDL para
o método de serviço da Web atual. . O exemplo de código a seguir obtém o valor da
propriedade ReflectionContext
C#
ProtocolReflector reflector = ReflectionContext;
4. Adicione código para preencher o SDFE.

O exemplo de código a seguir adiciona o XML definidos pelo SDFE para o descrição do
serviço se for aplicado a um método de serviço da Web. o YMLAttribute
C#
YMLAttribute attr = (YMLAttribute) reflector.Method.GetCustomAttribute(typeof(YMLAttribute)); //
If the YMLAttribute has been applied to this Web service // method, adds the XML defined in the
YMLOperationBinding class. if (attr != null) { YMLOperationBinding yml = new
YMLOperationBinding(); yml.Reverse = !(attr.Disabled);
5. Adicionar o SDFE à coleção Extensions da propriedade que representa o ponto de

extensão a SDFE é estender.
O exemplo de código a seguir adiciona o YmlOperationBinding SDFE até o
OperationBinding ponto de extensão.
C#
reflector.OperationBinding.Extensions.Add(yml);
Para estender o proxy geração classe processar

1. Criar uma classe que deriva de SoapExtensionImporter.
C#
public class YMLImporter : SoapExtensionImporter
2. Substituir o ImportMethod método.

O ImportMethod é chamado durante a geração de classe para cada operação definido em
um descrição do serviço proxy. Cada método de serviço da Web de serviços da Web
criados com ASP.NET, mapeia para uma operação para cada protocolo com suporte no
descrição do serviço.
C#
public override void ImportMethod(CodeAttributeDeclarationCollection metadata)
3. Obter o valor da propriedade ImportContext do SoapExtensionImporter para obter uma

instância do SoapProtocolImporter.
A instância do SoapProtocolImporter fornece detalhes sobre o processo de geração de
código para o método atual se comunicar com um método de serviço da Web. O exemplo
de código a seguir obtém o valor da propriedade ImportContext.
C#
SoapProtocolImporter importer = ImportContext;
4. Adicione código para aplicar ou modificar atributos para um método na classe proxy que
está se comunicando com um serviço da Web.
O ImportMethod passagens no um argumento de tipo CodeAttributeDeclarationCollection,
que representa a coleção de atributos que são aplicados para o método que se comunica
com a Web Serviço método. O exemplo de código a seguir adiciona à coleção, que faz com
a YML extensão SOAP a executar com o método quando o descrição do serviço contém o
XML apropriado. um YMLAttribute
C#
// Checks whether the XML specified in the YMLOperationBinding is // in the service description.
YMLOperationBinding yml = (YMLOperationBinding) importer.OperationBinding.Extensions.Find(
typeof(YMLOperationBinding)); if (yml != null) { // Only applies the YMLAttribute to the method
when the XML should // be reversed. if (yml.Reverse) { CodeAttributeDeclaration attr = new
CodeAttributeDeclaration(typeof(YMLAttribute).FullName); attr.Arguments.Add(new
CodeAttributeArgument(new CodePrimitiveExpression(true))); metadata.Add(attr); } }
Configurando o SDFE
Para configurar o SDFE requer editar arquivos de configuração no serviço da Web e cliente.
Para configurar o SDFE para executar com um serviço da Web
1. Instalar o conjunto que contém o SDFE em uma pasta acessível.

A menos que o SDFE seja necessária para vários aplicativos da Web, instale o SDFE na
pasta \Bin do aplicativo da Web que hospeda o serviço da Web.
2. Adicione um < serviceDescriptionFormatExtensionTypes > elemento com um add
elemento e especifique o nome e conjunto que contém o SDFE para o arquivo web.config
para o aplicativo da Web.
O exemplo de código a seguir configura o Sample.YMLOperationBinding SDFE seja
executado com os serviços da Web afetados pela no arquivo web.config. O elemento
completa add deve estar em uma linha.

<system.web> <webServices> <serviceDescriptionFormatExtensionTypes> <add
type="Sample.YMLOperationBinding,Yml, Version=1.0.0.0,Culture=neutral,
PublicKeyToken=6e55c64c6b897b30"/> </serviceDescriptionFormatExtensionTypes>
</webServices> </system.web>
3. Adicione um <soapExtensionReflectorTypes> Element elemento com um add elemento e

especifique o nome e montagem da classe que estende o processo de geração descrição
do serviço para o arquivo web.config para o aplicativo da Web.
O exemplo de código a seguir configura para executar com os serviços da Web afetados
pela no arquivo web.config. o Sample.YMLReflector O elemento completa add deve estar em
uma linha.
<soapExtensionReflectorTypes> <add type="Sample.YMLReflector,Yml,
Version=1.0.0.0,Culture=neutral, PublicKeyToken=6e55c64c6b897b30"/>
</soapExtensionReflectorTypes> </webServices> </system.web>
Para configurar o SDFE para executar com um cliente de serviços da Web
1. Instalar o conjunto que contém o SDFE no cache de conjunto de módulos global.

Para ser instalado, conjunto de módulos (assembly) deve ser de nome seguro. Para obter
detalhes sobre como criar um conjunto de nome seguro, consulte Criando e usando
conjuntos Named STRONG-. Para obter detalhes sobre como instalar conjuntos, consulte
Instalar um assembly no no cache do conjunto de módulos (assembly) global.
2. Adicione um <serviceDescriptionFormatExtensionTypes> Element elemento com um add
elemento e especifique o nome e conjunto que contém o SDFE para o arquivo
Machine.config.
O exemplo de código a seguir configura o Sample.YMLOperationBinding SDFE para executar
sempre que classes proxy são geradas para serviços da Web no computador.
</webServices> </system.web>
3. Adicionar um <soapExtensionImporterTypes> Element elemento com um add elemento e

especifique o nome e montagem da classe que estende o proxy classe processo geração
para o arquivo Machine.config.
O exemplo de código a seguir configura para executar sempre que classes proxy são
geradas para serviços da Web no computador. o Sample.YMLImporter
<soapExtensionImporterTypes> <add type="Sample.YMLImporter,Yml,
Version=1.0.0.0,Culture=neutral, PublicKeyToken=6e55c64c6b897b30"/>
</soapExtensionImporterTypes> </webServices> </system.web>
Observação

O método gerado na classe proxy é usado por um aplicativo cliente se comunicar com o serviço
da Web, caso se um SDFE adiciona um atributo que reside em um conjunto do qual o aplicativo
cliente não é notificado, um erro do compilador é gerado. Para resolver o erro do compilador,
adicionar uma referência ao conjunto que contém o atributo se usando Visual Studio. NET, ou
adicione montagem para a linha de comando do compilador se usando compilação de linha de
comando.
Passo-a-passo: Implantando um aplicativo ClickOnce manualmente
Essa explicação passo a passo descreve as etapas necessárias para criar uma implantação
completa ClickOnce usando a versão de linha de comando ou gráfica da ferramenta manifesto
geração e edição (Mage).
Se você não usar o Visual Studio regularmente, precisar para automatizar o processo de
implantação, ou precisa para usar recursos de implantação avançadas, como confiáveis
Implantação de aplicativo, você deve usar a ferramenta de linha de comando Mage.exe para criar
seu ClickOnce manifestos. Explicação passo a passo o seguir leva você por todos os as etapas
necessárias para gerar uma implantação completa ClickOnce usando a versão de linha de
comando (Mage.exe) ou a versão do Windows Forms (MageUI.exe) do manifesto geração e
ferramenta de edição.
Pré-requisitos
Essa explicação passo a passo foram gravado sob a suposição que você tiver um aplicativo
Windows Forms que você está preparado para implantar; este aplicativo será chamado para de
WindowsFormsApp1. Você também deve instalar o .NET Framework Software Development Kit
(SDK).
Há uma série de questões você precisará decidir antes de criar uma implantação. Primeiro e
foremost é como você vai distribuir a implantação:. Web a fim de um compartilhamento de arquivo,
ou instalado logoff de um CD Para obter mais informações, consulte Visão geral sobre a
implantação do ClickOnce.
Em seguida, você precisará determinar se o aplicativo será executado em um nível elevado de

confiança. Aplicativos conforme discutido no Visão geral da implantação de aplicativos confiáveis,
por padrão ClickOnce será executado em uma zona parcialmente confiável, com suas permissões
exatos determinados pela se eles são hospedados em uma intranet ou da Internet. Se um
aplicativo precisa acessar dados no computador cliente, converse com dispositivos locais, chamar
funções da API do Windows, ou executar outras operações potencialmente perigosas, ele
precisará declarar um maior nível de confiança. Se o aplicativo requer confiança — Total por
exemplo, acesso total ao sistema — do usuário use Mage.exe para defini-la facilmente. Se você
quiser definir uma permissão personalizada definida para seu aplicativo, você pode copiar a seção
de permissão Internet ou intranet de outra manifesto, modificá-lo para atender às suas
necessidades, e adicioná-lo ao manifesto de aplicativo usando um editor de texto ou MageUI.exe
Os dois métodos para declarar confiança em um ClickOnce manifesto superior são elevação
permissão e confiáveis Implantação de aplicativo. Em ambos os casos, sua implantação deve ser
assinada com um certificado Autenticode gerados usando a ferramenta MakeCert.exe ou obtido
uma certificação autoridade (CA) de. Se você optar por usar confiáveis Implantação de aplicativo,
você também deve executar uma instalação única do certificado para todos os computadores
cliente. Para obter mais informações, consulte Visão geral da implantação de aplicativos
confiáveis.
Para implantar um aplicativo com a ferramenta de linha de comando Mage.exe

1. Abra um .NET Framework Prompt de comando SDK, e altere para o diretório em que você
irá armazenar os ClickOnce arquivos.
2. Crie uma subpasta chamada bin e coloque todos os seus arquivos do aplicativo Incluindo
arquivos executáveis, conjuntos, recursos, e arquivos de dados aqui,
3. Crie uma subpasta chamada após a versão atual do sua implantação. Se esta for a
primeira vez você estiver implantando o aplicativo, você provavelmente escolherá 1.0.0.0.
Observação
A versão da sua implantação pode estar distintas da versão dos arquivos do aplicativo.
4. Mover o diretório \bin para a pasta que você criou etapa 2.

5. Gerar manifesto de aplicativo com uma chamada para Mage.exe:
mage -New Application -ToFile 1.0.0.0\WindowsFormsApp1.exe.manifest -Name "Windows Forms
App 1" -Version 1.0.0.0 -FromDirectory 1.0.0.0\bin
6. Assinar manifesto de aplicativo com o certificado digital:

mage -Sign WindowsFormsApp1.exe.manifest -CertFile mycert.pfx
7. Gerar o manifesto de implantação com uma chamada para Mage.exe. Por padrão,
Mage.exe irá, marcar a implantação ClickOnce como um aplicativo instalado, para que ele
pode ser executado tanto online e offline. Para tornar o aplicativo disponível somente
quando o usuário está online, usar o -i Sinalizador com um valor de f. Se você usar o
padrão, e usuários irá instalar um aplicativo de um site da Web ou compartilhamento de
arquivo, certifique-se o valor dos pontos de sinalizador providerUrl para o local do manifesto
de aplicativo no servidor Web ou compartilhamento -.
mage -New Deployment -ToFile WindowsFormsApp1.application -Name "Windows Forms App 1" -
Version 1.0.0.0 -AppManifest 1.0.0.0\WindowsFormsApp1.manifest -providerUrl
http://www.adatum.com/WindowsFormsApp1/WindowsFormsApp1.application
8. Assinar o manifesto de implantação com o certificado:

mage -Sign WindowsFormsApp1.application -CertFile mycert.pfx
9. Copie todo dos arquivos na pasta — atual incluindo a pasta de versão e a pasta — \bin
para o destino de implantação. Isso pode ser qualquer uma pasta em um site da Web ou
FTP site, um compartilhamento de arquivo, ou um CD.
10. Fornecer os usuários com a URL, UNC ou mídia física necessária para instalar um
aplicativo. Se você está fornecendo um URL ou UNC, você deve atribuir os usuários o
caminho completo o manifesto de implantação. Por exemplo, caso WindowsFormsApp1
seja implantado para http://webserver01/ no diretório WindowsFormsApp1, o caminho
completo URL seria http://webserver01/WindowsFormsApp1/WindowsFormsApp1.Deploy.
Implantando o aplicativo com a ferramenta Gráfico MageUI.exe
1. Abra um .NET Framework Prompt de comando SDK, e navegue para a pasta em que você
irá armazenar os ClickOnce arquivos.
2. Crie uma subpasta chamada bin e coloque todos os seus arquivos do aplicativo Incluindo
arquivos executáveis, conjuntos, recursos, e arquivos de dados aqui.
3. Crie uma subpasta chamada após a versão atual do sua implantação. Se esta for a
primeira vez você estiver implantando o aplicativo, você provavelmente escolherá 1.0.0.0.

Observação
A versão da sua implantação pode estar distintas da versão dos arquivos do aplicativo.
4. Mover o: \ bin diretório para a pasta que você criou na etapa 2, e inicie a ferramenta
gráfica
MageUI.exe
5. Criar um novo manifesto de aplicativo, New selecionando File, Application Manifest. a

partir do menu
6. Na guia Padrão Name, digite o número dessa Implantação nome e versão.
7. Selecione a Files guia e clique no Browse... botão próximo à caixa de texto Diretório
aplicativo.
8. Selecione a pasta que contém os arquivos do aplicativo que você criou na etapa 2, e clique
OK na pasta Caixa de diálogo de seleção.
9. Clique no Populate botão para adicionar todos os arquivos do aplicativo à lista da arquivo.
Se seu aplicativo contém mais de um arquivo executável, marcar o arquivo executável
principal para essa implantação como o aplicativo de inicialização, selecionar Entry Point
na lista File Type drop-down. MageUI.exe (se seu aplicativo só contém um arquivo
executável, será marcá-la para você.)
10. Selecione a Permissions Required guia e selecione o nível de confiança você precisa seu
aplicativo para declarar. O padrão é Full Trust, que será adequado para a maioria dos
aplicativos.
11. Selecione File, Save no menu, e salve o manifesto de aplicativo. Você será solicitado para
assinar o manifesto de aplicativo quando você salvá-lo.
12. Se você tiver um certificado armazenado como um arquivo no seu sistema de arquivos,
use a Sign as certificate file opção, e selecione o certificado do sistema de arquivos
usando o ... botão.
Ou-
Se o certificado é mantido em um armazenamento de certificados acessível de sua
máquina, selecione e selecione o certificado na lista fornecida. o Sign with stored
certificate option,
13. Selecionar File, New, Deployment Manifest no menu para criar sua implantação
manifesto, e em seguida, na guia Name, forneça um nome e versão número, neste exemplo
(1.0.0.0).
14. Selecione a Publisher guia e fornecer valores para Publisher e Product. ( Product is the
name given your application on the Windows Start menu when you install your application
locally.)
15. Alterne para a Update guia, e especifique a freqüência você deseja este aplicativo para
atualizar. Se o aplicativo usa a ClickOnce API de implantação para verificar se há
atualizações propriamente dito, desmarque a caixa de seleção rotulada This application
should check for updates.
16. Alternar para a Application Reference guia. Você pode preencher todos os valores nesta
guia, clicando no Select Manifest botão e selecionando o aplicativo manifesto você criou
nas etapas anteriores.
17. Escolha Save e salvar o manifesto de implantação em disco. Você será solicitado para
assinar o manifesto de aplicativo quando você salvá-lo.

18. Se você tiver um certificado armazenado como um arquivo no seu sistema de arquivos,
use a Sign as certificate file opção, e selecione o certificado do sistema de arquivos
usando o ... botão.
Ou-
Se o certificado é mantido em um armazenamento de certificados acessível de sua
máquina, selecione e selecione o certificado na lista fornecida. o Sign with stored
certificate option,
19. Copiar todos os arquivos na pasta — atual, incluindo a pasta de versão e a pasta — para o
destino de implantação. \ bin Isso pode ser qualquer uma pasta em um site da Web ou FTP
site, um compartilhamento de arquivo, ou um CD.
20. Fornecer os usuários com a URL, UNC ou mídia física necessária para instalar um
aplicativo. Se você está fornecendo um URL ou UNC, você deve atribuir os usuários o
caminho completo o manifesto de implantação. Por exemplo, caso WindowsFormsApp1
seja implantado para http://webserver01/ no diretório WindowsFormsApp1, o caminho
completo URL seria http://webserver01/WindowsFormsApp1/WindowsFormsApp1.Deploy.
Próximas etapas
Quando você precisa implantar uma nova versão do aplicativo, precisará criar uma nova pasta
chamada após a nova versão — por exemplo, 1.1.0.0—and move the new application files into a
\bin pasta em que novo diretório. Você deve gerar um novo manifesto de aplicativo e armazene-
no novo diretório, e ter o editor assinar o novo manifesto. Após você obter o manifesto assinado
de volta, você pode usar Mage.exe para atualizar o manifesto de implantação e aponte-lo no novo
manifesto de aplicativo:
mage -Update WindowsFormsApp1.application -Version 1.1.0.0 -AppManifest

1.1.0.0\WindowsFormsApp1.exe.manifest
Usuários MageUI.exe podem efetuar a mesma operação, abrindo o seu manifesto de implantação,
selecione a Application Reference guia e selecionar o Select Manifest botão novamente.
Após atualizar o aplicativo manifesto referência, será necessário assinar novamente o manifesto
de implantação, como alterar um manifesto de alguma forma invalida a assinatura digital.
Passo-a-passo: Fazendo o Download de Assemblies por Demanda com a API de Implantação

do ClickOnce
Por padrão, todos os as montagens incluídas um ClickOnce aplicativo são descarregados quando
o aplicativo é executado primeiro. Você pode, entretanto, ter partes do seu aplicativo que são
usados por um pequeno conjunto de seus usuários. Nesse caso, você deseja baixar um conjunto
somente quando você cria um dos seus tipos. Explicação passo a passo o seguir demonstra como
para marcar determinados conjuntos em seu aplicativo como " OPCIONAL ", e como baixá-las
usando classes no espaço para nome System.Deployment.Application quando o Common
Language Runtime (CLR) exige-los.
Criar Projetos
Para criar um projeto usando um conjunto por demanda
1. Abra o .NET Framework Prompt de comando SDK.

2. Ao usar o Bloco de Notas ou outro editor de texto, definir uma classe chamada
DynamicClass com uma única propriedade chamada Message.
1. Salvar o texto como um arquivo denominado ClickOnceOnDemand.cs ou
ClickOnceOnDemand.vb, dependendo do idioma você usar.

2. Compile o arquivo em um conjunto. csc /target:library ClickOnceOnDemand.csvbc
/target:library ClickOnceOnDemand.vb
3. Crie um novo arquivo usando o editor de texto e insira o código a seguir, que cria um
aplicativo Windows Forms que baixa o conjunto ClickOnceOnDemand quando ele é
necessário.
1. Salve o arquivo como um Form1.cs ou Form1.vb. csc /target:exe
/reference:ClickOnceOnDemand.dll Form1.csvbc /target:exe /reference:ClickOnceOnDemand.dll
Form1.vb e compilá-lo em um executável
Marcando conjuntos como opcional
Para marcar conjuntos como opcionais em seu aplicativo ClickOnce usando o manifesto
geração e ferramenta de edição-cliente gráfico (MageUI.exe)
1. Crie seu ClickOnce manifestos conforme descrito em Passo-a-passo: Implantando um

aplicativo ClickOnce manualmente. Nome seu aplicativo ClickOnceOnDemand.
2. Antes de fechar MageUI.exe, selecione a guia contendo a implantação na manifesto de
aplicativo, e selecione a Files guia dentro desse guia.
3. Na guia Files Localizar OnDemandAssembly.dll na lista dos arquivos aplicativo e defina
sua File Type Coluna a None. Para a Group coluna, digite ClickOnceOnDemand.dll.
Teste o novo conjunto
Para testar seu conjunto por demanda
1. Carregar sua ClickOnce implantação em um servidor Web.

2. Iniciar seu aplicativo implantado com ClickOnce de um navegador da Web inserindo a URL
para o manifesto de implantação. Se você chamar seu ClickOnce aplicativo
ClickOnceOnDemand, e você carregá-la para o diretório de raiz do adatum.com, seu URL
teria esta aparência:
http://www.adatum.com/ClickOnceOnDemand/ClickOnceOnDemand.application
3. Quando o formulário principal for exibida, pressione o Button. Você deve ver uma
seqüência em uma janela caixa de mensagem que lê " Hello, World! "
Passo-a-passo: Implementando um Editor de Tipos de Interface do Usuário
Você pode fornecer uma experiência em tempo de design personalizada para tipos complexos
Propriedade implementando um editor tipo Interface (UI) do usuário.
Essa explicação passo a passo explica como criar seu próprio Editor tipo UI para um tipo
personalizado e exibir a interface de edição, usando um PropertyGrid.
Tarefas explicadas nessa explicação passo a passo incluem:
• Definir um tipo personalizado.

• Definir um controle de exibição para seu editor tipo UI.
• Definir uma classe que deriva de UITypeEditor.
• Do PropertyGrid substituindo o GetEditStyle método para informar do tipo de estilo editor
que irá usar o editor.
• Substituir o EditValue método para tratar a interface do usuário, processamento de entrada
de usuário, e atribuição valor.

Para copiar o código nessa explicação passo a passo como uma lista simples, consulte COMO:
Criar um controle de formulários do Windows que tira vantagem de recursos em tempo de criação.
Pré-requisitos
• Permissões suficientes para poder para criar e executar projetos do aplicativo Windows
Forms no computador está instalado. onde o .NET Framework
Definir um tipo personalizado
Seu editor tipo UI personalizada exibirá um tipo personalizado. Esse tipo pode ser simples ou
complexos. Para essa explicação passo a passo, você irá definir um tipo simples com
comportamento de edição em tempo de design personalizado. Esse tipo é chamado
MarqueeLightShape, e é e Circle. com dois valores, Square um enum
Para definir um tipo de enumeração personalizado
• No corpo da definição do seu controle Windows Forms, define o MarqueeLightShape tipo.

C#
// This defines the possible values for the MarqueeBorder // control's LightShape property. public enum
MarqueeLightShape { Square, Circle }
Definir um controle de exibição
Seu editor tipo UI Personalizada exibe a interface edição usar um controle Windows Forms. Esse
controle é denominado LightShapeSelectionControl, e ele deriva de UserControl. Seu construtor usa
o valor da propriedade atual e uma referência à IWindowsFormsEditorService. O controle de
exibição usa o CloseDropDown método no IWindowsFormsEditorService para fechar a janela
Lista suspensa quando o usuário clica em uma seleção.
Para definir um controle de exibição
• No corpo da definição do seu controle Windows Forms, definir o LightShapeSelectionControl

controle.
C#
// This control provides the custom UI for the LightShape property // of the MarqueeBorder. It is used by
the LightShapeEditor. public class LightShapeSelectionControl : System.Windows.Forms.UserControl {
private MarqueeLightShape lightShapeValue = MarqueeLightShape.Square; private
IWindowsFormsEditorService editorService = null; private System.Windows.Forms.Panel squarePanel;
private System.Windows.Forms.Panel circlePanel; // Required designer variable. private
System.ComponentModel.Container components = null; // This constructor takes a MarqueeLightShape
value from the // design-time environment, which will be used to display // the initial state. public
LightShapeSelectionControl( MarqueeLightShape lightShape, IWindowsFormsEditorService
editorService ) { // This call is required by the designer. InitializeComponent(); // Cache the light shape
value provided by the // design-time environment. this.lightShapeValue = lightShape; // Cache the
reference to the editor service. this.editorService = editorService; // Handle the Click event for the two
panels. this.squarePanel.Click += new EventHandler(squarePanel_Click); this.circlePanel.Click += new
EventHandler(circlePanel_Click); } protected override void Dispose( bool disposing ) { if( disposing ) { //
Be sure to unhook event handlers // to prevent "lapsed listener" leaks. this.squarePanel.Click -= new

EventHandler(squarePanel_Click); this.circlePanel.Click -= new EventHandler(circlePanel_Click);
if(components != null) { components.Dispose(); } } base.Dispose( disposing ); } // LightShape is the
property for which this control provides // a custom user interface in the Properties window. public
MarqueeLightShape LightShape { get { return this.lightShapeValue; } set { if( this.lightShapeValue !=
value ) { this.lightShapeValue = value; } } } protected override void OnPaint(PaintEventArgs e) {
base.OnPaint (e); using( Graphics gSquare = this.squarePanel.CreateGraphics(), gCircle =
this.circlePanel.CreateGraphics() ) { // Draw a filled square in the client area of // the squarePanel
control. gSquare.FillRectangle( Brushes.Red, 0, 0, this.squarePanel.Width, this.squarePanel.Height ); //
If the Square option has been selected, draw a // border inside the squarePanel. if( this.lightShapeValue
== MarqueeLightShape.Square ) { gSquare.DrawRectangle( Pens.Black, 0, 0, this.squarePanel.Width-1,
this.squarePanel.Height-1); } // Draw a filled circle in the client area of // the circlePanel control.
gCircle.Clear( this.circlePanel.BackColor ); gCircle.FillEllipse( Brushes.Blue, 0, 0, this.circlePanel.Width,
this.circlePanel.Height ); // If the Circle option has been selected, draw a // border inside the circlePanel.
if( this.lightShapeValue == MarqueeLightShape.Circle ) { gCircle.DrawRectangle( Pens.Black, 0, 0,
this.circlePanel.Width-1, this.circlePanel.Height-1); } } } private void squarePanel_Click(object sender,
EventArgs e) { this.lightShapeValue = MarqueeLightShape.Square; this.Invalidate( false );
this.editorService.CloseDropDown(); } private void circlePanel_Click(object sender, EventArgs e) {
this.lightShapeValue = MarqueeLightShape.Circle; this.Invalidate( false );
this.editorService.CloseDropDown(); } #region Component Designer generated code /// <summary> ///
Required method for Designer support - do not modify /// the contents of this method with the code
editor. /// </summary> private void InitializeComponent() { this.squarePanel = new
System.Windows.Forms.Panel(); this.circlePanel = new System.Windows.Forms.Panel();
this.SuspendLayout(); // // squarePanel // this.squarePanel.Location = new System.Drawing.Point(8,
10); this.squarePanel.Name = "squarePanel"; this.squarePanel.Size = new System.Drawing.Size(60, 60);
this.squarePanel.TabIndex = 2; // // circlePanel // this.circlePanel.Location = new
System.Drawing.Point(80, 10); this.circlePanel.Name = "circlePanel"; this.circlePanel.Size = new
System.Drawing.Size(60, 60); this.circlePanel.TabIndex = 3; // // LightShapeSelectionControl //
this.Controls.Add(this.squarePanel); this.Controls.Add(this.circlePanel); this.Name =
"LightShapeSelectionControl"; this.Size = new System.Drawing.Size(150, 80); this.ResumeLayout(false);
} #endregion }
Definir um tipo UI classe Editor
Para implementar comportamento Editor tipo UI, derivar da classe UITypeEditor base. Essa
classe é chamado LightShapeEditor.
Para definir um tipo UI classe Editor
1. Do System.Drawing.Design Ativar acesso ao .NET Framework Design-time suporte por

referência o conjunto System.Design e importar e System.Windows.Forms.Design espaços
de nome. Para obter mais informações, consulte Como: Acessar suporte em tempo de
design no Windows Forms.
2. No corpo da definição do seu controle Forms janela, definir a LightShapeEditor classe.
C#
// This class demonstrates the use of a custom UITypeEditor. // It allows the MarqueeBorder
control's LightShape property // to be changed at design time using a customized UI element // that

is invoked by the Properties window. The UI is provided // by the LightShapeSelectionControl class.
internal class LightShapeEditor : UITypeEditor {
Substituir o método GetEditStyle
O GetEditStyle método indica para o ambiente de desenvolvimento que tipo de usuário interface
a implementa Editor tipo UI. Os valores possíveis são definidos no tipo UITypeEditorEditStyle. A
LightShapeEditor implementa uma DropDown interface digite Editor.
Para substituir o método GetEditStyle
• No corpo da LightShapeEditor definição, substituir o GetEditStyle método para retornar

DropDown.
C#
public override UITypeEditorEditStyle GetEditStyle( System.ComponentModel.ITypeDescriptorContext
context) { return UITypeEditorEditStyle.DropDown; }
Substituir o método EditValue
O EditValue método estabelece a interação entre o ambiente de desenvolvimento e a interface do

usuário para edição seu Tipo personalizado. O EditValue método cria uma instância da caixa de
diálogo restrita com o qual o usuário edita o valor ou o controle de exibição. Quando o usuário
estiver concluído edição, o EditValue método retorna o valor para o ambiente de design.
Do IWindowsFormsEditorService no caso de um controle de exibição como

LightShapeSelectionControl o EditValue método pode passar uma referência a para o controle
modo. O controle de exibição pode usar essa referência para fechar próprio quando o usuário
seleciona um valor. Isso é necessário para uma caixa de diálogo restrita, não porque um
formulário pode fechar próprio.
Para substituir o método EditValue
• No corpo da LightShapeEditor definição, substituir o EditValue método.

C#
public override object EditValue( ITypeDescriptorContext context, IServiceProvider provider, object
value) { if (provider != null) { editorService = provider.GetService(
typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; } if (editorService != null) {
LightShapeSelectionControl selectionControl = new LightShapeSelectionControl(
(MarqueeLightShape)value, editorService); editorService.DropDownControl(selectionControl); value =
selectionControl.LightShape; } return value; }
Substituir o método PaintValue
Você pode fornecer uma representação gráfica de valor sua propriedade por substituir o
PaintValue método.
Para substituir o método PaintValue
• No corpo da LightShapeEditor definição, substituir o PaintValue método. Também substituir

o GetPaintValueSupported método para retornar true.
C#

// This method indicates to the design environment that // the type editor will paint additional content in
the // LightShape entry in the PropertyGrid. public override bool GetPaintValueSupported(
ITypeDescriptorContext context) { return true; } // This method paints a graphical representation of the
// selected value of the LightShpae property. public override void PaintValue(PaintValueEventArgs e) {
MarqueeLightShape shape = (MarqueeLightShape)e.Value; using (Pen p = Pens.Black) { if (shape ==
MarqueeLightShape.Square) { e.Graphics.DrawRectangle(p, e.Bounds); } else {
e.Graphics.DrawEllipse(p, e.Bounds); } } }
Anexar seu editor tipo UI a uma propriedade
Quando estiver pronto para uso em seu controle personalizado, o editor tipo UI anexar à
propriedade. a uma propriedade, a propriedade com base no tipo MarqueeLightShape, implementar
e aplicar o LightShapeEditor a EditorAttribute
Para anexar o editor tipo UI a uma propriedade
• No corpo da definição do seu controle, declare uma MarqueeLightShape propriedade

chamada LightShape. Também declarar um campo da instância chamado lightShapeValue do
tipo MarqueeLightShape para fazer a propriedade. Do EditorAttribute Aplicar para a
propriedade.
C#
private MarqueeLightShape lightShapeValue; [Category("Marquee")] [Browsable(true)]
[EditorAttribute(typeof(LightShapeEditor), typeof(System.Drawing.Design.UITypeEditor))] public
MarqueeLightShape LightShape { get { return this.lightShapeValue; } set { this.lightShapeValue = value; } }
Teste seu editor tipo UI
Você pode testar seu editor tipo UI, criando uma instância do seu controle personalizado e anexá-
los a um PropertyGrid controle usando a SelectedObject propriedade.
Se você estiver usando Visual Studio, você pode criar um novo projeto aplicativo do Windows,
referência conjunto o do controle, e adicionar uma instância do seu controle para o formulário. Há
suporte para esta tarefa em Visual Studio abrangente.
Quando as propriedades de seu controle são exibidas no tempo de criação, você pode selecionar
a LightShape propriedade. Quando ele estiver selecionado, uma seta suspensa. aparece ( )
Quando você clica na seta, o controle de exibição é exibida sob a entrada Propriedade. Clique no
círculo ou quadrado para selecionar o valor. Após você clicar em, o controle de exibição descarta
propriamente dito, e o valor selecionado é exibido no PropertyGrid.
Observação
Quando você desenvolver seu personalizadas UITypeEditor, é recomendável que você definir o
número de criação para incrementar com cada compilação. Isso impede que versões mais
antigas, armazenadas em cache de sendo criada no ambiente de desenvolvimento. seu
UITypeEditor
Próximas etapas
Após você ter criado seu próprio Editor tipo UI, Explore outras maneiras para interagir com um
PropertyGrid e o ambiente de criação:

• Gravar um editor tipo UI com base em uma caixa de diálogo restrita em vez de um controle
de exibição.
• Escrever um conversor tipo for um tipo personalizado usando a TypeConverter classe.
Para obter mais informações, consulte COMO: Implementar um conversor de tipo.
• Gravar um designer de seu controle personalizado. Para obter mais informações, consulte
COMO: Criar um controle de formulários do Windows que tira vantagem de recursos em tempo
de criação.
O procedimento a seguir descreve como criar um novo componente de serviço.
Para criar um componente de serviço

1. Definir uma classe que deriva direta ou indiretamente a partir da ServicedComponent
classe. Por exemplo, o código a seguir garante que a Calculator classe é hospedada por um
aplicativo do COM +.
C#
using System.EnterpriseServices; public class Calculator : ServicedComponent { public int Add (int x,
int y) { return(x+y); } }
2. Aplicar atributos para indicar como cada conjunto, classe, ou método deve interagir com
funcionalidade com +.
Observação
No.NET Framework versão 1.1, a configuração de segurança do COM + é habilitada por padrão
se o ApplicationAccessControlAttribute atributo não está presente no conjunto. Isso é uma
alteração no comportamento de .NET Framework versão 1.0.
C#
[assembly: ApplicationName("Calculator")] [assembly:

ServicedComponent { // Member definitions. }

C#
sn –k Calculator.snk csc /t:library /r:System.EnterpriseServices.dll Calculator.cs
4. Implantar o aplicativo de componentes atendidos por registrar seu conjunto dinamicamente

ou manualmente.
5. Após um componente de serviço estiver registrado, os clientes podem criar instâncias do
componente como eles criar instâncias de qualquer outro componente. Para obter um
exemplo completo, consulte Exemplo de serviço do componente.
Observação
Em plataformas Windows 2000, com + sempre carrega a versão mais recente do Common
Language Runtime do para o componente você está criando. Isso significa que em um

computador com o .NET Framework versão 1.0 e .NET Framework versão 1.1 instalado,.NET
Framework versão 1.1 é carregado sempre. Como uma solução, você pode criar um arquivo
Dllhost.exe.Configuration COM + que permite que você para “ bloquear ” todos os aplicativos para
uma versão específica do .NET Framework. No Windows xp e plataformas Windows Server
2003, a configuração diretório raiz de aplicativo pode ser usada para apontar com + para uma
pasta apropriada para seu arquivo de configuração.
Exemplo
C#
using System.EnterpriseServices; [assembly: ApplicationName("Calculator")] [assembly:
ServicedComponent { public int Add (int x, int y) { return(x+y); } }
O exemplo a seguir mostra como aplicar o DescriptionAttribute atributo para definir a descrição de
um conjunto.
Exemplo
C#
using System.EnterpriseServices; [ assembly: Description("BankComponent assembly")] public class
Este exemplo mostra como usar o estático SetComplete e SetAbort métodos da classe
System.EnterpriseServices.ContextUtil. Para obter mais informações sobre esses métodos,
consulte Votação em uma transação automáticas.
Exemplo
C#
//Try to do something crucial to the transaction in progress. if( !DoSomeWork() ) { ContextUtil.SetAbort();
//Something goes wrong. } else { ContextUtil.SetComplete(); //All goes well. }
Este exemplo mostra como aplicar o atributo ApplicationID a um conjunto.
Exemplo

C#
using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] [ assembly:
ApplicationID("4fb2d46f-efc8-4643-bcd0-6e5bfa6a174c")] public class Account : ServicedComponent {
static void Main() {} }
• Referências a espaços para nome do sistema e System.EnterpriseServices
Para uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, com +

Objeto pool pode usar para evitar a sobrecarga de instanciar objetos de zero. Em vez disso
objetos obter recebidos de um pool quando ativado. Para obter mais informações, consulte Objeto
pool.
Para criar um objeto agrupado e definir seu tamanho e tempo limite limita
1. Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent, e
aplique o ObjectPoolingAttribute atributo à classe. Por exemplo, o código a seguir define
uma classe denominada TestObjectPooling e define e CreationTimeout propriedades para a
classe. o MinPoolSize, MaxPoolSize
C#
[ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public
class TestObjectPooling : ServicedComponent { }
2. Substituir o Activate, Deactivate., e CanBePooled métodos de classe

System.EnterpriseServices.ServicedComponent
3. Teste o objeto em pool, em um aplicativo do cliente:
1. Criar uma instância da classe do objeto agrupada e chamar os métodos no objeto
em pool. Por exemplo, o código a seguir cria uma instância da classe TestObjectPooling
e chama um Perform método.
C#
public class App { public static int Main(string[] args) { TestObjectPooling order = new
TestObjectPooling(); order.Perform();
2. Chame o método DisposeObject para retornar o objeto para o pool.

C#
ServicedComponent.DisposeObject (order);
Exemplo
C#
[ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)] public class
TestObjectPooling : ServicedComponent { public void Perform () { // Method contents go here. } protected
override void Activate() { // Called when removed from the pool. } protected override void Deactivate() { //
Called before deactivating or placing back in pool. } protected override bool CanBePooled() { // Called after
Deactivate. Indicate your vote here. return true; } }

O procedimento a seguir descreve como criar um método de serviço da Web que usa transações
automáticas. Se ocorrer uma exceção enquanto um método de serviço da Web está participando
em uma transação, ASP.NET anula automaticamente a transação. Da mesma forma, se nenhuma
exceção ocorrer, a transação é confirmada automaticamente.
Para criar um serviço da Web que usa transações automáticas

1. Importar os espaços para nome System.WebServices e System.EnterpriseServices.
Outros espaços para nomes, tais como System.Data e System.Data.SqlClient, podem ser
importado conforme necessário.
C#
<%@ WebService Language="C#" Class="Orders" %> <%@ assembly
name="System.EnterpriseServices" %> using System.Web.Services; using System.EnterpriseServices;
2. Definir uma classe que deriva da classe WebService. Por exemplo, o código a seguir
define uma classe denominado Pedidos que deriva da classe WebService.
C#
public class Orders : WebService { }
3. Para cada método Web que deve participar automaticamente de uma transação, aplicar o
WebMethodAttribute atributo, e definir a opção da transação. Por exemplo, no código a
seguir o atributo WebMethod é aplicado para o DeleteAuthor método, e a TransactionOption
propriedade é definida como TransactionOption.RequiresNew.
C#
[ WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string
lastName) { // Perform the required database task. }
Exemplo
C#
<%@ WebService Language="C#" Class="Orders" %> <%@ assembly name="System.EnterpriseServices"
%> using System; using System.Data; using System.Data.SqlClient; using System.Web.Services; using
System.Web.Util; using System.EnterpriseServices; public class Orders : WebService { [
WebMethod(TransactionOption=TransactionOption.RequiresNew)] public int DeleteAuthor(string
lastName) { String deleteCmd = "DELETE FROM authors2 where au_lname='" + lastName + "'" ;
SqlConnection sqlConn = new SqlConnection("Integrated Security=SSPI;database=pubs;server=myserver");
SqlCommand myCommand = new SqlCommand(deleteCmd,sqlConn); // If a Web service method is
participating in a transaction and an // exception occurs, ASP.NET automatically aborts the transaction. //
Likewise, if no exception occurs, then the transaction is // automatically committed.
myCommand.Connection.Open(); return myCommand.ExecuteNonQuery(); } }
Este exemplo mostra como definir a propriedade SoapVRoot " MyVRoot ".
Exemplo
C#
[ApplicationActivation(ActivationOption.Library, SoapVRoot="MyVRoot")]

• Referências para o sistema e System.EnterpriseServices Namespace espaços para nome
Este exemplo mostra como definir o limite de transação como 10 segundos.
Exemplo
C#
[Transaction(TransactionOption.Required, Isolation=TransactionIsolationLevel.Serializable, Timeout=10)]
• Referências ao espaço para nome System.EnterpriseServices.
Este exemplo mostra como para fornecer o nome do aplicativo, usando o conjunto - atributo
ApplicationName.
Exemplo
C#
using System.EnterpriseServices; [ assembly: ApplicationName("BankComponent")] public class Account :
ServicedComponent { static void Main() {} }
COM+
Exemplo do código
O procedimento e exemplo a seguir mostram como uma classe derivada da classe

ServicedComponent pode usar o recurso BYOT do COM + para acessar um coordenador
transações distribuídas (DTC). Para obter mais informações como utilizar o recurso BYOT de
dentro do espaço de nome System.EnterpriseServices, consulte BYOT (colocar seu próprio
Transaction).
Para criar um objeto que usa a transação de outro objeto.

1. Definir uma classe que deriva da classe ServicedComponent, e expõe uma propriedade
pública que retorna o objeto transações DTC com + atual. Por exemplo, no código a seguir a
classe Base, herda a classe ServicedComponent e tem uma propriedade pública que retorna
o objeto ContextUtil.Transaction para a transação COM + DTC atual no qual o objeto é
instanciado.

C#
using System.EnterpriseServices; public class Base : ServicedComponent { public Object Transaction {
get { return ContextUtil.Transaction; } } }
2. Crie duas classes que derivar da classe definida na etapa 1 e defina o atributo de
transações para ambas as classes. Por exemplo, o código a seguir declara duas classes
CTransaction1 e CTransaction2 derivar de classe Base, e têm seu conjunto de atributos de
transações.
C#
[Transaction] public class CTransaction1 : Base { // Insert your transaction logic here. } [Transaction]
public class CTransaction2 : Base { // Insert your transaction logic here. }
3. Criar um aplicativo do cliente que usa as classes criadas na etapa 2 para testar o recurso
BYOT.
1. Criar uma instância de uma das classes definidas na etapa 2. Por exemplo, o
código a seguir cria uma instância da classe CTransaction1.
C#
class BYOTDemonstration { static void Main() { CTransaction1 tx1 = new CTransaction1(); } }
2. Recuperar a transação COM + DTC atual do objeto criado no 3.a etapa. Por
exemplo, o código a seguir recupera o objeto transações a partir da propriedade
Transaction pública da classe CTransaction1.
C#
Object tx = tx1.Transaction;
3. Criar uma instância da classe segundo definiu na etapa 2, usando o objeto

Transaction recuperado em 3.b etapa. Por exemplo, o código a seguir cria uma
instância da classe CTransaction2 usando o Transaction recuperada em 3.b etapa.
C#

C#
sn –k BYOTDemo.snk
Exemplo
C#
using System; using System.Reflection; using System.EnterpriseServices; [assembly:
AssemblyKeyFileAttribute("byotdemo.snk")] public class Base : ServicedComponent { public Object
Transaction { get { return ContextUtil.Transaction; } } } [Transaction] public class CTransaction1 : Base { //
Insert your transaction logic here. } [Transaction] public class CTransaction2 : Base { // Insert your
transaction logic here. } class BYOTDemonstration { static void Main() { /* Create a transactional object, and
then get its transaction. */ CTransaction1 tx1 = new CTransaction1(); Console.WriteLine("Created
transaction1."); Object tx = tx1.Transaction; Console.WriteLine("Got the transaction of transaction1.");
Console.WriteLine("Created transaction2 using the transaction of transaction1."); } }

Este exemplo mostra como usar o atributo PrivateComponentAttribute em uma classe.
Exemplo
C#
[PrivateComponent] public class CPrivate : ServicedComponent
• Referências ao espaço para nome System.ServiceProcess.

Consulte também
Referência
Este exemplo mostra como definir o tipo de ativação para " Servidor ".
Exemplo
C#
using System.EnterpriseServices; [ assembly: ApplicationActivation(ActivationOption.Server)] public class

Consulte também
Referência
O exemplo a seguir mostra como habilitar a sincronização em instâncias da classe TestSync .
Exemplo
C#
[Synchronization] public class TestSync : ServicedComponent
O procedimento a seguir descreve como preparar uma classe para participar de uma transação
automática.
Para preparar uma classe para participar de uma transação automática

1. Do TransactionAttribute derivar sua classe de classe ServicedComponent, e aplicar à sua
classe. O exemplo a seguir mostra como aplicar o atributo TransactionAttribute a uma classe
derivada da classe ServicedComponent.
C#
[Transaction(TransactionOption.Required)] public class Account : ServicedComponent { //. . . }
2. Aplicar o atributo AutoCompletar para cada método para o qual o método

ContextUtil.SetComplete deve ser chamado automaticamente na ausência de exceções. O
exemplo a seguir mostra como aplicar o atributo AutoCompletar.
C#
[AutoComplete] public void Debit(int amount) { // Do some database work. Any exception thrown
here aborts the // transaction; otherwise, transaction commits. }
3. Assinar o assembly com um strong name. Do AssemblyKeyFileAttribute para assinar o

conjunto usando atributos, crie um par de chaves usando Sn.exe, e adicione ou
AssemblyKeyNameAttribute Conjunto atributo e especifique o nome do arquivo que contém
o par de chaves para assinar o conjunto com um nome de alta segurança.
C#
[assembly: AssemblyKeyFileAttribute("TestApp.snk")]
4. Registrar o conjunto que contém a classe com o catálogo COM +.

5. Se as instâncias de chamada de sua classe do cliente é gerenciado pelo Common
Language Runtime, o registro será executado para você. No entanto, se você prevê que um
chamador não gerenciado pode criar e chamar instâncias da sua classe, usar a ferramenta
de instalação dos Serviços .NET (Regsvcs.exe) para executar o Registro manualmente.
Exemplo
C#
// ----------------------------------------------------------------- // TestApp.cs // Generate a Strong name: // sn -k
TestApp.snk // Compile the code: // csc /target:exe /r:System.EnterpriseServices.dll TestApp.cs // Run
TestApp: // start TestApp.exe // ----------------------------------------------------------------- using System; using
System.Runtime.CompilerServices; using System.EnterpriseServices; using System.Reflection;
//Registration details. //COM+ application name as it appears in the COM+ catalog. [assembly:
ApplicationName("TestApp")] //Strong name for assembly. [assembly:
AssemblyKeyFileAttribute("TestApp.snk")] [Transaction(TransactionOption.Required)] public class Account
: ServicedComponent { //Provides SetComplete behavior in the absence of exceptions. [AutoComplete]
transaction; otherwise, transaction commits. } } public class client { public static int Main() { Account
accountX = new Account(); accountX.Debit(100); return 0; } }
Este exemplo mostra como habilitar ativação JIT e desativação e de uma classe.
Exemplo
C#
[JustInTimeActivation] public class TestJITObjectPooling : ServicedComponent

Este exemplo mostra a colocação de atributo AutoCompletar em uma classe reconhecem

transações. Para obter mais informações sobre o AutoCompletar atributo, consulte Votação em
uma transação automáticas.
Exemplo
C#
[Transaction(TransactionOption.Supported)] public class Account : ServicedComponent { [AutoComplete]
transaction; otherwise, transaction commits. } }
Como Implementar um Componente Enfileirado que Exibe uma Mensagem de Forma

Assíncrona
Exemplo do código
O serviço QC COM + fornece uma maneira de uma classe componente para ser chamado
assincronamente USAR O enfileiramento de mensagens Microsoft. Para obter mais informações
sobre componentes enfileirados derivados da System.EnterpriseServices.ServicedComponent
classe, consulte O QC (queueds Components).
Para implementar um componente enfileirado que exibe uma mensagem de forma assíncrona
1. Importar espaço para nome System.EnterpriseServices.
C#
2. Defina o ApplicationActivation atributo como ActivationOption.Server; ativar o ouvinte da

fila aplicativo enfileiramento e definindo o ApplicationQueuing atributo assembly, como
mostrado no código de exemplo a seguir:
C#
[assembly: ApplicationActivation(ActivationOption.Server)] [assembly:
ApplicationQueuing(Enabled=true, QueueListenerEnabled=true)]
3. Definir uma interface na fila, e aplique o InterfaceQueuing atributo à interface. Por exemplo
o código a seguir mostra o atributo InterfaceQueuing aplicada para a IQComponent interface
que tenha um único método DisplayMessage.
C#
[InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); }
4. Definir uma classe que deriva da classe System.EnterpriseServices.ServicedComponent e

implementa a interface na fila. Por exemplo, o código de exemplo a seguir declara uma

classe denominada QComponent que deriva da classe
System.EnterpriseServices.ServicedComponent e implementa a IQComponent interface.
C#
public class QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string
msg) { MessageBox.Show(msg, "Processing message"); } }
5. Criar um aplicativo cliente e testar o componente enfileirado.

1. Criar uma variável cujo tipo de dados é a interface na fila do qual a classe
componente enfileirado é derivada.
C#
IQComponent iQc = null;
2. Vincular ao moniker correspondente à interface na fila, e chamamos o método no

componente enfileirado para exibir a mensagem de forma assíncrona. Por exemplo o
código a seguir vincula ao componente enfileirado que corresponda à interface
IQComponent, e chama o método DisplayMessage para exibir uma mensagem de forma
assíncrona.
C#
IQComponent iQc = null; try { iQc = (IQComponent)
Marshal.BindToMoniker("queue:/new:QCDemo.QComponent"); } catch {
MessageBox.Show("Cannot create Queued Component"); } iQc.DisplayMessage
(messageToSend.Text); Marshal.ReleaseComObject(iQc);
Exemplo
C#
using System.Reflection; using System.EnterpriseServices; [assembly: ApplicationName("QCDemoSvr")]
[assembly: ApplicationActivation(ActivationOption.Server)] [assembly: ApplicationQueuing(Enabled=true,
QueueListenerEnabled=true)] [assembly: AssemblyKeyFile("QCDemoSvr.snk")] namespace QCDemo {
[InterfaceQueuing] public interface IQComponent { void DisplayMessage(string msg); } public class
QComponent : ServicedComponent, IQComponent { public void DisplayMessage(string msg) {
MessageBox.Show(msg, "Processing message"); } } }
Exemplo do código
O procedimento e exemplo a seguir mostram como para implementar uma classe de evento e
coletor de eventos que implementam uma interface de eventos comuns, mais um editor para
acionar um evento. Para obter mais informações sobre como usar o modelo flexível coupled
Eventos COM +, consulte Eventos flexível Coupled.
Para implementar flexível aliada eventos

1. Definir uma interface de eventos. Por exemplo, o código a seguir define uma interface de
evento denominada IlceMsg que tenha um método chamado EventMethod.
C#
public interface ILceMsg { void EventMethod(string message); }

2. Definir uma classe de evento que deriva da classe
na etapa 1. Por exemplo, o código a seguir define uma classe de evento chamado LceClass.
C#
[EventClass] public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string
message){} }
3. Definir uma classe mesmo do coletor que deriva da classe

na etapa 1. Por exemplo, o código a seguir define uma classe do coletor de evento chamado
LceSink.
C#
public class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) {
MessageBox.Show(message, "Event sink"); } }
4. Criar um editor de eventos para disparar o LCE.

C#
protected void Fire_Click (object sender, System.EventArgs e) { ILceMsg evt = (ILceMsg) new
Exemplo
C#
System.Runtime.InteropServices; [assembly: ApplicationName("EventDemo")] [assembly:
ApplicationActivation(ActivationOption.Library)] [assembly: AssemblyKeyFile("EventDemoSvr.snk")]
namespace EventDemo { public interface ILceMsg { void EventMethod(string message); } [EventClass]
public class LceClass : ServicedComponent, ILceMsg { public void EventMethod(string message){} } public
class LceSink : ServicedComponent, ILceMsg { public void EventMethod(string message) {
MessageBox.Show(message, "Event sink"); } } }
C#
//Publisher protected void Fire_Click (object sender, System.EventArgs e) { ILceMsg evt = (ILceMsg) new
O procedimento e exemplo a seguir descrevem como configurar construção de objeto e definir a

seqüência de inicialização padrão da classe TestObjectConstruct para a seqüência "Initial
Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes". Essa seqüência é
usada para conectar a um banco de dados SQL Server. O tópico Construção de objeto,. explica
mais o uso do COM + construção de objeto a partir da
System.EnterpriseServices.ServicedComponent classe
Para configurar construção de objeto e definir a seqüência de inicialização padrão para uma
classe
1. Definir uma classe que deriva direta ou indiretamente a partir da
System.EnterpriseServices.ServicedComponent classe. Por exemplo, o código a seguir
mostra uma classe TestObjectConstruct que deriva diretamente da classe
System.EnterpriseServices.ServicedComponent.
C#

using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; …
public class TestObjectConstruct : ServicedComponent { … }
2. Aplicar o ConstructionEnabled atributo para a classe e definir propriedade do atributo

Default. Por exemplo, o código a seguir se aplica o ConstructionEnabled atributo da
TestObjectConstruct classe e define a Padrão propriedade como a seqüência de conexão SQL
Server.
C#
[ConstructionEnabled(Default="Initial Catalog=Northwind;Data
ServicedComponent { … }
3. Substituir o método construir.

Visual Basic
<ConstructionEnabled([Default] := "Initial Catalog=Northwind;Data

Source=.\\SQLServerInstance;Trusted_Connection=yes")> _ Public Class TestObjectConstruct
Inherits ServicedComponent Private m_connectStr As String Private conn as SqlConnection Protected
Overrides Sub Construct(constructString As String) ' Called after constructor. m_connectStr =
constructString End Sub Public Sub ConnectToDatabase() conn = New SqlConnection(m_connectStr)
End Sub End Class
[C#] [ConstructionEnabled(Default="Initial Catalog=Northwind;Data
ServicedComponent { private string connectStr; SqlConnection conn; public TestObjectConstruct() { …
} protected override void Construct(string constructString) { // Called after constructor. connectStr =
constructString; } public void ConnectToDatabase() { conn = new SqlConnection(connectStr);
conn.Open(); } }
4. No aplicativo do cliente, criar uma instância da classe do componente sem especificar uma
seqüência de construção, para que o padrão é usado. Por exemplo, o código a seguir cria
uma instância da classe TestObjectConstruct, e a seqüência de construção padrão será "Initial
Catalog=Northwind;Data Source=.\\SQLServerInstance;Trusted_Connection=yes".
C#
public class App { public static void Main() { TestObjectConstruct order = new TestObjectConstruct();
order. ConnectToDatabase(); } }
Depois de instalar o aplicativo Serviços componente, você pode especificar seqüências de

construção por meio da ferramenta administrativa Serviços de componente. Para inserir uma
seqüência de construção de objeto para um componente, execute as seguintes etapas:
1. Abra a ferramenta administrativa Serviços de componente.

2. Clique com botão direito na ferramenta administrativa Serviços de componente, mouse no
componente que você deseja configurar, e, em seguida, clique em Properties.
3. Se você não tenha definido o atributo ConstructionEnabled para True, na caixa Properties
de diálogo, na guia Activation, marque a Enable object construction caixa de seleção
para ativar o uso da seqüência de caracteres de construção do objeto.
4. Se você desejar alterar a seqüência de construção do padrão especificado com o atributo
ConstructionEnabled, na caixa Constructor string, insira a seqüência de construção.
Exemplo

C#
using System; using System.EnterpriseServices; using System.Data; using System.Data.SqlClient; [assembly :
ApplicationName("OCDemo")] namespace OCDemo { [ConstructionEnabled(Default="Initial
Catalog=Northwind; Data Source=.\\SQLServerInstance;Trusted_Connection=yes")] public class
TestObjectConstruct : ServicedComponent { private string connectStr; SqlConnection conn; public
TestObjectConstruct() { … } protected override void Construct(string constructString) { // Called after
constructor. connectStr = constructString; } public void ConnectToDatabase() { conn = new
SqlConnection(connectStr); conn.Open(); } } }
O System.Reflection espaço para nome contém vários métodos para obter informações de um
conjunto de módulos (assembly). Esta seção demonstra um dos métodos. Para obter informações
adicionais, consulte Visão geral de reflexão.
O exemplo a seguir obtém informações Tipo e membro de um conjunto.
Exemplo
C#
using System; using System.Reflection; class Asminfo1 { public static void Main(string[] args) {
Console.WriteLine ("\nReflection.MemberInfo"); //Get the Type and MemberInfo. //Insert the fully
qualified class name inside the quotation marks in the following statement. Type MyType
=Type.GetType("System.IO.BinaryReader"); MemberInfo[] Mymemberinfoarray =
MyType.GetMembers(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Insta
nce|BindingFlags.DeclaredOnly); //Get and display the DeclaringType method. Console.Write("\nThere are
{0} documentable members in ", Mymemberinfoarray.Length); Console.Write("{0}.", MyType.FullName);
foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) { Console.Write("\n" +
Mymemberinfo.Name); } } }
Um conjunto de Arquivo Único, que é o tipo mais simples do conjunto, contém informações de tipo
e implementação,, bem como o Manifesto do conjunto. Você pode usar Compiladores de linha de
comando ou Visual Studio 2005 Para criar um conjunto de Arquivo Único. Por padrão, o
compilador cria um arquivo de montagem com uma extensão.exe.
Observação
Para Visual Studio 2005 C# e Visual Basic pode ser usada somente para criar conjuntos de
Arquivo Único. Se você deseja criar vários arquivos conjuntos, use Compiladores de linha de
comando ou Visual Studio 2005 com as extensões Managed do C++.. ou Visual Studio 2005 Com
o Managed Extensions para C++
Os procedimentos a seguir mostram como criar conjuntos de Arquivo Único usando Compiladores
Para criar um conjunto com uma extensão.exe

< compiler command> <module name>
conjunto.
O exemplo a seguir cria um conjunto chamado myCode.exe de um módulo de código chamado

myCode.
C#
csc myCode.cs
Para criar um conjunto com uma extensão.exe e especificar o nome do arquivo de saída

< compiler command> /out:<file name> <module name>
módulo de código, file name é o nome de arquivo de saída, e module name é o nome do
módulo de código para compilar para o conjunto.
O exemplo a seguir cria um conjunto chamado myAssembly.exe de um módulo de código chamado

myCode.
C#
csc /out:myAssembly.exe myCode.cs
Criando conjuntos da biblioteca
Um conjunto de biblioteca é semelhante a uma biblioteca de classes. Ele contém tipos que serão
referenciados por outros conjuntos, mas ele tem nenhum ponto de entrada para iniciar a
execução.
Para criar um conjunto de biblioteca

< compiler command> /t:library <module name>
conjunto. Você pode usar outras opções do compilador, como a /out: opção.
O exemplo a seguir cria um conjunto de biblioteca chamado myCodeAssembly.dll de um módulo de

código chamado myCode.
C#
csc /out:myCodeLibrary.dll /t:library myCode.cs
Como: Criar um domínio de aplicativo
Um host Runtime de idioma comum cria domínios aplicativos automaticamente quando eles são
necessários. No entanto, você pode criar seus próprios domínios aplicativos e carregá-los esses

conjuntos que você deseja gerenciar pessoal. Você também pode criar domínios de aplicativo do
qual você executar código.
Criar um novo domínio do aplicativo usando um dos métodos sobrecarregados CreateDomain na

classe System.AppDomain. Você pode dar o domínio do aplicativo um nome e fazer referência a
ela com esse nome.
O exemplo a seguir cria um novo domínio do aplicativo, atribui o nome MyDomain, e seguida,
imprime o nome de domínio host e domínio de aplicativo filho recém-criado para o console.
Exemplo
C#
AppDomain.CreateDomain("MyDomain"); Console.WriteLine("Host domain: " +
}}
Como determinar um conjunto o nome totalmente qualificado:
Há várias maneiras para descobrir o nome totalmente qualificado de um conjunto no cache de

conjunto global:
• Use o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).

• Exibir o diretório do cache de conjunto de módulos global.
• Use o Global ferramenta cache assembly (Gacutil.exe).
Procedimentos
Para exibir os nomes de conjuntos totalmente qualificados no cache de conjunto global usando a
ferramenta .NET Framework Configuration
1. Clique no Start botão, aponte para Administrative Tools, e clique em Microsoft .NET
Framework Configuration
2. Clique em Manage the Assembly Cache e, clique em View List of Assemblies in the
Assembly Cache.
Para obter informações sobre como usar a ferramenta Global Assembly Cache para exibir os
nomes de conjuntos, totalmente qualificados Consulte Como Visualizar o Conteúdo da Cache
Global de Assemblies.
Do Disassembler MSIL (Ildasm.exe) para conjuntos de módulos (assemblies) que não estão no
cache de conjunto global, você pode usar código para exibir as informações para o console ou a
uma variável, ou você pode usar para examinar metadados do conjunto, que contém o nome
totalmente qualificado.
Para obter mais informações sobre como definir atributos do conjunto, como versão, cultura e
nome do conjunto, consulte Definir atributos Assembly. Para obter mais informações sobre dar um
conjunto um nome de alta segurança, consulte Criando e usando assemblies de nome forte.
Exemplo

O exemplo de código a seguir mostra como exibir o nome totalmente qualificado de um conjunto
que contém uma classe especificada para o console.
C#
using System; using System.Reflection; class asmname { public static void Main() { Type t =
typeof(System.Data.DataSet); string s = t.Assembly.FullName.ToString(); Console.WriteLine("The fully
qualified assembly name containing the specified class is {0}.", s); } } Imports System Imports
System.Reflection Imports Microsoft.VisualBasic ' For a class not contained in mscorlib.dll, compile this code
with ' the /r:<dllname> option; for example,compile the code below using: ' vbc asmname.vb
/r:System.Data.dll /r:System.dll /r:System.Xml.dll ' If the class is contained in mscorlib.dll, the
/r:<dllname> compiler option is unnecessary. Class asmname Public Shared Sub Main() Dim t As Type =
GetType(System.Data.DataSet) Console.WriteLine("The fully qualified assembly name containing the
specified class is {0}.", t.Assembly.FullName.ToString()) End Sub 'Main End Class 'asmname
Você pode fornecer o Common Language Runtime com informações de configuração para um
novo domínio do aplicativo usando a AppDomainSetup classe. Ao criar seus próprios domínios de
aplicativo, a propriedade mais importante é ApplicationBase. As outras AppDomainSetup
propriedades são usadas principalmente por hosts de tempo de execução para configurar um
domínio aplicativo específico.
A ApplicationBase propriedade Define o Diretório de raiz do aplicativo. Quando o Runtime

precisa atender uma requisição tipo, ele investiga para o conjunto que contém o tipo no diretório
especificado pela propriedade ApplicationBase.
Observação
Um novo domínio do aplicativo herdará apenas a ApplicationBase propriedade do criador.
O exemplo a seguir cria uma instância da classe AppDomainSetup, usa esta classe para criar um
novo domínio do aplicativo, grava as informações ao console, e depois descarrega o domínio do
aplicativo.
Exemplo
C#
using System; using System.Reflection; class AppDomain4 { public static void Main() { // Create application
domain setup information. AppDomainSetup domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = "f:\\work\\development\\latest"; // Create the application domain.
AppDomain domain = AppDomain.CreateDomain("MyDomain", null, domaininfo); // Write application
domain information to the console. Console.WriteLine("Host domain: " +
Console.WriteLine("Application base is: " + domain.SetupInformation.ApplicationBase); // Unload the
application domain. AppDomain.Unload(domain); } }

Você pode usar para exibir informações linguagem intermediária (MSIL) Microsoft em um arquivo.
o Disassembler MSIL (Ildasm.exe) Se o arquivo sendo examinado for um conjunto, essas
informações podem incluir atributos do conjunto,, bem como referências a outros módulos e
conjuntos. Essas informações podem ser útil para determinar se um arquivo é um conjunto ou
parte de um conjunto, e se o arquivo possui referências a outros módulos ou conjuntos.
Para exibir o conteúdo de um conjunto usando Ildasm.exe

• Type ildasm <assembly name> at the command prompt. Por exemplo, o comando a seguir
desmonta o Hello.exe conjunto.
ildasm Hello.exe
Para exibir informações manifesto do conjunto

• Clique duas vezes no ícone MANIFEST na janela Disassembler MSIL.
Exemplo
O exemplo a seguir inicia com " Um Hello, básico " World programa. Depois compilar o programa,
use Ildasm.exe para desmontar o conjunto Hello.exe e exibir o manifesto do conjunto.
Visual Basic
Imports System Public Module modmain Sub Main() Console.WriteLine ("Hello World using Visual Basic!")
End Sub End Module using System; class MainApp { public static void Main() { Console.WriteLine("Hello
World using C#!"); } } #using <mscorlib.dll> using namespace System; void main() {
Console::WriteLine(L"Hello World using Managed Extensions!"); }
Executando o ildasm.exe Comando no conjunto Hello.exe e duas vezes no ícone MANIFEST na

janela DASM IL produz o seguinte resultado:
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 1:0:2411:0 }

.assembly Hello { // --- The following custom attribute is added automatically; do not uncomment. ------- //
.custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(bool, // bool) = ( 01 00 00
01 00 00 ) .hash algorithm 0x00008004 .ver 0:0:0:0 } .module Hello.exe // MVID: {58AD9DFD-63A6-
462A-8AD5-42CBC95AA147} .subsystem 0x00000003 .file alignment 512 .corflags 0x00000001 // Image
base: 0x03330000
A tabela a seguir descreve cada diretiva no conjunto do manifesto da montagem Hello.exe usado
no exemplo.
Diretiva Descrição
.assembly extern Especifica outro conjunto que contém itens referenciados pelo módulo
<assembly name> atual (, neste exemplo, mscorlib).
.publickeytoken <token> Especifica o símbolo da chave real da montagem referenciada.
.ver <version number> Especifica o número de versão da montagem referenciada.
.assembly <assembly Especifica o nome do conjunto.
name>
.hash algorithm <int32 Especifica o algoritmo hash usado.
value>
.ver <version number> Especifica o número de versão do conjunto.

.module <file name> Especifica o nome dos módulos que compõem o conjunto. Neste
exemplo, o conjunto consiste em apenas um arquivo.
.subsystem <value> Especifica o ambiente do aplicativo necessário para o programa. Neste
exemplo, o valor 3 indica que este executável é executado de um
console.
corflags Atualmente um campo reservado nos metadados.
Um manifesto do conjunto pode conter um número de diretivas diferentes, dependendo do

conteúdo do conjunto. Para obter uma lista abrangente das diretivas no manifesto do conjunto,
consulte a documentação ECMA, especialmente " ii partição metadados: e semântica " definição e
" partição III: CIL instrução Set ". A documentação está disponível online em
http://msdn.microsoft.com/net/ECMA/ e http://www.ECMA-
International.org/publications/Standards/ECMA-335.htm.
O processo na referência tipos ou recursos em um conjunto de nome seguro é normalmente

transparente. Você pode fazer a referência no tempo de compilação (antecipada ligação) ou em
tempo de execução.
Uma referência em tempo de compilação ocorre quando você indicar o compilador para que seu
conjunto faz referência outro conjunto explicitamente. Quando você usar em tempo de compilação
referência, automaticamente o compilador obtém a chave pública do conjunto de nome seguro de
destino e coloca-na referência do conjunto da montagem sendo compilada.
Observação
Um conjunto de nome seguro só pode usar tipos de outros conjuntos de nome seguro. Caso
contrário a segurança do conjunto de nome seguro deve ser comprometida.
Fazer uma referência a um conjunto de nome seguro em tempo de compilação

< compiler command> /reference:<assembly name>
Neste comando, compiler command é o comando do compilador para o idioma que você está
usando e assembly name é o nome do conjunto de nome seguro sendo referenciado. Você
pode usar outras opções do compilador, como a /t:library opção para criar um conjunto de
biblioteca.
O exemplo a seguir cria um conjunto chamado myAssembly.dll que referências um conjunto de

nome seguro chamado myLibAssembly.dll a partir de um módulo de código chamado
myAssembly.cs.
csc /t:library myAssembly.cs /reference:myLibAssembly.dll
Fazer uma referência a um conjunto de nome seguro em tempo de execução

• Quando você fazer uma referência em tempo de execução a um conjunto de nome seguro,
por exemplo, usando você deve usar o nome de exibição do conjunto de nome seguro
referenciado. ou Assembly.GetType métodos, o Assembly.Load A sintaxe de um nome de
exibição é a seguinte:
< assembly name>, <version number>, <culture>, <public key token>

Por exemplo:
myDll, Version=1.1.0.0, Culture=en, PublicKeyToken=03689116d3a4ae33
Do PublicKeyToken, neste exemplo, é a forma hexadecimal do símbolo de chave pública. Se

houver nenhum valor de cultura, use Culture=neutral.
O exemplo de código a seguir mostra como usar essas informações com o Assembly.Load
método.
C#
Assembly.Load("myDll,Version=1.0.0.1,Culture=neutral,PublicKeyToken=9b35aa32c18d4fb1");
Você pode imprimir o formato hexadecimal da chave pública e símbolo de chave pública para um
conjunto específico usando o seguinte Ferramenta nome forte (SN.exe) Comando:
sn -Tp <assembly>
Se você tiver um arquivo chave público, use o seguinte comando em vez disso (observe a
diferença no caso com a opção de linha de comando):: (observe a diferença no caso com a opção
de linha de comando)
sn -tp <assembly>
Como: Descarregar um domínio de aplicativo
Quando você tiver terminado usando um domínio de aplicativo, descarregá-lo usando o

System.AppDomain.Unload método. O Unload método normalmente desliga o domínio do
aplicativo especificado. Durante o processo descarregando, nenhum novo segmento pode
acessar o domínio de aplicativo, e são liberadas estruturas dados específicos de domínio – do
aplicativo todos os.
Conjuntos carregados no domínio de aplicativo são removidas e não estão mais disponíveis. Se
um conjunto no domínio do aplicativo é domínio neutro-, dados para o conjunto permanece na
memória até que o processo inteiro é desligado. Não há nenhum mecanismo para descarregar um
conjunto-domínio neutro diferente desligar o processo inteiro. Há situações em que a solicitação
para descarregar um domínio de aplicativo não funciona e resulta em um
CannotUnloadAppDomainException.. um CannotUnloadAppDomainException
O exemplo a seguir cria um novo domínio denominado MyDomain do aplicativo, imprime algumas
informações ao console, e depois descarrega o domínio do aplicativo. Observe que o código tenta
imprimir o nome amigável do domínio do aplicativo descarregado para o console. Essa ação gera
uma exceção que é tratada pelas instruções try / catch no final do programa.
Exemplo
C#
AppDomain.CreateDomain("MyDomain", null); Console.WriteLine("Host domain: " +
AppDomain.Unload(domain); try { Console.WriteLine(); Console.WriteLine("Host domain: " +
AppDomain.CurrentDomain.FriendlyName); // The following statement creates an exception because the

domain no longer exists. Console.WriteLine("child domain: " + domain.FriendlyName); } catch
(AppDomainUnloadedException e) { Console.WriteLine("The appdomain MyDomain does not exist."); } } }
Do Ferramenta Assembly Cache global (Gacutil.exe) uso para remover um conjunto de cache de
conjunto global.
Para remover um conjunto de cache de conjunto global

gacutil –u <assembly name>
Neste comando, assembly name é o nome da montagem para remover do cache de conjunto
global.
O exemplo a seguir remove um conjunto chamado hello.dll do cache de conjunto global.
gacutil -u hello
pode usar para remover conjuntos de cache de conjunto global. o Visualizador cache do conjunto
(Shfusion.dll),
Existem quatro maneiras para instalar um conjunto no cache de conjunto global:
• Usando o Ferramenta Assembly Cache global (Gacutil.exe).

Você pode usar Gacutil.exe para adicionar conjuntos de nome seguro de cache de conjunto
global e para exibir o conteúdo do cache de montagem global.
Observação
Gacutil.exe serve apenas para fins de desenvolvimento e não deve ser usado para instalar
conjuntos de produção no cache de conjunto global.
• Usando o Microsoft Windows Installer 2.0.

Essa é a maneira recomendada e mais comum para adicionar conjuntos de cache de conjunto
global. O instalador fornece referência Contagem de conjuntos no cache de conjunto global, e
outros benefícios.
• Usando uma extensão do shell do Windows fornecido pelo SDK do .NET Framework
chamado o Visualizador cache do conjunto (Shfusion.dll).
A extensão do shell permite que você a arrastar conjuntos para cache de conjunto global.
• Usando o Ferramenta Configuração estrutura .NET (Mscorcfg.msc).
O Ferramenta Configuração estrutura .NET (Mscorcfg.msc) permite que você se exibir o cache
de conjunto de módulos global e adicionar novos conjuntos de no cache.
Para instalar um conjunto de nome seguro no cache de conjunto global usando a ferramenta
Global Assembly Cache (Gacutil.exe)

gacutil –I <assembly name>
Neste comando, assembly name é o nome da montagem para instalar em cache de conjunto
global.
O exemplo a seguir instala um conjunto com o nome hello.dll de arquivo no cache de conjunto
global.
gacutil -i hello.dll
Esta seção descreve o procedimento utilizado para criar um conjunto de vários arquivos e fornece
um exemplo completo que ilustra cada uma das etapas no procedimento.
Para criar um conjunto de vários arquivos

1. Compilar todos os arquivos que contêm espaços para nome referido por outros módulos
na montagem em módulos de código. A extensão padrão para módulos de código
é.netmodule. Por exemplo, se criar um arquivo chamado Stringer espaço para nome
chamada myStringer que é referenciado no arquivo Código do cliente, Stringer deve ser
compilado em um módulo de código primeiro.
2. Compilar todos os outros módulos, usando as opções do compilador necessário para
indicar os outros módulos que são referenciados no código.
3. Do Vinculador do conjunto (AL.exe) uso para criar o arquivo de saída que contém o
manifesto do conjunto. Esse arquivo contém informações de referência para todos os
módulos ou recursos que fazem parte do conjunto.
Observação
O Visual Studio 2005 IDE de C# e Visual Basic poderá somente usar para criar conjuntos de
Arquivo Único. Se você desejar criar vários arquivos conjuntos, deve usar os compiladores de
linha de comando ou Visual Studio 2005 com Visual C++.. ou Visual Studio 2005 com Visual C++
O exemplo a seguir ilustra a etapa 1 do procedimento acima, por compilação arquivos com
espaços para nome referido por outros arquivos. Este exemplo inicia com alguns código simples
para o Stringer arquivo. Espaço para nome chamado myStringer com uma classe chamado
StringerStringer. A Stringer classe contém um método chamado StringerMethod que grava uma
única linha para o console.
C#
// Assembly building example in the .NET Framework SDK. using System; namespace myStringer { public
class Stringer { public void StringerMethod() { System.Console.WriteLine("This is a line from
StringerMethod."); } } }
C#
csc /t:module Stringer.cs

Especificando o module parâmetro com a /t: opção de compilador indica que o arquivo deve ser
compilado como um módulo em vez de como um conjunto. O compilador produz um módulo
chamado Stringer.netmodule, que pode ser adicionado a um conjunto.
Na Etapa dois do procedimento acima, você deve compilar módulos com referências a outros
módulos. Essa etapa usa a /addmodule opção de compilador. No exemplo a seguir, um módulo
de código chamado Client tem um método ponto Main de entrada que referencia um método no
módulo Stringer.dll criado na etapa 1.
O exemplo a seguir mostra o código para Client.
C#
using System; using myStringer; //The namespace created in Stringer.netmodule. class MainClientApp { //
Static method Main is the entry point method. public static void Main() { Stringer myStringInstance = new
Stringer(); Console.WriteLine("Client code executes"); //myStringComp.Stringer();
myStringInstance.StringerMethod(); } }
C#
csc /addmodule:Stringer.netmodule /t:module Client.cs
Especificar a /t:module opção porque este módulo irá ser adicionado a uma montagem em uma
etapa futura. Especificar a /addmodule opção porque o código em Client Referências criado pelo
código em Stringer.netmodule um espaço para nome. O compilador produz um módulo chamado
Client.netmodule que contém uma referência a outro módulo, Stringer.netmodule.
Observação
O C# e Visual Basic compiladores suportam diretamente criação usando as seguintes sintaxes

diferentes dois conjuntos de vários arquivos.
• Dois compilations criar um conjunto-dois arquivos:

C#
csc /t:module Stringer.cs csc Client.cs /addmodule:Stringer.netmodule
• Uma compilação cria um conjunto-dois arquivos:

C#
csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
Do Vinculador do conjunto (AL.exe) você pode usar para criar um conjunto de uma coleção de
compilado módulos de código.
Para criar um conjunto de vários arquivos usando o vinculador assembly

al <module name> <module name> … /main:<method name> /out:<file name>
/target:<assembly file type>

Os module name argumentos neste comando, especifique o nome de cada módulo para incluir
no conjunto. A /main: opção especifica o nome do método que é ponto de entrada do conjunto.
A /out: opção especifica o nome do arquivo de saída, que contém metadados do conjunto. A
/target: opção especifica que o conjunto é um arquivo executável (.exe) do aplicativo Console,
um arquivo executável (.Win) do Windows, ou um arquivo biblioteca (.lib).
No exemplo a seguir, a Al.exe cria um conjunto que é um aplicativo de console executável

chamado myAssembly.exe. O aplicativo consiste de dois módulos chamados Client.netmodule e
Stringer.netmodule. e o arquivo executável chamado myAssembly.exe, que contém somente
metadados conjunto O ponto de entrada do conjunto é o Main método na classe MainClientApp,
que está localizado em Client.dll.
al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
Do Disassembler MSIL (Ildasm.exe) você pode usar para examinar o conteúdo de um conjunto ou
determinar se um arquivo é um conjunto ou um módulo.
No.NET Framework, existem várias maneiras para carregar um conjunto em um domínio de

aplicativo. Cada forma usa uma classe diferente.
Você pode usar os seguintes métodos sobrecarregados para carregar um conjunto em um

domínio de aplicativo:
• A System.AppDomain classe contém vários métodos sobrecarregados Carga. Esses

métodos principalmente são usados para interoperabilidade com, embora eles podem ser
usados para carregar qualquer conjunto na atual ou um novo domínio do aplicativo com êxito.
Também é possível carregar um conjunto usando os CreateInstance métodos.
• A System.Reflection.Assembly classe contém dois métodos sobrecarregados estáticos,
Carga e LoadFrom. Os dois métodos variar pelo contexto de carga.
O exemplo seguinte carrega um conjunto no domínio de aplicativo atual e executa o conjunto.

Para uma discussão completa sobre como obter informações de um conjunto carregado, consulte
Carregar dinamicamente e Usando tipos.
Observação
Na versão do .NET Framework 2.0 domínios do aplicativo possuem um contexto somente

Reflection-. Conjuntos carregados neste contexto podem ser examinados mas não executado,
permitindo exame de conjuntos que destino outras plataformas. Consulte Como Carregar
Assemblies no Contexto Somente de Reflexão e ReflectionOnlyLoad.
Exemplo
C#
using System; using System.Reflection; public class Asmload0 { public static void Main () { // Use the file
name to load the assembly into the current application domain. Assembly a =
Assembly.LoadFrom("adname.exe"); //Get the type to use. Type myType = a.GetType("adname"); //Get the
method to call. MethodInfo mymethod = myType.GetMethod("adnamemethod"); //Create an instance.
Object obj = Activator.CreateInstance(myType); //Execute the adnamemethod method.
mymethod.Invoke(obj,null); } }

COMO: Assinar uma Assembly com Nome Forte
Há duas maneiras para assinar um conjunto com um nome de alta segurança:
• Do Vinculador do conjunto (AL.exe) Usando fornecido pelo .NET Framework SDK.

• Usando atributos do conjunto para inserir as informações de nome de alta segurança em
seu código. Você pode usar ou AssemblyKeyFileAttribute a AssemblyKeyNameAttribute,
dependendo da onde o arquivo de chave a ser usado está localizado.
Você deve ter um par de chaves de criptografia para assinar um conjunto com um nome de alta
segurança. Para obter mais informações sobre como criar um par de chaves, consulte Como criar
um par de chaves pública / Private:.
Para criar e assinar um conjunto com um nome de alta segurança usando o vinculador assembly
al /out:<assembly name> <module name> /keyfile:<file name>
Neste comando, assembly name é o nome da montagem para entrar com um nome de alta
segurança, module name é o nome do módulo do código usado para criar o conjunto, e file
name é o nome do recipiente ou arquivo que contém o par de chaves.
O exemplo a seguir assina o conjunto MyAssembly.dll com um nome de alta segurança usando o
arquivo sgKey.snk de chave.
al /out:MyAssembly.dll MyModule.netmodule /keyfile:sgKey.snk
Para assinar um conjunto com um nome de alta segurança com atributos
• Entre um módulo de código, adicione o AssemblyKeyFileAttribute ou o

AssemblyKeyNameAttribute, especificando o nome do arquivo ou recipiente que contém o
par de chaves para usar ao assinar o conjunto com um nome de alta segurança.
Do AssemblyKeyFileAttribute exemplo usa o seguinte código com um arquivo de chave

chamado sgKey.snk, localizado na pasta onde o conjunto é compilado. Isso pressupõe que o
conjunto é compilado usando o vbc.exe Compiladores de linha de comando e csc.exe.
C#
[assembly:AssemblyKeyFileAttribute(@"sgKey.snk")]
Observação
Em ambientes de desenvolvimento, como Visual Studio, o conjunto não pode ser compilado no
diretório do projeto. Por exemplo, algumas versões do Visual Studio Compilar projetos C# em um
bin\Debug subdiretório. Nesse caso, o caminho no exemplo de código seria ".. \\ \\sgKey.snk ". No
Visual Studio 2005 arquivo de chave no C# pode ser especificado nas configurações do projeto.

código.

Do Ferramenta Assembly Cache global (Gacutil.exe) uso para exibir o conteúdo do cache de
montagem global.
Para exibir uma lista das montagens no cache de conjunto global

l Gacutil –
pode usar para exibir o conteúdo do cache de conjunto global. o Visualizador cache do conjunto
(Shfusion.dll),
Para assinar um conjunto com um nome de alta segurança, você deve ter um par de chaves
pública / particular Criptografia esse par de chaves pública e privada é usado durante a
compilação para criar um conjunto de nome seguro. Você pode criar um par de chaves usando o
Ferramenta nome forte (SN.exe). Par de Chaves arquivos geralmente têm uma extensão.snk.
Para criar um par de chaves

sn –k <file name>
Neste comando, file name é o nome do arquivo de saída que contém o par de chaves.
O exemplo a seguir cria um par de chaves denominado sgKey.snk.
sn -k sgKey.snk
Se você pretende atrasar a assinatura um conjunto e você controlar o par de chaves toda (que é
improvável fora cenários de teste), você pode usar o seguinte comandos para gerar um par de
chaves e então extrair a chave pública em um arquivo separado. Primeiro, crie o par de chaves:
sn -k keypair.snk
• Em seguida, extrair a chave pública do par de chaves e copiá-la para um arquivo

separado:
sn -p keypair.snk public.snk
• Assim que você criar o par de chaves, você deve colocar o arquivo em que ele pode
localizar o nome de alta segurança assinatura ferramentas.

código.
Se você estiver usando um IDE, tais como Visual Studio 2005, para assinar um conjunto com um
nome de alta segurança, é necessário compreender onde o IDE procura o arquivo de chave. Por
exemplo, Visual Basic 2005 procura pelo arquivo de chave no diretório que contém a Solução
Visual Studio, enquanto o compilador C# procura o arquivo de chave no diretório que contém o
binário. Coloque o arquivo de chave no diretório do projeto adequado e defina o atributo de
arquivo da seguinte maneira:

C#
[assembly: AssemblyKeyFileAttribute(@"..\..\key.snk")]
Você pode compactar uma biblioteca de tipos como um arquivo separado ou incorporá-lo como
arquivo recurso Win32 dentro de um aplicativo baseado em .NET. O Microsoft Visual Basic 6.0
executado essa tarefa para você automaticamente; no entanto, ao usar Microsoft Visual Basic
2005, você deve incorporar sua biblioteca tipo manualmente.
Para incorporar uma biblioteca de tipos como um recurso do Win32 em um aplicativo baseado em
.NET
1. Compilar o aplicativo gerenciado como um arquivo de biblioteca. Por exemplo, para criar
um conjunto para um aplicativo chamado MyApp, digite o seguinte comando no prompt de
comando:
C#
csc /t:library MyApp.cs
2. Exportar um arquivo biblioteca tipo do seu conjunto usando o Tipo Exporter da biblioteca
(TlbExp.exe). No prompt de comando, digite o seguinte comando:
tlbexp MyApp.dll /out:mytypelib.tlb

IDR_TYPELIB1 typelib "mytypelib.tlb"
Para este exemplo, o nome de arquivo script é myresource.rc.

rc myresource.rc

5. Compile o arquivo de origem novamente e especifique o arquivo de recurso. No prompt de
Visual Basic
vbc /t:library MyApp.vb /win32res:myresource.res
C#
csc /t:library MyApp.cs /win32res:myresource.res
A maneira mais simples para produzir conjuntos de interoperabilidade primárias consiste em usar
o Importador de Biblioteca de Tipos (TLBIMP.exe).
Para gerar um conjunto de interoperabilidade primário usando TLBIMP.exe

tlbimp tlbfile /primary /keyfile:filename /out:assemblyname

Neste comando, tlbfile é o arquivo que contém a biblioteca de tipos COM, filename é o nome do
recipiente ou arquivo que contém o par de chaves e assemblyname é o nome da montagem
para entrar com um nome de alta segurança.
Conjuntos de interoperabilidade primárias podem referenciar apenas outros conjuntos de

interoperabilidade primárias. Se seu conjunto faz referência tipos de uma biblioteca de tipos com
de terceiros, você deverá obter um conjunto interoperacional primário do editor antes você pode
gerar seu conjunto interoperacional primário. Se você for o editor, você deve gerar um conjunto de
interoperabilidade primário para a biblioteca de tipos dependente antes de gerar conjunto de
módulos (assembly referência o) de interoperabilidade primária.
Primário um conjunto interoperacional dependente com um número de versão que seja diferente
da biblioteca de tipos original é não localizável quando instalado no diretório atual. Você deve
registrar Principal conjunto interoperacional do dependente no Registro do Windows ou use a
/reference Opção para ter certeza que localiza TLBIMP.exe a DLL dependente.
Você também poderá dispor várias versões de uma biblioteca de tipos. Para obter instruções,
consulte Como Empacotar Várias Versões de Bibliotecas de Tipos.
Exemplo
O exemplo a seguir importa a biblioteca LibUtil.tlb de tipos COM e assina o conjunto LibUtil.dll
com um nome de alta segurança usando o arquivo CompanyA.snk de chave. Omitindo um nome de
espaço para nome específico, este exemplo produz o espaço para nome LibUtil padrão.
Para um nome mais descritivo). (usando, o exemplo a seguir substitui o nome de arquivo do
conjunto padrão e nome namespace nomeação diretriz. LibraryName o VendorName
tlbimp LibUtil.tlb /primary /keyfile:CompanyA.snk /namespace:CompanyA.LibUtil

/out:CompanyA.LibUtil.dll
O exemplo a seguir importa MyLib.tlb, quais referências CompanyA.LibUtil.dll, e assina o conjunto

CompanyB.MyLib.dll com um nome de alta segurança usando o arquivo CompanyB.snk de chave.
Espaço para nome, CompanyB.MyLib,. substitui o nome de espaço para nome padrão
tlbimp MyLib.tlb /primary /keyfile:CompanyB.snk /namespace:CompanyB.MyLib

/reference:CompanyA.LibUtil.dll /out:CompanyB.MyLib.dll
Uma abordagem menos usada para produzir uma biblioteca de tipos envolve criar um conjunto de
interoperabilidade primário manualmente no código fonte, usando uma linguagem que é
compatível com o COM comum especificação (cls), como C# idioma. Essa abordagem é útil
quando uma biblioteca de tipos não está disponível.
Para gerar um conjunto interoperacional primário no código fonte

1. Crie um conjunto de interoperabilidade no código fonte. Para obter instruções, consulte
Criando um wrapper manualmente. Observação Se você deve incluir todos os tipos COM da
biblioteca Tipo original quando você cria um conjunto de interoperabilidade primário
manualmente.
2. No nível do conjunto, aplicar os seguintes atributos:

1. ou AssemblyKeyFileAttributeAssemblyKeyNameAttribute, para especificar o nome
do arquivo ou recipiente que contém o par de chaves para usar ao assinar o conjunto
com um nome de alta segurança.
2. GuidAttribute Para especificar o identificador de biblioteca (LIBID) da biblioteca de
tipos de destino.
3. PrimaryInteropAssemblyAttribute Para identificar o conjunto como um conjunto
Observação
3. O exemplo de código a seguir aplica chamado CompanyA.snk com um arquivo de chave e

especifica que este conjunto de módulos (assembly) é um conjunto de interoperabilidade
primário suporte versões de biblioteca tipo 4.2 e 5.2. o AssemblyKeyFileAttribute Como
mostra o exemplo, você pode dispor mais de uma versão de uma biblioteca tipo Aplicando
atributos adicionais conjunto-nível.
C#
[assembly:AssemblyKeyFile(@"..\..\CompanyA.snk")] [assembly:Guid("97d25db0-0363-1cf-abc4-02608
c9e7553"] [assembly:PrimaryInteropAssembly(4, 2)] [assembly:PrimaryInteropAssembly(5, 2)]
O Importador da biblioteca Tipo (TLBIMP.exe) é uma ferramenta de linha de comando que

converte o coclasses e interfaces contidos em uma biblioteca de tipos com aos metadados. Essa
ferramenta cria um conjunto interoperacional e espaço para nome para as informações tipo
automaticamente. Depois os metadados de uma classe estiver disponível, clientes gerenciados
podem criar instâncias do tipo COM e chamar seus métodos, apenas como se fosse uma
instância .NET. TLBIMP.exe converte uma biblioteca inteira tipo aos metadados de uma vez e não
pode gerar informações sobre tipo de um subconjunto dos tipos definidas em uma biblioteca de
tipos.
Para gerar um conjunto de interoperabilidade de uma biblioteca de tipos

• Use o seguinte comando:
TLBIMP < type-library-file>
Adicionando a /out: opção produz um conjunto de interoperabilidade com um nome alterada,
como LOANLib.dll. Alterar o nome Conjunto interoperacional pode ajudar a distingui-lo da DLL
com original e evitar problemas que podem ocorrer tenham nomes duplicados.
Exemplo
O seguinte comando produz o conjunto Loanlib.DLL no espaço para nome Loanlib.
tlbimp Loanlib.dll
O seguinte comando produz um conjunto de interoperabilidade com um nome alterada

(LOANLib.dll).
tlbimp LoanLib.dll /out: LOANLib.dll

Framework, não Consulte Manipulando e disparando eventos. Para obter detalhes específicos que
se aplicam a este tópico, consulte Disparar um evento na mesma seção.
O.NET Framework fornece um sistema baseado em delegate-evento para conectar-se um

remetente de evento (origem) a um destinatário de evento (PIA). Quando o coletor é um cliente
COM, a origem deve incluir elementos para simular pontos de conexão adicionais. Com essas
modificações, um cliente COM pode registrar sua interface do coletor de eventos no modo
tradicional chamando o IConnectionPoint::Advise método. (Visual Basic oculta detalhes ponto
de conexão, para que não faça precise chamar esses métodos diretamente.)
Para interoperar com um coletor de eventos com

1. Definir a interface do coletor de eventos no código gerenciado. Esta interface pode conter
um subconjunto dos eventos sourced por uma classe gerenciado. Os nomes método da
interface deve ser a mesma os nomes de eventos.
2. Do ComSourceInterfacesAttribute aplicar se conectar a interface do coletor de eventos a
classe gerenciada.
3. Exportar o conjunto que contém a classe para uma biblioteca de tipos. Use API equivalente
ou Tipo Exporter da biblioteca (TlbExp.exe) um para exportar o conjunto.
4. Implementar a interface do coletor de eventos em COM.
5. Para clientes com que coletar eventos, implementar a interface do coletor de eventos
definido pela fonte de eventos na sua biblioteca de tipos. Usar o mecanismo ponto de
conexão para conectar-se a interface do coletor à fonte de eventos.
Exemplo
O exemplo a seguir mostra um servidor gerenciado como a origem de eventos e um cliente COM
como o coletor de eventos. O servidor gerenciado declara ButtonEvents como uma interface do
coletor de eventos e se conecta a interface a Button classe. O cliente não gerenciado cria uma
instância da classe Button e implementa a interface do coletor de eventos.
Visual Basic
' Managed server (event source) Option Explicit Option Strict Imports System Imports
System.Runtime.InteropServices Namespace EventSource Public Delegate Sub ClickDelegate(x As Integer, y
As Integer) Public Delegate Sub ResizeDelegate() Public Delegate Sub PulseDelegate() ' Step 1: Defines an
event sink interface (ButtonEvents) to be ' implemented by the COM sink. <GuidAttribute("1A585C4D-3371-
48dc-AF8A-AFFECC1B0967"), _ InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)> _ Public
Interface ButtonEvents Sub Click(x As Integer, y As Integer) Sub Resize() Sub Pulse() End Interface ' Step 2:
Connects the event sink interface to a class ' by passing the namespace and event sink interface '
("EventSource.ButtonEvents, EventSrc"). <ComSourceInterfaces(GetType(ButtonEvents))> _ Public Class
Button Public Event Click As ClickDelegate Public Event Resize As ResizeDelegate Public Event Pulse As
PulseDelegate Public Sub CauseClickEvent(x As Integer, y As Integer) RaiseEvent Click(x, y) End Sub Public
Sub CauseResizeEvent() RaiseEvent Resize() End Sub Public Sub CausePulse() RaiseEvent Pulse() End Sub
End Class End Namespace using System; using System.Runtime.InteropServices; namespace EventSource {
public delegate void ClickDelegate(int x, int y); public delegate void ResizeDelegate(); public delegate void
PulseDelegate(); // Step 1: Defines an event sink interface (ButtonEvents) to be // implemented by the COM
sink. [GuidAttribute("1A585C4D-3371-48dc-AF8A-AFFECC1B0967") ]

[InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)] public interface ButtonEvents { void
Click(int x, int y); void Resize(); void Pulse(); } // Step 2: Connects the event sink interface to a class // by
passing the namespace and event sink interface // ("EventSource.ButtonEvents, EventSrc").
[ComSourceInterfaces(GetType(ButtonEvents))] public class Button { public event ClickDelegate Click;
public event ResizeDelegate Resize; public event PulseDelegate Pulse; public Button() { } public void
CauseClickEvent(int x, int y) { Click(x, y); } public void CauseResizeEvent() { Resize(); } public void
CausePulse() { Pulse(); } } } ' COM client (event sink) ' This Visual Basic 6.0 client creates an instance of the
Button class and ' implements the event sink interface. The WithEvents directive ' registers the sink interface
pointer with the source. Public WithEvents myButton As Button Private Sub Class_Initialize() Dim o As
Object Set o = New Button Set myButton = o End Sub ' Events and methods are matched by name and
signature. Private Sub myButton_Click(ByVal x As Long, ByVal y As Long) MsgBox "Click event" End Sub
Private Sub myButton_Resize() MsgBox "Resize event" End Sub Private Sub myButton_Pulse() End Sub
Há duas maneiras para personalizar um wrapper Callable Runtime (RCW). Se você pode
modificar a fonte interface Definition Language (IDL), você pode aplicar atributos de arquivo (tlb)
de biblioteca Tipo e importar a biblioteca de tipos Como alternativa, você pode aplicar atributos
específicos interop-a tipos importados e gerar um novo conjunto. Suporte para personalizar RCWs
padrão é limitado por esses atributos.
Para modificar a fonte IDL

1. Se aplicam atributos TLB a bibliotecas, tipos, membros, e parâmetros. Use a custom
palavra-chave e um valor de atributo para alterar metadados. Aplicando atributos TLB, você
pode:
o Especifique o nome de um tipo COM importados, em vez de permitir que o Utilitário
de Importação para selecionar o nome de acordo com regras conversão padrão gerenciado.
o Definir um espaço para nome de destino para os tipos em uma biblioteca com
explicitamente.
2. Compilar o código fonte IDL.
3. Gerar um conjunto do arquivo resultante de biblioteca tipo ou de um arquivo de biblioteca
de vínculo dinâmico (DLL) que contém o tipo que pretende implementar.
Para modificar um conjunto importados
1. Importe o arquivo de biblioteca tipo. Do Importador da biblioteca Tipo (TLBIMP.exe) uso
para gerar um conjunto DLL.
(Ildasm.exe).
3. Aplicar Atributos de interoperabilidade ao arquivo de texto.
4. Gerar um novo conjunto do arquivo de texto modificada usando o Assembler MSIL
(Ilasm.exe).
Ativação livre registro-para componentes baseado em .NET é apenas um pouco mais complicado
que ele é para componentes COM. A instalação requer dois manifestos:
• Aplicativos COM devem ter um manifesto de aplicativo estilo Win32-para identificar o

componente gerenciado.

• Componentes baseado em .NET devem ter um manifesto componente para ativação
informações necessárias em tempo de execução.
Este tópico descreve como associar um manifesto de aplicativo a um aplicativo; associar um

manifesto componente a um componente; e incorporar um manifesto componente em um
conjunto.
Para criar um manifesto de aplicativo

1. Usando um editor XML, criar (ou modificar) manifesto de aplicativo pertencentes ao
aplicativo do COM que é interoperar com um ou mais componentes gerenciados.
Para informações sobre elementos manifesto e seus atributos, procure por " Reference
Manifests Application " na Biblioteca do MSDN.
3. Identificar o proprietário do manifesto. No exemplo a seguir, myComApp Versão 1 possui o
name="myOrganization.myDivision.myComApp" version="1.0.0.0" processorArchitecture="x86" />
4. Identificar conjuntos de módulos (assemblies) dependentes. No exemplo a seguir,

myComApp depende da myManagedComp.
name="myOrganization.myDivision.myComApp" version="1.0.0.0" processorArchitecture="x86"
publicKeyToken="8275b28176rcbbef" /> <dependency> <dependentAssembly> <assemblyIdentity
type="win32" name="myOrganization.myDivision.myManagedComp" version="6.0.0.0"
processorArchitecture="X86" publicKeyToken="8275b28176rcbbef" language="*" />
</dependentAssembly> </dependency> </assembly>
5. Salvar e nomear o arquivo de manifesto. O nome de um manifesto de aplicativo é o nome

do conjunto executável seguido pela extensão.manifest. Por exemplo, o nome arquivo
manifesto do aplicativo para myComApp.exe é myComApp.exe.manifest
Você pode instalar um manifesto de aplicativo no mesmo diretório como o aplicativo COM. Como
alternativa, você pode adicioná-lo como um recurso para arquivo.exe do aplicativo. Para obter
mais informações, procure por " conjuntos lado a lado na Biblioteca do MSDN ".
Para criar um manifesto componente
1. Usando um editor XML, criar um manifesto componente para descrever o conjunto

gerenciado.
3. Identificar o proprietário do arquivo. O <assemblyIdentity> elemento do elemento

<dependentAssembly> no arquivo de manifesto de aplicativo deve corresponder ao nome

no manifesto do componente. No exemplo a seguir, myManagedComp Versão 1.2.3.4 possui o
publicKeyToken="8275b28176rcbbef"
4. Identificar cada classe no conjunto. Use o <clrClass> elemento para identificar

exclusivamente cada classe no conjunto de módulos (assembly) gerenciado. O elemento,
que é um subelemento do elemento <assembly> tem dos atributos descritos na tabela a
seguir.
Atributo Descrição Required

Clsid O identificador que especifica a classe para ser ativado. Sim
description Seqüência que informe ao usuário sobre o componente. Uma Não
seqüência vazia é o padrão.
name Uma seqüência de caracteres que representa a classe gerenciada. Sim
ProgID O identificador a ser usado para ativação vinculados as. Não
threadingModel O modelo de segmentação com. é "Both" o valor padrão. Não
runtimeVersion Este atributo é ignorado. Se o Runtime não está carregado, a versão Não
mais recente será carregada antes da classe é ativado. Caso
contrário, a versão atualmente carregado é usada.
tlbid O identificador da biblioteca de tipos que contém informações sobre Não
a classe tipo.
5. Todas as marcas de atributo diferenciam maiúsculas de minúsculas. Você pode obter

CLSIDs, ProgIDs, segmentação modelos, e a versão de tempo de execução, exibindo a
biblioteca de tipos exportada para o conjunto com o ObjectViewer OLE / com (Oleview.exe).
6. O manifesto componente a seguir identifica uma classe única com dois métodos.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <assembly xmlns="urn:schemas-microsoft-
com:asm.v1" manifestVersion="1.0"> <assemblyIdentity
publicKeyToken="8275b28176rcbbef" <clrClass clsid="{65722BE6-3449-4628-ABD3-74B6864F9739}"
progid="myManagedComp.testClass1" threadingModel="Both" name="myManagedComp.testClass1"
runtimeVersion="v1.0.3705"> </clrClass> <clrClass clsid="{367221D6-3559-3328-ABD3-
45B6825F9732}" progid="myManagedComp.testClass2" threadingModel="Both"
name="myManagedComp.testClass2" runtimeVersion="v1.0.3705"> </clrClass> <file
name="MyManagedComp.dll"> </file> </assembly>
7. Salvar e nomear o arquivo de manifesto. O nome do componente um manifesto é o nome

da biblioteca do conjunto seguida pela extensão.manifest. Por exemplo, o
myManagedComp.dll é myManagedComp.manifest.
Você deve incorporar o manifesto componente como um recurso no conjunto.
Para incorporar um manifesto componente em um conjunto gerenciado

RT_MANIFEST 1 myManagedComp.manifest

Nesta instrução myManagedComp.manifest é o nome do manifesto componente sendo
incorporado. Para este exemplo, o nome de arquivo script é myresource.rc.
rc myresource.rc
3. Compilar arquivo de origem do conjunto novamente e especifique o arquivo de recurso
usando a /win32res opção:
/win32res:myresource.res
Novamente, myresource.res é o nome do arquivo de recurso contendo recurso incorporado.
O procedimento e exemplo a seguir demonstram como um aplicativo gerenciado, usando

plataforma chamar, pode imprimir o valor o identificador de cada janela para o computador local.
Especificamente, o procedimento e exemplo use a EnumWindows função a que o guiará pela
lista de janelas e uma função de retorno de chamada gerenciado (denominada CallBack) para
imprimir o valor do identificador de janela.
Para implementar uma função de retorno de chamada

1. Examine a assinatura para a EnumWindows função antes passar mais com a
implementação. Possui EnumWindows a assinatura a seguir:
BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
Uma pista que essa função requer um retorno de chamada é a presença do argumento
lpEnumFunc. É comum para ver o lp prefixo (ponteiro longo) combinado com o Func sufixo
do nome do argumentos que se um ponteiro para uma função de retorno de chamada. Para
obter documentação sobre funções Win32, consulte Microsoft Platform SDK.
2. Crie a função de retorno de chamada gerenciado. O exemplo declara um tipo delegate,
que utiliza dois argumentos chamado CallBack, (hwnd e lparam.) O primeiro argumento é
um identificador para a janela; o segundo argumento é definido pelo aplicativo. Nesta
versão, ambos os argumentos devem ser inteiros.
Funções de retorno de chamada geralmente retornam valores diferentes de zero para indicar
êxito e zero para indicar falha. Este exemplo explicitamente define o valor de retorno para
true para continuar a enumeração.
3. Criar um representante e transfira-como um argumento para a EnumWindows função.
Chamar plataforma converte o representante em um formato de retorno de chamada
familiarizado automaticamente.
4. Verifique o coletor de lixo que não não recuperou o representante antes a função de
retorno de chamada conclua seu trabalho. Quando você passar um representante como um
parâmetro, ou passar um representante contido como um campo em uma estrutura, ela
permanece uncollected para a duração da chamada. Portanto, como é o caso no seguinte
exemplo de enumeração, a função de retorno de chamada completa seu trabalho antes da
chamada retorna e não requer nenhuma ação adicional pelo chamador gerenciado.
Se, no entanto, a função de retorno de chamada pode ser chamada depois retorna a
chamada, o chamador gerenciado deverá executar etapas para garantir que o representante
permanece uncollected até terminar a função de retorno de chamada. Para obter
informações detalhadas sobre como evitar coleta de lixo, consulte Interoperabilidade
Marshaling COM Invoke Platform.
Exemplo

C#
using System; using System.Runtime.InteropServices; public delegate bool CallBack(int hwnd, int lParam);
public class EnumReportApp { [DllImport("user32")] public static extern int EnumWindows(CallBack x, int
y); public static void Main() { CallBack myCallBack = new CallBack(EnumReportApp.Report);
EnumWindows(myCallBack, 0); } public static bool Report(int hwnd, int lParam) { Console.Write("Window
handle is "); Console.WriteLine(hwnd); return true; } }
Como: Mapear HRESULTs e exceções
Métodos com Relatar Erros, retornando HRESULTs; Métodos .NET relatá-los por organizando
exceções. Tempo de Execução trata a transição entre os dois. Cada classe de exceção no .NET
Framework mapeia para um HRESULT.
Classes de exceção definida pelo usuário podem especificar qualquer HRESULT é apropriado.
Essas classes de exceção dinamicamente podem alterar o HRESULT a ser retornado quando a
exceção é gerada, definindo o HResult campo no objeto de exceção. Informações adicionais
sobre a exceção é fornecidas para o cliente por meio da IErrorInfo interface, que é implementado
no objeto .NET durante o processo não gerenciado.
Se você criar uma classe que estende System.Exception, deve definir o campo HRESULT
durante construção. Caso contrário, a classe base atribui o valor HRESULT. Você pode mapear
novas classes de exceção para um HRESULT existente, fornecendo o valor no construtor a
exceção é.
Para criar uma nova classe de exceção e mapeá-lo para um HRESULT

• Use o seguinte código para criar uma nova classe de exceção chamado NoAccessException
e mapeá-lo para o HRESULT E_ACCESSDENIED.
C++
Class NoAccessException : public ApplicationException { NoAccessException () { HResult =

E_ACCESSDENIED; } } CMyClass::MethodThatThrows { throw new NoAccessException(); }
Você pode encontrar um programa (em qualquer linguagem de programação) que usa um código
tanto gerenciados e não gerenciados ao mesmo tempo. Por exemplo, o empacotador
personalizado no exemplo de código a seguir usa o Marshal.ThrowExceptionForHR(int
HResult) método para acionar uma exceção com um valor HRESULT específico. O método
procura o HRESULT e gera o tipo de exceção apropriado. Por exemplo, o HRESULT no
fragmento de código a seguir gera ArgumentException.
C++
CMyClass::MethodThatThrows { Marshal.ThrowExceptionForHR(COR_E_ARGUMENT); }
A tabela a seguir fornece o mapeamento completo de cada HRESULT à sua classe de exceção
comparável no .NET Framework.
HRESULT Exceção .NET

MSEE_E_APPDOMAINUNLOADED AppDomainUnloadedException
COR_E_APPLICATION ApplicationException
COR_E_ARGUMENT ou E_INVALIDARG ArgumentException
COR_E_ARGUMENTOUTOFRANGE ArgumentOutOfRangeException
COR_E_ARITHMETIC ou ArithmeticException
ERROR_ARITHMETIC_OVERFLOW
COR_E_ARRAYTYPEMISMATCH ArrayTypeMismatchException
COR_E_BADIMAGEFORMAT ou BadImageFormatException
ERROR_BAD_FORMAT
COR_E_COMEMULATE_ERROR COMEmulateException
COR_E_CONTEXTMARSHAL ContextMarshalException
COR_E_CORE CoreException
NTE_FAIL CryptographicException
COR_E_DIRECTORYNOTFOUND ou DirectoryNotFoundException
ERROR_PATH_NOT_FOUND
COR_E_DIVIDEBYZERO DivideByZeroException
COR_E_DUPLICATEWAITOBJECT DuplicateWaitObjectException
COR_E_ENDOFSTREAM EndOfStreamException
COR_E_TYPELOAD EntryPointNotFoundException
COR_E_EXCEPTION Exceção
COR_E_EXECUTIONENGINE ExecutionEngineException
COR_E_FIELDACCESS FieldAccessException
COR_E_FILENOTFOUND ou FileNotFoundException
ERROR_FILE_NOT_FOUND
COR_E_FORMAT FormatException
COR_E_INDEXOUTOFRANGE IndexOutOfRangeException
COR_E_INVALIDCAST ou E_NOINTERFACE InvalidCastException
COR_E_INVALIDCOMOBJECT InvalidComObjectException
COR_E_INVALIDFILTERCRITERIA InvalidFilterCriteriaException
COR_E_INVALIDOLEVARIANTTYPE InvalidOleVariantTypeException
COR_E_INVALIDOPERATION InvalidOperationException
COR_E_IO IOException
COR_E_MEMBERACCESS AccessException
COR_E_METHODACCESS MethodAccessException
COR_E_MISSINGFIELD MissingFieldException
COR_E_MISSINGMANIFESTRESOURCE MissingManifestResourceException
COR_E_MISSINGMEMBER MissingMemberException

COR_E_MISSINGMETHOD MissingMethodException
COR_E_MULTICASTNOTSUPPORTED MulticastNotSupportedException
COR_E_NOTFINITENUMBER NotFiniteNumberException
E_NOTIMPL NotImplementedException
COR_E_NOTSUPPORTED NotSupportedException
OrE_POINTER COR_E_NULLREFERENCE NullReferenceException
COR_E_OUTOFMEMORY ou OutOfMemoryException
E_OUTOFMEMORY
COR_E_OVERFLOW OverflowException
COR_E_PATHTOOLONG ou PathTooLongException
ERROR_FILENAME_EXCED_RANGE
COR_E_RANK RankException
COR_E_REFLECTIONTYPELOAD ReflectionTypeLoadException
COR_E_REMOTING RemotingException
COR_E_SAFEARRAYTYPEMISMATCH SafeArrayTypeMismatchException
COR_E_SECURITY SecurityException
COR_E_SERIALIZATION SerializationException
OrERROR_STACK_OVERFLOW StackOverflowException
COR_E_STACKOVERFLOW
COR_E_SYNCHRONIZATIONLOCK SynchronizationLockException
COR_E_SYSTEM SystemException
COR_E_TARGET TargetException
COR_E_TARGETINVOCATION TargetInvocationException
COR_E_TARGETPARAMCOUNT TargetParameterCountException
COR_E_THREADABORTED ThreadAbortException
COR_E_THREADINTERRUPTED ThreadInterruptedException
COR_E_THREADSTATE ThreadStateException
COR_E_THREADSTOP ThreadStopException
COR_E_TYPELOAD TypeLoadException
COR_E_TYPEINITIALIZATION TypeInitializationException
COR_E_VERIFICATION VerificationException
COR_E_WEAKREFERENCE WeakReferenceException
COR_E_VTABLECALLSNOTSUPPORTED VTableCallsNotSupportedException
Todos os outros HRESULTs COMException
Para recuperar informações de erro estendidas, o cliente gerenciado deve examinar os campos do
objeto de exceção que foi gerado. Para o objeto de exceção para fornecer informações úteis

sobre um erro, o objeto COM deve implementa a IErrorInfo interface. Tempo de Execução utiliza
as informações fornecidas por IErrorInfo para inicializar o objeto de exceção.
Se o objeto COM não oferece suporte IErrorInfo, o Runtime Inicializa um objeto de exceção com
valores padrão. A tabela a seguir lista cada campo associado a um objeto de exceção e identifica
a fonte de informações padrão quando o objeto com oferece suporte IErrorInfo.
Campo Exceção Fonte de informações de com

ErrorCode HRESULT retornado da chamada.
HelpLink Se IErrorInfo->HelpContext diferente de zero, a seqüência é formada pelas
concatenação IErrorInfo->GetHelpFile e " # ". é e IErrorInfo-
>GetHelpContext Caso contrário a seqüência é retornada de IErrorInfo-
>GetHelpFile.
InnerException Sempre uma referência nula (Nothing no Visual Basic.)
Message Seqüência de caracteres retornada de IErrorInfo->GetDescription.
(Mensagem)
Origem Seqüência de caracteres retornada de IErrorInfo->GetSource.
StackTrace O rastreamento da pilha.
TargetSite O nome do método que retornados a falha HRESULT.
Campos exceção, como Message, Source a StackOverflowException., e StackTrace não estão

disponíveis para
O Importador da biblioteca Tipo (TLBIMP.exe) converte assinaturas método com a maioria em

assinaturas gerenciadas. No entanto, vários tipos requer informações adicionais que você pode
especificar, editando o conjunto de interoperabilidade. Este tópico descreve como editar um
conjunto de interoperabilidade. O Empacotamento alterações tópico identifica vários casos que
exigem que você para editar o conjunto de interoperabilidade e descreve as alterações
necessárias.
Para especificar empacotamento alterações no Microsoft intermediários idioma (MSIL)

1. Gerar conjunto interoperacional inicial usando TLBIMP.exe. Por exemplo, para produzir um
conjunto chamado New.dll de New. TLB, digite o seguinte comando no prompt de comando:
tlbimp New.tlb /out:New.dll
2. No prompt de comando, digite o seguinte comando para produzir MSIL para o conjunto:
ildasm New.dll /out:new.il
3. Editar o MSIL conforme necessário.

4. No prompt de comando, digite o seguinte comando para produzir a sintaxe apropriada
definindo um novo New.dll:
ilasm New.il /dll

Gera Visual Studio 2005 um conjunto interoperacional que contém metadados quando você
adiciona uma referência a uma biblioteca de tipos determinado. Se um conjunto interoperacional
primário estiver disponível, Visual Studio usará o conjunto existente antes de gerar um novo
conjunto de interoperabilidade.
Para adicionar uma referência a uma biblioteca de tipos

1. Instale o arquivo exe ou dll com em seu computador, a menos que um instalar.exe do
Windows executa a instalação para você.
2. No menu Project, selecione References.
3. Selecione a COM guia.
4. Selecionar a biblioteca de tipos na lista Available References, ou procure o arquivo TLB.
5. Clique em OK.
Framework, não Consulte Tratamento e Raising eventos. Para obter detalhes específicos que se
aplicam a nesta seção, consulte Consumir eventos na mesma seção.
Um cliente .NET (coletor de eventos) pode receber eventos criados por um servidor COM
existente (origem de evento). Interoperabilidade com gera os representantes necessários nos
metadados que forem incluídos no seu cliente gerenciado. Uma assinatura de representante
importados compreende a interface de evento do coletor, um sublinhado, o nome de evento, e a
palavra EventHandler: SinkEventInterface _ EventName EventHandler.
Observe que objetos com eventos em um cliente .NET que elevar exigir duas coleções Garbage
Collector (GC) antes que são lançadas. Isso ocorre quando o ciclo de referência que ocorre entre
objetos COM e clientes gerenciados. Caso você precise explicitamente liberar um objeto com você
deve chamar o Collect método duas vezes.
Para interoperar com uma fonte de eventos COM existente

1. Obter Conjunto de Módulos (Assembly o) de interoperabilidade primária para o servidor
COM se os tipos com forem a ser compartilhada por outros aplicativos. Um conjunto de
interoperabilidade primário contém metadados que representa a biblioteca de tipos
convertido e é assinado no editor.
Observação
Se o conjunto de interoperabilidade primário é não disponível ou se o conjunto for a ser usado de

forma privada, você pode importar a biblioteca de tipos usando API equivalente ou a Importador
da biblioteca Tipo (TLBIMP.exe) um.
2. O processo de conversão gera um representante para cada evento; no entanto, você só

precisa para coletar os eventos de seu interesse.
3. Você pode usar um navegador de metadados, como para identificar eventos
representantes. o Disassembler MSIL (Ildasm.exe),
4. Consumir eventos da fonte de eventos COM da mesma maneira que consome eventos de
uma origem de evento gerenciado.
Exemplo

O exemplo a seguir demonstra como abrir uma janela do Internet Explorer e Wire eventos criados
pelo InternetExplorer Objeto para manipuladores de eventos implementado no código gerenciado.
Definições de tipos Internet Explorer (incluindo representantes de evento) são importadas como
metadados do SHDocVw.dll. O exemplo recpetores o TitleChange evento.
C#
namespace InternetExplorer { using System; using System.Runtime.InteropServices; using SHDocVw; public
class Explorer { public static void Main() { Explorer explorer = new Explorer(); explorer.Run(); } public void
Run() { Object o = null; String s; try { // Starts the browser. m_IExplorer = new
SHDocVw.InternetExplorer(); } catch(Exception e) { Console.WriteLine("Exception when creating Internet
Explorer object {0}", e); return; } // Wires your event handlers to m_IExplorer. SetAllEvents(); try { // Goes
to the home page. m_WebBrowser = (IWebBrowserApp) m_IExplorer; m_WebBrowser.Visible = true;
m_WebBrowser.GoHome(); // Starts navigating to different URLs. Console.Write("Enter URL (or enter to
quit): "); s = Console.ReadLine(); while (s != "" && m_IExplorer != null && m_WebBrowser != null) {
m_WebBrowser.Navigate(s, ref o, ref o, ref o, ref o); Console.Write("Enter URL (or enter to quit): "); s =
Console.ReadLine(); } m_WebBrowser.Quit(); } catch(Exception sE) { if (m_IExplorer == null &&
m_WebBrowser == null) { Console.WriteLine("Internet Explorer has gone away"); } else {
Console.WriteLine("Exception happens {0}", sE); } } } // Uses the += syntax for adding delegates to events.
void SetAllEvents() { if (m_IExplorer != null) { // Title Change event // DWebBrowserEvents2 is the name of
the sink event //interface. // TitleChange is the name of the event. //
DWebBrowserEvents2_TitleChangeEventHandler is the // delegate name assigned by TlbImp.exe.
DWebBrowserEvents2_TitleChangeEventHandler DTitleChangeE = new
DWebBrowserEvents2_TitleChangeEventHandler(OnTitleChange); m_IExplorer.TitleChange +=
DTitleChangeE; } } /////////////////////////////////////////////////////////////////////// // Define
event handlers. // Document title changed static void OnTitleChange(String Text) { Console.WriteLine("Title
changes to {0}", Text); } ////////////////////////////////////////////////////////////////////////// //
The following are class fields. static private SHDocVw.InternetExplorer m_IExplorer = null; static private
IWebBrowserApp m_WebBrowser = null; } }
Se você optar por declarar tipos com manualmente no código fonte gerenciado, o melhor lugar
para começar é com uma biblioteca Arquivo ou tipo interface Definition Language (IDL) existente.
Quando você não tem o arquivo IDL ou não é possível gerar um arquivo de biblioteca Tipo, você
pode simular os tipos com criando declarações gerenciadas e exportar o conjunto resultante para
uma biblioteca de tipos.
Para simular com tipos de fonte gerenciado

1. Declarar os tipos em um idioma que seja compatível o com comum especificação (cls)
idioma e compilar o arquivo.
2. Exportar o conjunto que contém os tipos com o Tipo Exporter da biblioteca (TlbExp.exe).
3. Usar a biblioteca de tipos com exportado como uma base para declarar tipos gerenciados
orientado com.
Para criar um invólucro Callable Runtime (RCW)
1. Supondo que você tiver um arquivo IDL ou arquivo biblioteca Tipo, decidir quais classes e
interfaces você deseja incluir no RCW personalizado. Você pode excluir qualquer tipos que
você não pretende usar diretamente ou indiretamente em seu aplicativo.

2. Criar um arquivo de origem em um idioma compatível com CLS e declarar os tipos.
Consulte Biblioteca tipo para resumo de conversão assembly Para uma descrição completa
do processo de conversão de importação. Efetivamente, quando você cria um RCW
personalizado, você está executando a atividade de conversão fornecida pelo tipo
manualmente o Importador da biblioteca Tipo (TLBIMP.exe). O Exemplo que segue este
tipos mostra procedimento em um arquivo de biblioteca IDL ou tipo e seus tipos
correspondentes no código C#.
3. Quando as declarações estiverem concluídas, compile o arquivo como você compila
qualquer outro código de fonte gerenciado.
4. Como com os tipos importados com TLBIMP.exe, algumas exigem informações adicionais
que você pode adicionar diretamente a seu código. Para obter detalhes, consulte Como
editar conjuntos Interop:.
Exemplo
O código a seguir mostra um exemplo da interface e ISATestSATest Classe em IDL e os tipos

Arquivo de biblioteca IDL ou tipo
[ object, uuid(40A8C65D-2448-447A-B786-64682CBEF133), dual, helpstring("ISATest Interface"),

pointer_default(unique) ] interface ISATest : IDispatch { [id(1), helpstring("method InSArray")] HRESULT
InSArray([in] SAFEARRAY(int) *ppsa, [out,retval] int *pSum); }; [ uuid(116CCA1E-7E39-4515-9849-
90790DA6431E), helpstring("SATest Class") ] coclass SATest { [default] interface ISATest; };
Wrapper no código fonte gerenciado
C#
using System; using System.Runtime.InteropServices; using System.Runtime.CompilerServices;
[assembly:Guid("E4A992B8-6F5C-442C-96E7-C4778924C753")]
[assembly:ImportedFromTypeLib("SAServerLib")] namespace SAServer { [ComImport] [Guid("40A8C65D-
2448-447A-B786-64682CBEF133")] [TypeLibType(TypeLibTypeFlags.FLicensed)] public interface ISATest {
[DispId(1)] //[MethodImpl(MethodImplOptions.InternalCall, //
MethodCodeType=MethodCodeType.Runtime)] int InSArray( [MarshalAs(UnmanagedType.SafeArray,
SafeArraySubType=VarEnum.VT_I4)] ref int[] param ); } [ComImport] [Guid("116CCA1E-7E39-4515-9849-
90790DA6431E")] [ClassInterface(ClassInterfaceType.None)]
[TypeLibType(TypeLibTypeFlags.FCanCreate)] public class SATest : ISATest { [DispId(1)]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)] extern int
ISATest.InSArray( [MarshalAs(UnmanagedType.SafeArray, SafeArraySubType=VarEnum.VT_I4)] ref int[]
param ); } }
Você deverá registrar todos os adquirida primário conjuntos interoperabilidade no seu computador
de desenvolvimento antes você pode referi-las com Microsoft Visual Studio 2005. O Visual Studio
procurará e usa um conjunto interoperacional primário na primeira vez que você referência um tipo
de uma biblioteca de tipos COM. Se Visual Studio não é possível localizar conjunto de módulos
(assembly o) de interoperabilidade primária associado à biblioteca tipo, ele solicitará que você a
adquiri-lo ou oferece para criar um conjunto de interoperabilidade. Do Importador da biblioteca
Tipo (TLBIMP.exe) da mesma forma, também usa o Registro para localizar conjuntos de
interoperabilidade primárias.

Embora ele não seja necessário para registrar conjuntos de interoperabilidade primárias a menos
que você pretende usar Visual Studio, registro oferece duas vantagens:
• Um conjunto de interoperabilidade primário registrado claramente está marcado sob a

chave de registro da biblioteca de tipos original. Registro é a melhor maneira de se localizar um
conjunto de interoperabilidade primário no seu computador.
• Você pode evitar acidentalmente gerar e usando um novo conjunto interoperacional se, em
algum momento no futuro, você usar o Visual Studio para fazer referência a um tipo para as
quais você tem Conjunto de Módulos (Assembly não registrado um) de interoperabilidade
primária.
Do Ferramenta de registro do conjunto (RegAsm.exe) uso para registrar um conjunto

Para registrar um conjunto interoperacional primário

regasm assemblyname
Neste comando, assemblyname é o nome de arquivo do conjunto que está registrado.
RegAsm.exe adiciona uma entrada para o conjunto de interoperabilidade primário sob a
mesma chave de Registro como a biblioteca tipo original.
Exemplo
O exemplo a seguir registra o CompanyA.UtilLib.dll conjunto de módulos (assembly) de

interoperabilidade primária.
regasm CompanyA.UtilLib.dll
Opcionalmente, você pode dispor mais de uma versão de uma biblioteca de tipos. Por exemplo,
você pode indicar um conjunto de interoperabilidade primário que oferece suporte tipo versões de
biblioteca 1.0 e 1.1.
Para ajustar várias versões de uma biblioteca de tipos

1. Importar um arquivo de biblioteca tipo:

(Ildasm.exe):
ildasm LibUtil.dll /out:LibUtil.il
3. Usando um editor de texto, insira um atributo segundo PrimaryInteropAssemblyAttribute

abaixo o atributo adicionado por TLBIMP.exe. Incluir os números de versão primária e
secundária que representam a segunda versão de biblioteca tipo.
4. Gerar e assinar um novo conjunto do arquivo de texto modificado por meio do Assembler
MSIL (Ilasm.exe):
ilasm LibUtil.il /dll /key:CompanyA.snk

Aplicativos do Windows (Como fazer em C#)
Esta página tem links para Ajuda sobre tarefas em aplicativos do Windows amplamente usadas.
Para ver outras categorias de tarefas populares abordadas na Ajuda, Como fazer em C#.
Como: Escolher o formulário de inicialização em um aplicativo do Windows
Quando você adicionar um formulário do Windows a um projeto, ele não exibirá próprio por padrão
em tempo de execução. Para obter informações sobre como exibir um formulário em tempo de
execução, consulte Exibindo JanelaRestrita e Modeless Windows Forms. Entretanto, o formulário
criado quando você escolhe um aplicativo do Windows a partir da New Project Caixa de diálogo
será o formulário Inicialização por padrão. Para alterar o formulário de inicialização, use a Project
página de propriedades.
Para definir o formulário de inicialização no Windows Forms

1. No Solution Explorer, clique com o botão direito do mouse o projeto e escolha
Properties.
A Project página Propriedade abre com as General propriedades exibidas.
2. Escolha o formulário a ser como o formulário de inicialização da lista Startup Object drop-
down.
COMO: Conectar vários eventos a um único manipulador de eventos em Windows Forms
No seu projeto de aplicativos, talvez seja necessário para usar um manipulador de eventos único
para vários eventos ou tem vários eventos executar o mesmo procedimento. Por exemplo, é
geralmente um saver tempo a poderoso para que um comando de menu elevar o mesmo evento
como um botão em seu formulário faz se eles expor a mesma funcionalidade. Para fazer isso,
usando a exibição Eventos da janela Propriedades em C# ou palavra-chave Handles e Class
Name. e Method Name caixas suspensas no editor de código do Visual Basic
Para conectar múltiplos eventos a um manipulador de eventos único no Visual Basic

1. Clique com o botão direito do mouse no formulário e escolha View Code.
2. Na caixa Class Name suspensa, selecione um dos controles que você deseja que tem o
manipulador de eventos tratar.
3. Na caixa Method Name suspensa, selecione um dos eventos que você deseja
manipulador de eventos para manipular.
4. O Editor de Código insere o manipulador de eventos apropriado e posiciona o ponto de
inserção dentro do método. No exemplo abaixo, ele é o Click evento para o Button controle.
Visual Basic
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
Button1.Click ' Add event-handler code here. End Sub
5. Acrescentar os outros eventos você deseja tratado com a Handles cláusula.

Visual Basic
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
Button1.Click, Button2.Click ' Add event-handler code here. End Sub
6. Adicione o código apropriado ao manipulador de eventos.

Para se conectar vários eventos a um manipulador de eventos único em C#

1. Selecione o controle ao qual você quer se conectar um manipulador de eventos.
2. Na janela Propriedades, clique no Events botão ( ).
3. Clique no nome do evento que você deseja manipular.

4. Na seção valor ao lado do nome de evento, clique no botão drop-down para exibir uma
lista de existente manipuladores de eventos que correspondem à assinatura método do evento
você deseja manipular.
5. Selecione o manipulador de eventos apropriado na lista.
Código será adicionado para o formulário para vincular o evento ao manipulador de eventos
existentes.
Como: Criar uma interface de usuário Multipainel com Windows Forms
No procedimento a seguir, você criará uma interface usuário multipane que é semelhante daquele
usado no Microsoft Outlook, com uma Folder lista, um Messages painel, e um Preview painel.
Essa organização é conseguida chiefly através de encaixe controles com o formulário.
Quando você ancora um controle, você determinar qual borda do recipiente pai um controle é
encaixado para. Assim, se você definir a Dock propriedade para Right, a borda direita do controle
ser encaixada para a borda direita de seu controle pai será. Além disso, a borda do controle
encaixada é redimensionada para coincidir com a de seu controle de recipiente. Para obter mais
informações sobre como a Dock propriedade funciona, consulte HOW TO: Dock controles em
Windows Forms.
Este procedimento se concentra na organização e SplitContainer a outros controles no formulário,

não em Adicionar funcionalidade para tornar o aplicativo imitar o Microsoft Outlook.
Para criar essa interface de usuário, você coloque todos os controles em um SplitContainer
controle, que contém um TreeView controle no painel esquerdo. O painel direito do controle
SplitContainer contém um segundo SplitContainer controle com um ListView controle acima um
RichTextBox controle. Esses SplitContainer controles permitem redimensionamento
independente dos outros controles no formulário. Você pode adaptar as técnicas neste
procedimento para artesanato interfaces do usuário personalizada de suas preferência.
Para criar uma interface de usuário estilo Outlook-programaticamente

1. Em um formulário, declare cada controle que abranja a interface do usuário. Neste
exemplo, para usar e RichTextBox controles para imitar a interface de usuário do Microsoft
Outlook., SplitContainer a TreeView, ListView
C#
private System.Windows.Forms.TreeView treeView1;
private System.Windows.Forms.ListView listView1;
private System.Windows.Forms.RichTextBox richTextBox1;
private System.Windows.Forms. SplitContainer splitContainer2;
private System.Windows.Forms. SplitContainer splitContainer1;
2. Criar um procedimento que define a interface do usuário. O código a seguir define as

propriedades para que se será o formulário parecer com interface de usuário no Microsoft Outlook.
No entanto, ao usando outros controles ou encaixe-los de forma diferente, é apenas tão fácil para
criar outras interfaces de usuário que são igualmente flexíveis.
C#

public void createOutlookUI() { // Create an instance of each control being used. treeView1 = new
System.Windows.Forms.TreeView(); listView1 = new System.Windows.Forms.ListView(); richTextBox1 =
new System.Windows.Forms.RichTextBox(); splitContainer2 = new
System.Windows.Forms.SplitContainer(); splitContainer1 = new System.Windows.Forms.SplitContainer();
// Insert code here to hook up event methods. // Set properties of TreeView control. treeView1.Dock =
System.Windows.Forms.DockStyle.Fill; treeView1.TabIndex = 0; treeView1.Nodes.Add("treeView"); // Set
properties of ListView control. listView1.Dock = System.Windows.Forms.DockStyle.Top; listView1.TabIndex
= 2; listView1.Items.Add("listView"); // Set properties of RichTextBox control. richTextBox1.Dock =
System.Windows.Forms.DockStyle.Fill; richTextBox1.TabIndex = 3; richTextBox1.Text = "richTextBox1"; //
Set properties of first SplitContainer control. splitContainer1.Dock = System.Windows.Forms.DockStyle.Fil1;
splitContainer2.TabIndex = 1; splitContainer2.SplitterWidth = 4; splitContainer2.SplitterDistance = 150;
splitContainer2.Orientation = Orientation.Horizontal; splitContainer2.Panel1.Controls.Add(this.listView1);
splitContainer2.Panel1.Controls.Add(this.richTextBox1); // Set properties of second SplitContainer control.
splitContainer2.Dock = System.Windows.Forms.DockStyle.Fil1; splitContainer2.TabIndex = 4;
splitContainer2.SplitterWidth = 4; splitContainer2.SplitterDistance = 100;
splitContainer2.Panel1.Controls.Add(this.treeView1);
splitContainer2.Panel1.Controls.Add(this.splitContainer1); // Add the main SplitContainer control to the
form. this.Controls.Add(this.splitContainer2); this.Text = "Intricate UI Example"; }
3. No Visual Basic, adicione uma chamada para o procedimento recém-criado no

procedimento New(). No Visual C#, adicione esta linha de código para o construtor para a classe
formulário.
C#
// Add this to the form class's constructor. createOutlookUI();
Como: Adicionar imagens de plano de fundo ao Windows Forms
Ao projetar sua formulários Windows, às vezes, convém para colocar uma imagem de plano de
fundo em um controle ou no próprio o formulário. Você pode fazer isso facilmente utilizando a
Properties janela.
Para adicionar uma imagem de plano de fundo a um formulário do Windows

1. Clique em propriedade do formulário BackgroundImage na janela Properties. Clique o
reticências ( .) botão para abrir a Select Resource caixa de diálogo
2. Clique Import para abrir a Open File caixa de diálogo. Navegue para um arquivo bitmap
(.bmp), por exemplo <Windows folder> / Rhododendron.bmp. Clique Open para aceitar sua
escolha.
Observe que o arquivo você separado agora aparece na lista Entry, e a imagem aparece na caixa
Preview.
3. Clique OK Para importar a imagem como um recurso. Observe que a imagem agora
aparece em seu formulário. Você pode usar a BackgroundImageLayout propriedade para controlar
a aparência da imagem no formulário
Observe também que o projeto agora tem uma pasta chamada Resources na qual a imagem de
origem foi copiada.
Para remover uma imagem de plano de fundo de um formulário do Windows
• Na janela Properties, clique com o botão direito do mouse o reticências ( .), botão para a
BackgroundImage propriedade, em Reset seguida clique em

Como: Definir ToolTips para controles em um Windows Form em tempo de design
Você pode definir uma ToolTip seqüência no código ou em Windows Forms Designer. Para obter
mais informações sobre o ToolTip componente, consulte Dica de Ferramenta Component
Overview (formulários do Windows).
Observação
Para definir uma dica de ferramenta programaticamente

1. Adicione o controle que será exibida a dica de ferramenta.
2. Use o SetToolTip método do componente ToolTip.
C#
// In this example, button1 is the control to display the ToolTip. toolTip1.SetToolTip(button1, "Save
changes");
Para definir uma dica de ferramenta no designer

1. Adicionar um ToolTip componente para o formulário.
2. Selecione o controle que exibirá a dica de ferramenta, ou adicioná-lo ao formulário.
3. Na janela Properties, defina o ToolTip on ToolTip1 valor como uma seqüência de texto
apropriada.
COMO: Adicionar controles ActiveX ao Windows Forms
Enquanto o Windows Forms Designer é otimizado para host controles Windows Forms, você
também pode colocar controles ActiveX em Windows Forms.
Cuidado
Existem limitações de desempenho para Windows Forms quando controles ActiveX são
adicionados a eles.
Antes de adicionar controles ActiveX a seu formulário, você deve adicioná-los para a Caixa de
ferramentas. Para obter mais informações, consulte Componentes COM, Personalizar caixa de
diálogo Caixa de ferramentas.
Observação
clique em Import and Export Settings No menu Tools. Para obter mais informações, consulte

Para adicionar um controle ActiveX para o formulário Windows
• Clique duas vezes no controle na barra de ferramentas.
Adiciona Visual Studio Todas as referências para o controle no seu projeto. Para obter mais
informações sobre o que tenha em mente ao usar controles ActiveX em Windows Forms, consulte
Considerações ao hospedando um controle ActiveX em um formulário do Windows.
Observação
Formulários Windows o Importer controle ActiveX (AxImp.exe) cria argumentos evento de um tipo
diferente do esperado na importação das bibliotecas de vínculo dinâmico ActiveX. Os argumentos
criado pelo AxImp.exe são semelhantes ao seguinte: Invoke(object sender,
DWebBrowserEvents2_ProgressChangeEvent e), quando Invoke(object sender,
DWebBrowserEvents2_ProgressChangeEventArgs e) é esperado. Esteja ciente que este irregularity
não impede Código de funcionando normalmente. Para obter detalhes, consulte Importer controle
ActiveX formulários Windows (Aximp.exe).
COMO: Criar chaves do acesso para controles do Windows Forms
Um Tecla de acesso é um caractere sublinhado no texto de um menu, item de menu, ou o rótulo

de um controle como um botão. Com uma tecla de acesso, o usuário pode " clicar " um botão,
pressionando a tecla ALT junto com a chave predefinida de acesso. Por exemplo, faz se um botão
executa um procedimento para imprimir um formulário, e portanto sua Text propriedade estiver
definida para " imprimir ", adicionando e um comercial antes da letra " P " com a letra " P " para
ser sublinhada no texto do botão em tempo de execução. O usuário pode executar o comando
associado com o botão pressionando ALT + P. Não é possível ter uma tecla de acesso para um
controle que não pode receber o foco.
Para criar uma chave de acesso para um controle

• Set the Text property to a string that includes an ampersand (&) before the letter that will be
the shortcut.
C#
// Set the letter "P" as an access key. button1.Text = "&Print";
Observação
To include an ampersand in a caption without creating an access key, include two ampersands
(&&). Um único e comercial é exibido na legenda e sem caracteres são sublinhados.
Como: Adicionar ou remover de uma coleção de controles em tempo de execução
Tarefas comuns em desenvolvimento de aplicativos são adicionar controles para e removendo

controles de qualquer caixa de controles no seus formulários o Panel, como ou GroupBox
controle, ou mesmo o formulário próprio)..), como o Panel ou GroupBox controle, ou mesmo o
próprio formulário (( Em tempo de criação, controles podem ser arrastadas diretamente em uma
caixa painel ou grupo. Em tempo de execução, esses controles manter uma Controls coleção,
que mantém registro dos quais controles são colocados sobre eles.
Observação

O exemplo de código a seguir aplica a qualquer controle que mantém um conjunto de controles
dentro dela.
Para adicionar um controle a uma coleção programaticamente

1. Criar uma instância do controle a ser adicionado.
2. Definir propriedades do novo controle.
3. Adicione o controle à coleção Controls do controle pai.
O exemplo de código a seguir mostra como criar uma instância do controle Button. Ele requer um
formulário com um Panel controle e que o método tratamento de eventos para o botão sendo
criada NewPanelButton_Click,. já existe
C#
public Button newPanelButton = new Button(); public void addNewControl() { // The Add method will
accept as a parameter any object that derives // from the Control class. In this case, it is a Button control.
panel1.Controls.Add(newPanelButton); // The event handler indicated for the Click event in the code //
below is used as an example. Substite the appropriate event // handler for your application.
this.newPanelButton.Click += new System.EventHandler(this. NewPanelButton_Click); }
Para remover controles de uma coleção programaticamente

1. Remover o manipulador de eventos do evento. No Visual Basic, use a Instrução
RemoveHandler palavra-chave; no Visual C#, use o = Operador (referência C#).
2. Use o Remove método para excluir o controle desejado do painel na Controls coleção.
3. Chamar o Dispose método para versão todos os recursos usado pelo controle.
C#
private void removeControl(object sender, System.EventArgs e) { // NOTE: The code below uses the instance
of // the button (newPanelButton) from the previous example.
if(panel1.Controls.Contains(newPanelButton)) { this.newPanelButton.Click -= new
System.EventHandler(this. NewPanelButton_Click); panel1.Controls.Remove(newPanelButton);
newPanelButton.Dispose(); } }
COMO: Ativar estilos do Visual Windows XP
é Estilo visual a aparência modifiable Usuário da interface do usuário de um aplicativo ou sistema

operacional. Por padrão, o Windows XP fornece um novo estilo visual. O novo estilo visual a
barras de rolagem e barra título de um formulário do Windows será usam automaticamente
quando o formulário é executado no Windows XP. O estilo visual se seu aplicativo chama o
EnableVisualStyles método, a maioria dos controles Windows Forms usará automaticamente
quando seu aplicativo é executado no Windows XP.
Observação
O suporte estilos visuais Windows XP também pode ser habilitado através da Enable Visual
Styles caixa de seleção no painel Application da Project Designer. Para obter mais
informações, consulte o tópico COMO: ativar estilos visuais.
Para ativar estilos visuais

• Para ativar estilos visuais na área cliente de um formulário do Windows, adicione o
seguinte código ao método do aplicativo Main.
C#
Application.EnableVisualStyles();
Observação
Não há alguns formulários Windows controla que será aspecto. os mesmos em todos os sistemas
operacionais; implementação EnableVisualStyles tem não afeta esses controles Eles incluem e
CheckedListBox controles., DomainUpDown, NumericUpDown o LinkLabelLabel Além disso, se
você ativar estilos visuais em alguns controles, o controle pode exibirá incorretamente em certas
situações. Eles incluem o MonthCalendar controle com um conjunto intervalo, seleção com
páginas guia alinhado na parte inferior ou lados do controle, e o tratamento de fontes substituto no
controle TextBox. o TabControl
Como: Tornar uma Windows Form de inicialização invisível
Para tornar o formulário principal de um aplicativo baseado no Windows invisível quando o

aplicativo for iniciado, você deve mover lógica de inicialização do aplicativo para uma classe
separada. Simplesmente você não pode definir sua Visível propriedade para false.
Depois você ter separados a vida útil do aplicativo da vida útil do formulário, você pode fazer
formulários visível (e invisível), porque o aplicativo será encerrado quando você " fechar " a classe
que foi usado para inicialização Aplicativo.. porque o aplicativo será encerrado quando você "
fechar " a classe que foi usado para inicialização aplicativo
Observação
Como um módulo é invisível quando seu código está sendo executado, o procedimento a seguir
inclui uma etapa para adicionar uma caixa de mensagem para o módulo de inicialização para
simplesmente demonstrar que o aplicativo está sendo executado.
Para definir um formulário para ser invisível no seu início

1. Execute uma das maneiras a seguir:
1. No Visual Basic, adicionar um módulo a seu aplicativo baseado no Windows, com o
botão direito do mouse o projeto e escolhendo Add Module.
2. No Visual C#, criar uma nova classe.
3. No Visual C++, abra Form1.cpp do seu aplicativo baseados no Windows.
Para obter mais informações sobre como criar um aplicativo baseado no Windows, consulte
Como: Criar um projeto de aplicativos Windows.
2. Dentro do módulo ou classe, desenvolver uma Main subrotina que podem atuar como o
objeto de inicialização para o projeto.
O exemplo de código a seguir mostra como você pode Approach isso.
C#
// All methods must be contained in a class. // This class is added to the namespace containing the Form1
class. class MainApplication { public static void Main() { // Instantiate a new instance of Form1. Form1 f1 =
new Form1(); // Display a messagebox. This shows the application // is running, yet there is nothing shown

to the user. // This is the point at which you customize your form.
System.Windows.Forms.MessageBox.Show("The application " + "is running now, but no forms have been
shown."); // Customize the form. f1.Text = "Running Form"; // Show the instance of the form modally.
f1.ShowDialog(); } }
Observação
Caixa de mensagem no exemplo de código anterior é especificado com um espaço para nome
totalmente qualificado porque o módulo criado, diferentemente de um formulário padrão do
Windows, não importa espaços para qualquer nome por padrão. Para obter mais informações
sobre como importar espaços para nome, consulte Referências e a declaração imports (Visual
Basic) (Visual C# (Visual C++.), o Usando diretiva (referência C#), ou o using Directive (C++))
Será Application.Run() iniciado o bomba mensagem, que é vital para o comportamento de
determinados aplicativos e pode afetar comportamento formulário durante determinadas horas em
ciclo de vida do aplicativo, como ao desligar. Para obter mais informações, consulte Método
Application.Run.
3. Alterar o objeto de inicialização para o projeto seja Sub Main em vez de Form1.
Para Visual C# definir o objeto de inicialização para ser ApplicationName, MainApplication como
em nomeação da classe no exemplo de código anterior. Para obter mais informações, consulte
Como: Escolher o formulário de inicialização em um aplicativo do Windows.
Observação
Ignorar esta etapa para aplicativos baseados no Windows em Visual C++.

Quando a execução de aplicativos, o código no Main() executa primeiro enquanto a instância do
Form1 lingers, oculto, até que o código para mostrar é executado. Isso permite que você para fazer
o que você deseja na instância do Form1 em segundo plano sem conhecimento do usuário.
Como: Manter um Windows Form em exibição
Iniciando com o sistema operacional Microsoft Windows 2000, um formulário mais alto-sempre
permanece na frente de todas as janelas em um determinado aplicativo. No Microsoft Windows
98, um formulário mais alto-permanece na frente de todas as janelas em todos os aplicativos. Por
exemplo, você pode deseja manter uma janela ferramenta flutuante no frente da janela principal
do aplicativo A TopMost propriedade controla se um formulário é um formulário mais superior.
Sempre um formulário mais alto-será flutuar acima, outros formulários não – mais alto-mesmo
quando ele não está ativa.
Observação
Para fazer um formulário o formulário mais alto-em uma aplicativo do Windows Forms a tempo de
design
• Na janela Properties, defina a TopMost propriedade como true.
Para fazer um formulário o formulário mais alto-em uma aplicativo do Windows Forms
programaticamente
• Em um procedimento, defina a TopMost propriedade como true.
C#
public void MakeOnTop() { myTopForm.TopMost = true; }
Como: Exibir Windows Forms com e sem janelas restritas
Formulários e caixas de diálogo são marcas restrita ou sem janela restrita. Um janela restrita
formulário ou caixa de diálogo deve ser fechado ou ocultos antes de continuar trabalhando com o
restante do aplicativo. Para obter mais informações sobre como trabalhar com caixas de diálogo,
consulte Entrada de usuário para caixas de diálogo.
Caixas de diálogo que exibe mensagens importantes sempre deve ser restrita. Caixa About de
diálogo no Visual Studio é um exemplo de uma caixa de diálogo restrita. é MessageBox um
formulário modal você pode usar.
Formulários Sem janela restrita permitem que você alternar o foco entre o formulário e um outro
formulário sem ter que fechar o formulário inicial. O usuário pode continuar a trabalhar em
qualquer lugar em qualquer aplicativo enquanto o formulário é exibido.
Formulários sem janela restrita são mais difíceis para programa, porque os usuários possam
acessá-los em uma ordem imprevisíveis. Você deve manter o estado do do aplicativo consistente
não importa o que o usuário faz. Freqüentemente, janelas de ferramentas são mostrados em uma
maneira sem janela restrita. A Find caixa de diálogo acessíveis de menu Edit no Visual Studio, é
um exemplo de uma caixa de diálogo sem janela restrita. Usar formulários para comandos
exibição usados ou informações sem janela restrita.
Observação
Para exibir um formulário como uma caixa de diálogo restrita

• Chame o ShowDialog método.
O exemplo de código a seguir mostra como exibir uma caixa de diálogo modally.
C#
//Display frmAbout as a modal dialog Form frmAbout = new Form(); frmAbout.ShowDialog();
O ShowDialog método contém um argumento opcional, owner,. que pode ser usado para
especificar uma relação pai-filho para um formulário Por exemplo, ao código no formulário
principal mostra uma caixa de diálogo, você pode passar Me (in Visual Basic) ou this (no Visual
C#). Como o proprietário da caixa de diálogo para estabelecer o formulário principal como o
proprietário, como o código a seguir mostra
C#
private void mnuAbout_Click(object sender, System.EventArgs e) { Form f = new Form();
f.ShowDialog(this); }

Para exibir um formulário como uma caixa de diálogo sem janela restrita
• Chame o Show método.
O exemplo a seguir mostra como exibir uma About caixa de diálogo em formato sem janela
restrita.
C#
//Display f as a modeless dialog Form f= new Form(); f.Show();
Observação
Se um formulário é exibido como janela restrita, o código seguinte ao ShowDialog método não
será executado até que a caixa de diálogo seja fechada. No entanto, quando um formulário é
exibido como modal, o código seguinte ao Show método for executado imediatamente após o
formulário é exibido..
Como: Selecionar texto no controle TextBox do Windows Forms
Você pode selecionar texto programaticamente no controle Windows Forms TextBox Por exemplo,
se você criar uma função que procura texto para uma seqüência específica, você pode selecionar
o texto a visualmente Alerta o leitor de posição a seqüência de caracteres encontrada na
Para selecionar texto programaticamente

1. Defina a SelectionStart propriedade para o início do texto desejado para selecionar.
A SelectionStart propriedade é um número que indica o ponto de inserção dentro da seqüência
de texto, com 0 é a posição extrema esquerda. Se a SelectionStart propriedade é definida como
um valor igual a ou maior que o número de caracteres na caixa de texto, o ponto de inserção está
colocado depois do último caractere.
2. Defina a SelectionLength propriedade ao comprimento do texto que deseja selecionar.
A SelectionLength propriedade é um valor numérico que define a largura do ponto de inserção.
Do SelectionLength configuração para um número maior que 0 causará esse número de
caracteres a ser selecionado, iniciando a partir o ponto de inserção atual.
3. (Opcional) Acessar o texto selecionado através da SelectedText propriedade.
O código a seguir seleciona o conteúdo de uma caixa de texto quando o controle o Enter evento
ocorrer. O TextBox1_Enter manipulador de eventos deve ser vinculado ao controle; para obter mais
informações, consulte Como criar manipuladores de eventos em tempo de execução para
Windows Forms:.
C#
private void textBox1_Enter(object sender, System.EventArgs e){ textBox1.SelectionStart = 0;
textBox1.SelectionLength = textBox1.Text.Length; }
Como: Colocar aspas em uma seqüência (Windows Forms)
Às vezes, convém colocar as aspas (. " " em uma seqüência de texto) Por exemplo:
Ela dito, " Você merece uma trate! "
Para colocar aspas em uma seqüência em seu código

1. No Visual Basic, inserir duas aspas em uma linha como uma marca cotação incorporada.
Em Visual C# \ " como uma marca cotação incorporada. e Visual C++, insira a seqüência de
escape Por exemplo, para criar a seqüência anterior, use o código a seguir.
C#
private void InsertQuote(){ textBox1.Text = "She said, \"You deserve a treat!\" "; }
- ou -
2. Insira o caractere ASCII ou Unicode para uma aspa. No Visual Basic, use o caractere
ASCII (34). In Visual C#, use the Unicode character (\u0022).
C#
private void InsertAscii(){ textBox1.Text = "She said, " + '\u0022' + "You deserve a treat!" + '\u0022'; }
Observação
In this example, you cannot use \u0022 because you cannot use a universal character name that
designates a character in the basic character set. Caso contrário, você produzir C3851. For more
information, see Compilador C3851 de erro.
- ou -
3. Você também pode definir uma constante para o caractere, e usá-la quando necessário.
C#
const string quote = "\""; textBox1.Text = "She said, " + quote + "You deserve a treat!"+ quote ;
Como: Selecionar texto no controle TextBox do Windows Forms
Você pode selecionar texto programaticamente no controle Windows Forms TextBox Por exemplo,
se você criar uma função que procura texto para uma seqüência específica, você pode selecionar
o texto a visualmente Alerta o leitor de posição a seqüência de caracteres encontrada na
Para selecionar texto programaticamente

1. Defina a SelectionStart propriedade para o início do texto desejado para selecionar.
A SelectionStart propriedade é um número que indica o ponto de inserção dentro da
seqüência de texto, com 0 é a posição extrema esquerda. Se a SelectionStart propriedade
é definida como um valor igual a ou maior que o número de caracteres na caixa de texto, o
ponto de inserção está colocado depois do último caractere.
2. Defina a SelectionLength propriedade ao comprimento do texto que deseja selecionar.
A SelectionLength propriedade é um valor numérico que define a largura do ponto de
inserção. Do SelectionLength configuração para um número maior que 0 causará esse
número de caracteres a ser selecionado, iniciando a partir o ponto de inserção atual.
3. (Opcional) Acessar o texto selecionado através da SelectedText propriedade.
O código a seguir seleciona o conteúdo de uma caixa de texto quando o controle o Enter
evento ocorrer. O TextBox1_Enter manipulador de eventos deve ser vinculado ao controle;
para obter mais informações, consulte Como criar manipuladores de eventos em tempo de
execução para Windows Forms:.
C#
private void textBox1_Enter(object sender, System.EventArgs e){ textBox1.SelectionStart = 0;
textBox1.SelectionLength = textBox1.Text.Length; }

Como exibir várias linhas no controle TextBox de formulários do Windows:
Por padrão, o controle Windows Forms TextBox exibe uma única linha de texto e não exibe barras
de rolagem. Se o texto for maior que o espaço disponível, somente parte do texto estará visível.
Você pode alterar esse comportamento padrão, definindo o Multiline, WordWrap., e ScrollBars
propriedades para valores apropriados
Para exibir um retorno de carro no controle TextBox

• Para exibir um retorno de carro em uma várias linhas TextBox, use a NewLine
propriedade.
Esteja ciente que a interpretação de caracteres de escape ( é específico de idioma. Visual
Basic usa Chr$(13) & Chr$(10) para retorno de carro e alimentação de linha a combinação de
caracteres.
Para exibir várias linhas no controle TextBox
1. Defina a Multiline propriedade para true. Se WordWrap será true (o padrão), em seguida,
o texto no controle será exibida como um ou mais parágrafos; caso contrário, ele aparecerá
como uma lista, em que algumas linhas podem ser cortadas na borda do controle.
2. Defina a ScrollBars propriedade como um valor apropriado.
Value
(Valor) Descrição
None Use esse valor se o texto será um parágrafo que. quase sempre ajusta o controle O
usuário pode usar o ponteiro do mouse para mover-se dentro do controle se o texto
for muito longa para exibir todos de uma vez.
Horizontal Use esse valor se você deseja exibir uma lista de linhas, alguns dos que podem estar
maior que a largura do controle TextBox.
Both Use esse valor se a lista pode ser maior que a altura do controle.
3. Defina a WordWrap propriedade como um valor apropriado.
Value
(Valor) Descrição
false Texto no controle não automaticamente será ser disposto, para que ele irá rolar para a
direita até que uma quebra de linha seja alcançada. Use esse valor se você escolheu
Horizontal barras de rolagem ou Both, acima.
(true A barra de rolagem horizontal não será exibido. Use esse valor se você escolheu
padrão) Vertical barras de rolagem ou None, acima, para exibir um ou mais parágrafos.
Componente Timer (Windows Forms)

Os formulários Timer do Windows é um componente que gera um evento em intervalos regulares.
Este componente é projetado para um ambiente Windows Forms.
Visão geral do componente de timer (Windows Forms)

Os formulários Timer do Windows é um componente que gera um evento em intervalos regulares.
Este componente é projetado para um ambiente Windows Forms. Se você precisar um timer que é
adequado para um ambiente de servidor, consulte Introdução ao timers Based Server-.
Chave propriedades, métodos e eventos

O comprimento de intervalos é definido pela propriedade Interval, cujo valor é em milissegundos.
Quando o componente está ativado, o Tick evento será gerado a cada intervalo. É onde você
adicionaria código para ser executado. Para obter mais informações, consulte Como executar
procedimentos na intervalos do conjunto com o componente Timer Windows Forms:.Os métodos
para o Timer componente de chave são Start e Stop, que ativar o timer e desativar. Quando o
cronômetro é desligado, ele redefine; não é um meio para pausar um Timer componente.
Limitações do componente Timer de formulários do Windows

na propriedade Interval
O componente Windows Forms Timer tem uma Interval propriedade que especifica o número de
milissegundos que passam entre um evento Timer e a próxima. A menos que o componente é
desativado, um timer continua a receber o Tick evento em aproximadamente iguais intervalos de
tempo.
A propriedade Interval
A Interval propriedade tem algumas limitações a serem considerados quando você está
programando um Timer componente:
• Se seu aplicativo ou outro aplicativo está fazendo demandas pesadas no sistema —, como
loops longos, intenso cálculos, ou unidade, rede, ou acesso — da porta seu aplicativo pode
possível obter eventos timer com freqüência como a Interval propriedade especifica.
• O intervalo pode ser entre 1 e 64,767, inclusive, que significa que mesmo o intervalo mais
longo não é muito maior que um minuto 64.8 sobre (segundos).
• O intervalo não é garantido para decorrer exatamente no tempo. Para garantir a precisão,
o timer deve verificar o relógio do sistema conforme necessário, em vez de tentar se manter
controle de tempo acumulado internamente.
• O sistema gera 18 pulsos do relógio por segundo — tão mesmo embora a Interval
propriedade é medida em milissegundos, a precisão de um intervalo VERDADEIRO é mais de
um-eighteenth de um segundo.
Como executar procedimentos na intervalos do conjunto com o componente Timer Windows

Forms:
Às vezes, convém criar um procedimento que executa em intervalos específicos de tempo até que
um loop foi concluída ou que seja executado quando um intervalo de tempo definido tiver
decorrido. O Timer componente permite tal um procedimento.
Observação
Existem algumas limitações ao usar o Timer Componente. Para obter mais informações, consulte
Limitações do componente Timer de formulários do Windows na propriedade Interval.
Para executar um procedimento em intervalos definidos com o componente timer

1. Adicionar ao seu formulário. um Timer Consulte a seção exemplo a seguir para obter uma
ilustração de como fazer isso programaticamente. Também Visual Studio oferece suporte
para adicionar componentes a um formulário.
2. Defina a Interval propriedade (em milissegundos) para o timer. Esta propriedade determina
quanto tempo irá passar antes o procedimento é executado novamente.
Observação
Quanto maior a freqüência de um evento Timer ocorrer, mais tempo do processador é usado em
responder ao evento. Isso pode diminuir o desempenho geral. Não defina um intervalo menor do
que você precisa.
3. Escreva código apropriado no manipulador Tick de eventos. O código você escreve nesse
evento será executado no intervalo especificado na propriedade Interval.
4. Defina a Enabled propriedade para true Para iniciar o cronômetro. O Tick evento
começará a ocorrer, executar o procedimento no intervalo conjunto.
5. Ao tempo apropriado, defina a Enabled propriedade como false para interromper o
procedimento seja executado novamente. Definir o intervalo para 0 não faz com que o timer
para parar.
Exemplo
Este primeiro exemplo de código controla a hora do dia em incrementos um segundo. Ele usa um
Button, a Label, e um Timer componente em um formulário. A Interval propriedade é definida
como 1000 (igual a um segundo). No evento Tick, legenda do rótulo é definida como a hora atual.
Quando o botão for clicado, a Enabled propriedade é definida como false, interrompendo o timer
de atualizar legenda do rótulo. O exemplo de código a seguir requer que você tenha um formulário
com um Button controle denominado Button1, um Timer controle chamado Timer1, e um Label
controle chamado Label1.
C#
private void InitializeTimer() { //' Run this procedure in an appropriate event. // Set to 1 second.
Timer1.Interval = 1000; // Enable timer. Timer1.Enabled = true; Button1.Text = "Stop"; } private void
Timer1_Tick(object Sender, EventArgs e) { // Set the caption to the current time. Label1.Text =
DateTime.Now.ToString(); } private void Button1_Click() { if ( Button1.Text == "Stop" ) { Button1.Text =
"Start"; Timer1.Enabled = false; } else { Button1.Text = "Stop"; Timer1.Enabled = true; } }
Este exemplo de código segundo executa um procedimento cada milissegundos 600 até que um
loop tenha terminado. O exemplo de código a seguir requer que você tenha um formulário com um
Button controle denominado Button1, um Timer controle chamado Timer1, e um Label controle
chamado Label1.
C#
// This variable will be the loop counter. private int counter; private void InitializeTimer() { // Run this
procedure in an appropriate event. counter = 0; timer1.Interval = 600; timer1.Enabled = true; // Hook up
timer's tick event handler. this.timer1.Tick += new System.EventHandler(this.timer1_Tick); } private void
timer1_Tick(object sender, System.EventArgs e) { if (counter >= 10) { // Exit loop code. timer1.Enabled =
false; counter = 0; } else { // Run your procedure here. // Increment counter. counter = counter + 1;
label1.Text = "Procedures Run: " + counter.ToString(); } }

Controle toolBar Windows (formulários)
Observação
O ToolStrip controle substitui e adiciona funcionalidade para o ToolBar controle; no entanto, o

ToolBar controle foi mantido para compatibilidade com versões anteriores e uso futuro, se você
escolher.
O controle Windows Forms ToolBar for usado como uma barra de controle que exibe uma linha
de menus suspensos e botões de bitmap que Ativar comandos em formulários. Assim, clicar em
um botão de ferramentas equivale a escolher um comando de menu. Os botões podem ser
configurado para aparecem e se comportam como botões de ação, menus drop-down ou
separadores. Normalmente, uma barra de ferramentas contém botões e menus que correspondem
aos itens em um aplicativo na estrutura de menu, fornecendo acesso rápido às funções usadas
com mais freqüência do aplicativo e comandos.
Observação
Propriedade do ToolBar controle DropDownMenu tem uma instância da classe ContextMenu

como uma referência. Cuidadosamente a referência você passar ao implementar esse tipo de
botão nas barras de ferramentas em seu aplicativo, como a propriedade aceitará qualquer objeto
que herda da classe Menu.
Visão geral sobre de controle toolBar (formulários do

Windows)
Observação

escolher.
O controle Windows Forms ToolBar for usado como uma barra de controle que exibe uma linha
de menus suspensos e botões de bitmap que Ativar comandos em formulários. Assim, clicar em
um botão de ferramentas pode ser um equivalente ao escolher um comando de menu. Os botões
podem ser configurado para aparecem e se comportam como pushbuttons, menus drop-down ou
separadores. Normalmente, uma barra de ferramentas contém botões e menus que correspondem
aos itens em um aplicativo na estrutura de menu, fornecendo acesso rápido às funções usadas
com mais freqüência do aplicativo e comandos.
Trabalhando com o controle ToolBar
Um ToolBar controle normalmente está " ancorada " ao longo da parte superior da sua janela pai,
mas ela também pode ser ancorada para qualquer lado da janela. Uma barra de ferramentas pode
exibir dicas de ferramentas quando o usuário aponta o ponteiro do mouse em um botão da barra
de ferramentas. Uma dica de ferramenta é uma janela pop-up pequena que descreve
resumidamente o botão ou finalidade do menu. Para exibir as dicas de ferramentas, a
ShowToolTips propriedade deve ser definida para true.

Observação
Determinados aplicativos apresentam controles muito semelhantes à barra de ferramentas que

têm a capacidade de " flutuar " acima a janela do aplicativo e ser reposicionada. O controle
Windows Forms ToolBar é não podem fazer essas ações.
Quando a Aparência propriedade é definida para Normal, os botões da barra de ferramentas

aparecem elevado e tridimensional. Você pode definir a Appearance Propriedade da barra de
ferramentas para Flat para dar a barra de ferramentas e seus botões uma aparência plana.
Quando o ponteiro do mouse se move sobre um botão plano, aparência do botão muda para
tridimensional. Botões da barra de ferramentas podem ser dividida em grupos lógicos, usando
separadores. Um separador é um botão da barra de ferramentas com a Estilo propriedade
definida como Separador. Ele é exibido como espaço vazio na barra de ferramentas. Quando tiver
uma aparência plana, barra de ferramentas separadores botão aparecem como linhas em vez de
espaços entre os botões.
O ToolBar controle permite que você para criar barras de ferramentas, adicionando Button
objetos a uma Buttons coleção. Você pode usar o editor coleção para adicionar botões a um
ToolBar controle; cada Button objeto deve ter texto ou uma imagem atribuída, embora você pode
atribuir ambos. A imagem é fornecida por um componente Associado ImageList. Do Adicionar em
tempo de execução, você pode adicionar ou remover botões usem o ToolBarButtonCollection e
Remover métodos. Para programar os botões de usar o ToolBar, a Botão propriedade da classe
ToolBarButtonClickEventArgs para determinar qual botão foi clicado. Adicione código aos
ButtonClick Eventos a ToolBar,
Como adicionar botões a um controle ToolBar usando o

criador:
Observação
ToolBar controle foi mantida para compatibilidade com versões anteriores e uso futuro, se você
escolher.
Uma parte integral do controle ToolBar é os botões você adicionar a ela. Esses pode ser usado
para fornecer acesso fácil aos comandos de menu ou, como alternativa, eles podem ser
colocadas em outra área da interface do usuário do seu aplicativo para expor comandos para os
usuários que não estão disponíveis na estrutura menu.
O procedimento a seguir requer um Windows Application projeto com um formulário contendo

um ToolBar controle.Para obter informações sobre como configurar esse projeto, consulte Como:
Criar um projeto de aplicativos Windows e Como adicionar controles ao Windows Forms:.
Observação
Para adicionar botões em tempo de criação

1. Selecione o ToolBar controle.

2. Na janela Properties, clique na Buttons propriedade para selecioná-lo e clique no Ellipsis.
( ) botão para abrir o ToolBarButton Collection Editor
3. Uso e Remove botões para adicionar e remover botões do controle ToolBar. o Add
4. Configurar as propriedades dos botões individuais na janela Properties que aparece no
painel no lado direito do editor. A tabela a seguir mostra algumas propriedades importantes
a considerar.
Propriedade Descrição
DropDownMenu Define o menu exibido em no botão da barra de ferramentas drop-down. Defina
a DropDownButton propriedade do botão Style Barra de ferramentas. Essa
propriedade tem uma instância da classe ContextMenu como uma referência.
PartialPush Define se um botão da barra de ferramentas Estilo toggle-é parcialmente
pressionado. Defina a ToggleButton propriedade do botão Style Barra de
ferramentas.
Pushed Define se um botão da barra de ferramentas Estilo toggle-está atualmente no
estado pushed. Propriedade do botão Style Barra de ferramentas deve ser
definida para ToggleButton ou PushButton.. ou PushButton
Style Define o estilo do botão da barra de ferramentas. Deve ser um dos valores na
enumeração ToolBarButtonStyle.
Text A seqüência de texto exibido pelo botão.
ToolTipText O texto que aparece como uma dica de ferramenta para o botão.
5. Clique OK para fechar a caixa de diálogo e criar os painéis você especificou.
Como adicionar botões a um controle ToolBar:
Observação
escolher.
Uma parte integral do ToolBar controle é os botões você adicionar a ela. Esses podem ser
usados para fornecer acesso fácil aos comandos de menu ou, como alternativa, que pode ser
colocada em outra área da interface de usuário de seu aplicativo para expor comandos para os
usuários que não estão disponíveis na estrutura do menu.
Os exemplos abaixo suponha que um ToolBar controle foi adicionado a um formulário do

Windows (Form1).
Para adicionar botões programaticamente

1. Em um procedimento, Criar botões da barra de ferramentas, adicionando-os para a
System.Windows.Forms.ToolBar.Buttons coleção.
2. Especificar configurações de propriedades para um botão individual, passando de índice
do botão via a Buttons propriedade.
O exemplo a seguir assume um formulário com um ToolBar controle já adicionado.
Observação
A System.Windows.Forms.ToolBar.Buttons coleção é uma coleção base zero, para código

deve prosseguir adequadamente.
C#
public void CreateToolBarButtons() { // Create buttons and set text property.
toolBar1.Buttons.Add("One"); toolBar1.Buttons.Add("Two"); toolBar1.Buttons.Add("Three");
toolBar1.Buttons.Add("Four"); // Set properties of StatusBar panels. // Set Style property.
toolBar1.Buttons[0].Style = ToolBarButtonStyle.PushButton; toolBar1.Buttons[1].Style =
ToolBarButtonStyle.Separator; toolBar1.Buttons[2].Style = ToolBarButtonStyle.ToggleButton;
toolBar1.Buttons[3].Style = ToolBarButtonStyle.DropDownButton; // Set the ToggleButton's
PartialPush property. toolBar1.Buttons[2].PartialPush = true; // Instantiate a ContextMenu
component and menu items. // Set the DropDownButton's DropDownMenu property to // the
context menu. ContextMenu cm = new ContextMenu(); MenuItem miOne = new MenuItem("One");
MenuItem miTwo = new MenuItem("Two"); MenuItem miThree = new MenuItem("Three");
cm.MenuItems.Add(miOne); cm.MenuItems.Add(miTwo); cm.MenuItems.Add(miThree);
toolBar1.Buttons[3].DropDownMenu = cm; // Set the PushButton's Pushed property.
toolBar1.Buttons[0].Pushed = true; // Set the ToolTipText property of 1 of the buttons.
toolBar1.Buttons[1].ToolTipText = "Button 2"; }
Como definir um ícone para um botão toolbar usando o criador:
Observação
ToolBar controle foi mantida para compatibilidade com versões anteriores e uso futuro, se você
escolher.
Botões ToolBar são capazes de exibir ícones dentro deles para fácil identificação pelos usuários.
Isso é conseguido através adicionando imagens para o ImageList componente e associando-lo
com o ToolBar controle.
O procedimento a seguir requer um Windows Application projeto com um formulário contendo

um ToolBar controle e um ImageList componente. Para obter informações sobre como configurar
esse projeto, consulte Como: Criar um projeto de aplicativos Windows e Como adicionar controles
ao Windows Forms:.
Observação
Para definir um ícone para um botão da barra de ferramentas em tempo de criação

1. Adicionar imagens para o ImageList Componente. Para obter mais informações, consulte
Como adicionar ou remover imagens ImageList com o designer:.
2. Selecione o ToolBar controle no formulário.
3. Na janela Properties, defina a ToolBar propriedade controle é ImageList para o
ImageList Componente.
4. A elipse a ToolBar propriedade do controle Buttons para selecioná-lo, clique no
ToolBarButton Collection Editor. ( ) botão para abrir

5. Use o Add botão para adicionar botões para o ToolBar controle.
6. Na janela Properties que aparece no painel no lado direito do conjunto ToolBarButton
Collection Editor, a ImageIndex propriedade de cada barra de ferramentas botão para um
dos valores na lista, que é desenhado entre as imagens adicionadas ao ImageList
componente.
Como definir um ícone para um botão toolbar:
Observação
escolher.
Botões ToolBar são capaz de exibir ícones dentro deles para facilitar a identificação pelos
usuários. Isso é conseguido através de adicionando imagens para o Componente ImageList
(Windows Forms) componente e então associar o ImageList componente ao ToolBar controle.
Para definir um ícone para um botão da barra de ferramentas programaticamente

1. Em um procedimento, instanciar um ImageList componente e um ToolBar controle.
2. No mesmo procedimento, atribuir uma imagem para o ImageList Componente.
3. No mesmo procedimento, atribuir o ImageList controle para o ToolBar controle e atribuir a
ImageIndex propriedade dos botões da barra de ferramentas individuais.
No exemplo de código a seguir, o caminho definido para o local da imagem é a My
Documents pasta. Isso é feito, porque você pode assumir que a maioria dos computadores
que executam o sistema operacional Windows inclua este diretório. Isso também permite
que usuários com níveis de acesso sistema mínimo para executar o aplicativo com
segurança. O exemplo a seguir assume um formulário com um PictureBox controle já
adicionado.
Seguindo as etapas acima, você deve ter escrito código semelhante ao que exibido abaixo.
C#
public void InitializeMyToolBar() { // Instantiate an ImageList component and a ToolBar control.
ToolBar toolBar1 = new ToolBar(); ImageList imageList1 = new ImageList(); // Assign an image to
the ImageList component. // You should replace the bold image // in the sample below with an icon
of your own choosing. // Note the escape character used (@) when specifying the path. Image
myImage = Image.FromFile (System.Environment.GetFolderPath
(System.Environment.SpecialFolder.Personal) + @"\Image.gif"); imageList1.Images.Add(myImage);
// Create a ToolBarButton. ToolBarButton toolBarButton1 = new ToolBarButton(); // Add the
ToolBarButton to the ToolBar. toolBar1.Buttons.Add(toolBarButton1); // Assign an ImageList to the
ToolBar. toolBar1.ImageList = imageList1; // Assign ImageIndex property of the ToolBarButton.
toolBarButton1.ImageIndex = 0; }
HOW TO: eventos menu do disparador para botões da barra de ferramentas
Observação
escolher.

Se o formulário Windows recursos um ToolBar controle com botões da barra de ferramentas, será
desejar saber qual botão o usuário clicar.
No evento ButtonClick do controle ToolBar, você pode avaliar a Botão propriedade da classe
ToolBarButtonClickEventArgs. No exemplo abaixo, uma caixa de mensagem é mostrada,
indicando qual botão foi clicado. Para obter detalhes, consulte Classe MessageBox.
O exemplo a seguir supõe que tem um ToolBar controle foi adicionada a um formulário do
Windows.
Para manipular o evento Click em uma barra de ferramentas

1. Em um procedimento, adicionar botões de barras de ferramentas para o ToolBar controle.
C#
public void ToolBarConfig() { toolBar1.Buttons.Add(new ToolBarButton("One"));
toolBar1.Buttons.Add(new ToolBarButton("Two")); toolBar1.Buttons.Add(new
ToolBarButton("Three")); toolBar1.ButtonClick += new
ToolBarButtonClickEventHandler(this.toolBar1_ButtonClick); }
2. Adicionar um manipulador de eventos para o ToolBar evento do controle ButtonClick. Use

um caso Alternar instrução e a ToolBarButtonClickEventArgs classe para determinar o
botão da barra de ferramentas que foi clicado. Com base nisso, mostrar uma caixa
mensagem apropriada.
Observação
Uma caixa de mensagem está sendo usada exclusivamente como um espaço reservado, neste
exemplo. Vontade para adicionar outro código seja executado quando os botões da barra de
ferramentas são clicados.
C#
protected void toolBar1_ButtonClick(object sender, ToolBarButtonClickEventArgs e) { // Evaluate the
Button property of the ToolBarButtonClickEventArgs // to determine which button was clicked. switch
(toolBar1.Buttons.IndexOf(e.Button)) { case 0 : MessageBox.Show("First toolbar button clicked"); break;
case 1 : MessageBox.Show("Second toolbar button clicked"); break; case 2 : MessageBox.Show("Third
toolbar button clicked"); break; } }

Páginas da Web e Serviços da Web (Como
Fazer em C#)
Esta página faz referência a ajuda sobre tarefas de aplicativos da Web amplamente executadas.
Para ver outras categorias de tarefas populares abordadas na ajuda, consulte Como fazer em C#.
O que há de novo no desenvolvimento para Web no Visual

Studio
O Microsoft Visual Studio 2005 inclui a ferramenta de desenvolvimento para Web, Visual Web
Developer, que é um conjunto de ferramentas e utilitários para criação de sites da Web ASP.NET
versão 2.0. O Visual Web Developer representa uma melhoria evolutiva no suporte para a criação
de sites Web. O Visual Web Developer continua trazendo os benefícios de produtividade do
ambiente de desenvolvimento integrado (IDE) ao apresentar uma enorme gama de melhorias.
Os aprimoramentos principais para esta versão do Visual Web Developer incluem o seguinte:
• Suporte ao ASP.NET 2.0.

O Visual Web Developer oferece suporte aos novos recursos do ASP.NET 2.0, incluindo um
conjunto de novos controles que são introduzidos no ASP.NET 2.0. Além disso, o Visual Web
Developer adota intimamente recursos nativos do ASP.NET 2.0 e não adiciona recursos
específicos do designer. Por exemplo, o Visual Web Developer não incorpora marcas
específicas do designer em suas páginas ASP.NET 2.0.
• Opções de projetos e implantações mais flexíveis.
O Visual Web Developer permite que você crie aplicativos tradicionais do Serviço de
Informações da Internet da Microsoft (IIS) na raiz IIS em computadores locais e remotos, e
também oferece suporte a raízes virtuais, abertura de sites da Web usando File Transfer
Protocol (FTP) e uso de arquivos autônomos que residam fora um projeto. O resultado final é
que é substancialmente mais fácil criar e implantar aplicativos ASP.NET 2.0.
• Modelo code-behind aprimorado.
O Visual Web Developer pode criar páginas usando qualquer modelo code-behind novo ou
incluindo código na página ASP.NET (o arquivo .aspx).
• Recursos aprimorados de programação.
Muitas tarefas básicas foram bastante simplificadas. Por exemplo, você pode criar uma página
com dados vinculados qualquer que seja a codificação. Os novos controles do ASP.NET 2.0
adicionam funcionalidades substanciais que requereriam que você escrevesse seu próprio
código. O Microsoft IntelliSense e tecnologias relacionadas foram estendidos para trabalhar
praticamente em todo lugar.
As seções a seguir fornecem um resumo de alto nível das alterações no Visual Web Developer.
• Web Sites
• Projetos
• Modelo de Compilação Dinâmica
• Edição
• Programação

• Modelo Code-Behind Melhorado
• Controles
• Controle e Ligação de Dados
• Conversão de Sites Web Existentes
Para informações sobre novos recursos no ASP.NET 2.0, consulte O que há de novo no ASP.NET
Web Sites e Projetos
O Visual Web Developer apresenta uma abordagem flexível para a criação de web sites (também
chamados projetos e aplicações web em versões anteriores do Visual Web Developer e Web
Page Designer, respectivamente). Web sites no Visual Web Developer não são, necessariamente,
vinculados ao IIS nem a pastas físicas da raiz do IIS.
Agora você pode criar os seguintes tipos de web sites:
• Sistema de Arquivos.
Você pode manter todos os arquivos de um site em uma pasta simples. O sistema de arquivos
de web sites não dependem do IIS. Para obter detalhes, consulte Passo-a-passo: Criando uma
página da web básica no Visual Web Developer.
• IIS Local.
Como nas versões anteriores do Visual Studio, você pode criar aplicativos do IIS que podem
residir na raiz local do IIS ou em um diretório virtual. Você também pode criar pastas virtuais.
Para obter detalhes, consulte Passo-a-passo: Acesso a Dados Básico em Páginas da Web.
• Remoto.
Você pode criar aplicativos residentes em servidores remotos que oferecem suporte ao
FrontPage 2002 Server Extensions da Microsoft. Este é o modelo que foi usado em versões
anteriores do Visual Web Developer e continua recebendo suporte nesta versão.
• FTP.
Você pode abrir web sites através de FTP. Para obter detalhes, consulte Passo-a-passo:
Edição de Web Sites com FTP no Visual Web Developer.
Servidor de Desenvolvimento do ASP.NET
A ferramenta de desenvolvimento Web do Visual Web Developer inclui um servidor de aplicação

de teste simplificado, o ASP.NET Development Server, que você pode usar para testar sistemas
de arquivos de web sites, sem precisar utilizar o IIS. Para mais informações, consulte Servidores
Web no Visual Web Developer.
Projetos
Na nova versão do Visual Web Developer, web sites não dependem de arquivos de projeto e de
solução. Você pode adicionar arquivos a um web site no Visual Web Developer, ou usar o
Microsoft Windows Explorer, e os arquivos são automaticamente parte do web site.
O Visual Web Developer ainda cria arquivos de projeto e de solução para armazenar uma
pequena quantidade de informações específicas de projeto, como as configurações IDE. Boa
parte das informações que anteriormente eram armazenadas em arquivos de projeto, agora são
armazenadas no arquivo Web.config, como configurações padrão do ASP.NET 2.0, ou não são
mais necessárias. O arquivo de projeto não armazena informação necessária para executar o
aplicativo.

Trabalhar sem um modelo de projeto não somente torna possível adicionar, editar e remover
arquivos de fora do Visual Web Developer, como também torna mais fácil a mais de um
desenvolvedor trabalhar juntos para criar um site. Mais de um desenvolvedor pode adicionar ou
remover arquivos de um web site sem exigir acesso a um arquivo centralizado de projeto, que
precisa ser atualizado com as informações do arquivo. Além disso, é mais fácil manter arquivos do
web site em um sistema controlado por origem, como o sistema de controle de versão do
Microsoft Visual SourceSafe, porque os desenvolvedores não têm, exclusivamente, que fazer o
check-out em um arquivo de projeto para adicionar arquivos ao web site.
Modelo de Compilação Dinâmica
No Visual Web Developer, web sites não usam mais o modelo de compilação que foi usado em
versões anteriores, no qual o código executável do projeto inteiro era compilado em um único
assembly. Em vez disso, como padrão, a nova versão usa o modelo de compilação dinâmica que
é nativo para o ASP.NET 2.0.
Trabalhar com web sites que não produzem um assembly executável como saída tem várias
vantagens:
• Você pode testar web sites que contêm páginas ainda em desenvolvimento — páginas que
contêm erros de compilação não impedem que outras páginas do web site sejam executadas.
• Para desenvolvimento em web sites grandes, não é necessário que a aplicação inteira seja
recompilada sempre que uma alteração é feita a uma página única ou componente. Quando
um desenvolvedor altera uma única página, somente essa página é recompilada quando ela é
solicitada em seguida.
• Diferentes desenvolvedores podem fazer edições em diferentes páginas ao mesmo tempo,
sem interferir nas alterações do outro, como pode acontecer quando se compila o projeto para
um assembly único no Microsoft Visual Studio .NET 2003.
Quando você testa um web site, ele ainda é compilado (built). Entretanto, a etapa de compilação é
usada como verificação, tal que que todas as páginas e suas dependências possam ser
compiladas; a saída do processo de compilação não é usada como base para executar o web site.
Essa etapa de compilação é mais abrangente do que era em versões anteriores porque ele valida
não apenas a compilação do código como também, a localização de erros na sintaxe de marcação
e no arquivo Web.config.
Publicação de Web Sites
Por alguns desenvolvedores não optarem pela implantação de código fonte nos seus web sites, a
ferramenta de desenvolvimento da Web, o Visual Web Developer, oferece a opção de pré-
compilação e implantação de um web site usando o comando Build Web Site. O comando Build
Web Site executa o compilador sobre o site inteiro (não apenas nos arquivos de código), e produz
um layout de web site que você pode implantar em um servidor de produção. O layout inclui
assemblies para páginas individuais, que incluem o código e a marcação para a página (ou seja,
os arquivos .aspx são compilados também).
Observação
Esta propriedade não está disponível no Visual Web Developer Express Edition.
O benefício principal da pré-compilação é que ela permite que você implante apenas código
executável, colocando uma medida de proteção em sua propriedade intelectual. Além disso, a pré-
compilação localiza qualquer erro em tempo de compilação, em páginas ou código dependente.

Finalmente, a pré-compilação melhora o desempenho e reduz o tempo que leva para as páginas
de seu web site processarem na primeira vez.
Edição de páginas
O Visual Web Developer oferece os seguintes aperfeiçoamentos para criar e editar páginas da
web:
• Suporte a novos recursos de página.

O Web Page Designer do Visual Web Developer apresenta suporte WYSIWYG para os novos
elementos de página do ASP.NET 2.0, como em páginas mestras. Para obter detalhes,
consulte Visão Geral Sobre Páginas Mestras do ASP.NET e Passo-a-passo: Criando e Usando
Páginas-Mestre do ASP.NET no Visual Web Developer.
• Preservação do código fonte.
O Visual Web Developer mantém a formatação HTML da sua página quando você alterna entre
o modo Design e o Source, e quando você salva os arquivos.
• Geração e Validação de HTML Avançadas.
O Visual Web Developer oferece mais opções para gerar e validar o HTML da sua página.
Como padrão, o Web Page Designer cria uma marcação que é compatível com XHTML 1.1, e
novos esquemas incluem suporte para diversas variações de XHTML. Você pode definir
opções para determinar como, estritamente, o Visual Web Developer deve validar os
elementos em sua página e HTML. Além disso, o Visual Web Developer fornece informações
de erro em ToolTips.
• Funcionalidade da ação Arrastar-e-Soltar no modo Source.
Você pode arrastar controles da Toolbox (caixa de ferramentas) enquanto estiver no modo
Source.
Programação
O Visual Web Developer inclui uma série de aperfeiçoamentos para o editor de códigos que o
ajudam a programar mais produtivamente. Ele inclui o seguinte:
• Tecnologia Microsoft IntelliSense.

A conclusão de instrução está em praticamente todos os locais quando você edita páginas da
Web. A tecnologia IntelliSense ajuda a criar código code-behind e páginas de arquivo único,
tags de marcação, diretivas de páginas e assim por diante.
• Evento de listas suspensas.
Você pode criar manipuladores de evento no modo Fonte usando eventos de lista suspensa,
como você poderia fazer anteriormente somente no modo Código. A janela Properties agora
permite que você crie manipuladores de eventos para o Visual Basic e C#.
• Suporte a páginas de arquivo único.
O Editor de códigos agora fornece suporte equivalente para code-behind e páginas de arquivo
único em ASP.NET 2.0. (Para informações sobre alterações para o modelo code-behind,
consulte Modelo Code-Behind Aperfeiçoado.) Ambos os modelos de código suportam
coloração de sintaxe, tecnologia IntelliSense e assim por diante.
• Código compartilhado.
Classes para as quais o código fonte está na pasta App_Code de sua aplicação da web são
automaticamente referenciadas; se você tiver compilado componentes, você pode inseri-los na
pasta Bin para que o Visual Web Developer os referencie automaticamente. A funcionalidade
IntelliSense obtém informações sobre qualquer componente que estiver instalada na pasta

App_Code ou Bin, de sua aplicação. Para obter detalhes, consulte Passo-a-passo: Usando
Código Compartilhado em Web Sites no Visual Web Developer.
• Depuração.
Você tem facilidades completas de depuração para Web Sites locais, incluindo arquivos de
sistema. A depuração é menos complexa e mais rápida do que nas versões anteriores. Para
obter detalhes, consulte Passo-a-passo: Depuração de Páginas da Web no Visual Web
Developer.
Modelo Code-Behind Aperfeiçoado
Uma diferença significativa entre versões anteriores do Visual Web Developer e esta versão está
no funcionamento de páginas code-behind. No Microsoft Visual Studio .NET 2002, quando você
cria página de Web Forms, o Visual Web Developer cria um arquivo .aspx com uma marcação e
um arquivo .vb ou .cs separado (o arquivo code-behind) para o código da página. O arquivo code-
behind define uma classe completa que é derivada da classe Page.
O Web Page Designer guarda o arquivo .aspx e o arquivo code-behind na sincronização. Por
exemplo, se você adicionou um controle de servidor web ao arquivo .aspx, o Web Page Designer
criou uma variável de instância correspondente no arquivo code-behind para aquele controle.
Nesta versão, o modelo code-behind tira proveito de um novo recurso de linguagem, conhecido
como classes parciais. O arquivo code-behind para uma página não é uma definição completa de
classe. Em vez disso, ele inclui somente o código do aplicativo que você precisa, como
manipuladores de eventos. A classe parcial code-behind não necessita incluir variáveis de
instância; o ASP.NET 2.0 infere as instâncias de controle da marcação, no tempo de compilação.
Se você estiver programando em C#, você não precisa incluir representantes explícitos para
vinculação de evento, porque o ASP.NET 2.0 pode deduzi-los dos atributos de evento (por
exemplo, onclick) na marcação de controle. No Visual Basic, você pode adicionar uma cláusula
Handles para a declaração de um método de evento, como no modelo anterior, para vincular o
evento ao manipulador.
O novo modelo code-behind oferece uma série de vantagens sobre o modelo anterior, da seguinte
maneira:
• Separação verdadeira de código e marcação.

Em versões anteriores, a marcação e o código eram armazenados em arquivos separados.
Versões anteriores necessitavam manter os arquivos em sincronização usando variáveis de
instância e representantes de evento. No entanto, não era prático trabalhar com os arquivos
separados. Por exemplo, não era prático para um desenvolvedor de página trabalhar no layout
de uma página enquanto outro desenvolvedor trabalhava no código. Nesta versão, isso é muito
mais prático.
• Menos complexidade na referência de controles.
Conforme observado, o novo modelo code-behind não requer variáveis de instância explícitas
na página code-behind. Embora versões anteriores gerenciassem variáveis de instância, não a
faziam para todos os controles — notadamente para controles de usuário ou para alguns
elementos HTML que foram declarados como controles. Nesta versão, devido ao fato de
nenhuma variável de instância ser necessária, todos os controles, incluindo controles de
usuário, são referenciados implicitamente.
• Menos geração de código.
O novo modelo code-behind não contém praticamente nenhum código gerado além da própria
definição de classe. Não há nenhuma área reservada no code-behind que o editor possa
sobrescrever.
Controles

O Visual Web Developer oferece suporte aos novos controles ASP.NET 2.0, cujas novas
funcionalidades resultam no aumento significativo da produtividade. Além dos novos controles de
hospedagem, o Web Page Designer inclui melhoras para ajudá-lo a trabalhar mais facilmente com
controles. Destaques incluem o seguinte:
• Modelo de edição mais consistente e eficiente.

O modelo geral para trabalhar com controles é mais consistente entre os controles e permite
que você execute várias outras ações sem precisar usar a janela Properties ou editar a sintaxe
declarativa de um controle.
• Exibição visual de controles.
O Web Page Designer melhorou o suporte para processamento de controles, por exemplo, os
controles de usuário são agora processados visualmente no modo Design.
• Edição baseada em tarefa.
Quando você trabalha com controles, eles exibem um menu de marcas inteligentes (um menu
flutuante de atalho de tarefas) para o controle atual. Ações típicas que são oferecidas pela
edição baseada em tarefas incluem edição de modelos e configuração de dados vinculados.
• Edição de modelo.
O Web Page Designer fornece uma interface simplificada e mais intuitiva para criar e editar
modelos em controles complexos, como o controle DataList e o GridView.
• Edição de Tabela.
É muito mais fácil agora criar e editar tabelas HTML no Web Page Designer. Para obter
detalhes, consulte Passo-a-passo: Editando Tabelas HTML no Visual Web Developer.
Extensibilidade de Controle
Agora você pode estender controles de novas e eficientes maneiras. Como antes, você pode criar
controles de usuário e controles personalizados. Esta versão da ferramenta de desenvolvimento
da Web, o Visual Web Developer, fornece suporte aprimorado para controles de usuário, incluindo
processamento WYSIWYG no modo Design e janela Properties de suporte.
Você pode estender o comportamento em tempo de execução dos controles criando adaptadores
que definem a saída do controle para um dispositivo específico ou navegador. Em tempo de
execução, o ASP.NET 2.0 determina o tipo de dispositivo que gerou a solicitação e chama um
adaptador de controle para processar a saída apropriada para este dispositivo, para um dado
controle. Criando um adaptador para um controle e uma classe específica de dispositivo, você
pode personalizar a saída para o controle do dispositivo. Adaptadores são especialmente úteis
para criar processamento personalizado para novos dispositivos. Para mais informações, consulte
Criação de Adaptadores de Controle do Servidor ASP.NET - Uma Introdução.
Se você desenvolver controles comuns, você terá melhorado o suporte para hospedar seu
controle em um Web Page Designer, incluindo o seguinte:
• Classes que permitem que você adicione edição baseada em região aos controles em
tempo de design.
• Suporte a edição baseada em tarefas, de modo que você possa definir verbos (tarefas)
que são expostos para o controle usando atalhos de menu no Web Page Designer.
• Serviços de edição de modelos que simplificam a adição de suporte para modelos nos
controles.
• Controles podem se beneficiar dos serviços baseados em ferramentas para melhor
interagir com o ambiente de hospedagem. Por exemplo, controles tem acesso à diretiva de
página, ao sistema do projeto e ao documento atual.

Controles de Dados e Vinculação de Dados
Trabalhar com dados é uma parte importante em muitas páginas web em ASP.NET 2.0, e o Visual
Web Developer inclui vários aprimoramentos para facilitar a implementação e gerenciamento do
acesso a dados. O objetivo geral para a vinculação de dados no ASP.NET 2.0 é tornar possível a
realização de uma variedade de cenários de vinculação de dados, sem precisar gravar qualquer
código. Esta versão suporta essa meta e a estende oferecendo assistentes que o ajudam a
configurar a vinculação de dados e criação de componentes de dados.
Ligação de Dados com Controles de Fonte de Dados
O modelo para vincular controles de página a fontes de dados foi aperfeiçoado

consideravelmente. O modelo de vinculação de dados do Microsoft Visual Studio .NET 2002
necessitava que você adicionasse componentes de dados como objetos e conexões dataset na
página. Em seguida, você precisava escrever o código para gerenciar dados vinculando a
controles de dados, como o controle DataList e o DataGrid.
Para simplificar vinculação de dados, o ASP.NET 2.0 introduz controles de fonte de dados.
Controles de fonte de dados fornecem um único objeto no qual você pode, declarativamente,
definir o seguinte:
• Informações de conexão.
• Consultas (um instrução SQL, nome de parâmetro armazenado ou nomes dos métodos
para chamar em um objeto).
• Parâmetros — Você pode definir parâmetros declarativamente e especificar que eles
obtenham seus valores de um controle na página, de uma seqüência de caracteres de
consulta, de variáveis de sessão ou de outras fontes.
• As opções de comportamento (dependendo do controle da fonte de dados), como
paginação e cache.
Em geral, você não precisa trabalhar diretamente com os objetos que são usados para gerenciar
acesso a dados, como datasets ou leitores de dados. Controles de fonte de dados criam
componentes de dados de forma transparente. Você não trabalha com esses componentes, mas
não precisa estar ciente deles quando desejar usar um recurso, como o de paginação, que
depende da escolha entre um dataset e um leitor de dados.
O ASP.NET 2.0 fornece controles de fonte de dados para diferentes tipos de armazenamentos de
dados, incluindo SQL (para OLE DB e bancos de dados Open Database Connectivity [ODBC]),
arquivos XML e objetos comerciais. Todos os controles de fonte de dados expõem a mesma
interface para controles de dados na página, como o controle DataList e o Repeater, e o novo
controle GridView pode ligar o mesmo caminho a qualquer controle de fonte de dados, apesar do
armazenamento de dados subjacente que eles representam, e depois mostra os dados na página.
O resultado é que você pode usar a matriz completa dos controles de dados do ASP.NET 2.0 para
trabalhar com uma ampla variedade de fontes de dados.
Para ajudá-lo a criar e configurar controles de fonte dados, a ferramenta de desenvolvimento da

Web, o Visual Web Developer, inclui assistentes que o ajudam a criar conexões, definir consultas
ou especificar métodos para chamar e configurar parâmetros.
Controles de dados avançados
Todos os controles de dados no ASP.NET 2.0 foram aprimorados para trabalhar com controles de
fonte de dados. Em vez de apontar um controle em um dataset ou leitor de dados, você referencia
um controle de fonte de dados. Depois, o controle de dados e o controle da fonte de dados

trabalham juntos para gerenciar, automaticamente, a vinculação de dados, para que na maioria
dos casos, você não precise escrever código para executar a vinculação.
Como resultado, você pode tirar proveito da vinculação de dados automática, em qualquer
controle de vinculação de dados. Além disso, o ASP.NET 2.0 introduz novos controles de dados
que fornecem funcionalidades adicionais. Eles incluem o seguinte:
• O controle GridView, que é o sucessor do controle DataGrid.

O controle GridView automatiza muitos dos recursos do controle DataGrid, para que você não
precise escrever código para edição, classificação ou paginação. Para situações em que você
desejar personalizar o comportamento do controle, você pode continuar usando o modelo de
objeto que você estiver familiarizado a partir do controle DataGrid.
• O controle DetailsView exibe um registro por vez e permite que você edite, exclua e insira
registros.
Você pode também paginar através de vários registros.
• O controle FormView é semelhante ao controle DetailsView, mas permite que você defina
um layout de forma livre para cada registro.
O controle FormView é como um controle DataList para um registro individual.
Você pode continuar usando o controle DataGrid, embora ele seja substituído pelo controle
GridView. Páginas existentes que usam o controle DataGrid trabalham como são. Como em
outros controles de dados, o controle DataGrid foi aprimorado para interagir com controles de
fonte de dados.
Vinculação bidirecional de dados
A combinação de controles de fonte de dados, parâmetros declarativos e controles de dados

avançados fornece a capacidade para criar vinculação bidirecional de dados, sem precisar
escrever código. Nos controles de fonte de dados, você pode definir consultas ou nomes de
métodos a serem usados para atualizações. Controles de dados, como o controle GridView,
DetailsView e FormView, suportam modos de edição e exclusão (e para alguns controles, modo
de inserção) que automaticamente podem interagir com os controles de fonte de dados, para
gravar dados na fonte de dados.
Armazenamento de seqüência de caracteres de conexão
Para ajudar a tornar seus sites mais manuteníveis e mais seguros, você pode manter as
seqüências de caracteres de conexão no arquivo Web.config em uma nova seção, que foi
desenvolvida especificamente para armazenamento de seqüência de caracteres de conexão.
Quando utilizar a ferramenta de desenvolvimento da Web, o Visual Web Developer, para criar ou
configurar controles de fonte de dados, você pode especificar que a seqüência de caracteres de
conexão seja armazenada no arquivo Web.config. Se você alterar as fontes de dados, você pode
facilmente alterar a seqüência de caracteres de conexão em um local, ao invés de ter que
atualizar todos os componentes de dados em todas as páginas, com uma nova seqüência de
caracteres de conexão. Para segurança adicional, você pode criptografar a seção de seqüência
de caracteres de conexão do arquivo Web.config. Para obter detalhes, consulte Criptografar
informações de configuração usando configuração protegida.
Acesso a dados em duas e três camadas
O modelo anterior de vinculação de dados incentivava a criação de soluções de dados em duas

camadas, na qual as páginas da Web interagiam diretamente com o banco de dados para
preencher o dataset e para vincular controles a ele. O novo modelo continua facilitando o trabalho
em uma estrutura em duas camadas. Por exemplo, o controle SqlDataSource se conecta

diretamente a um banco de dados e executa instruções SQL ou procedimentos para ler e gravar
dados armazenados.
O novo modelo de vinculação de dados também torna mais fácil criar uma estrutura em três
camadas na qual o acesso a dados é tratado por um objeto corporativo de camada intermediária.
O controle ObjectDataSource interage com um objeto corporativo chamando métodos no objeto
para recuperar e atualizar dados. Controles de dados em uma página podem se vincular ao
controle ObjectDataSource da mesma maneira como eles fazem a quaisquer outros controles de
fonte de dados, como o controle SqlDataSource.
A ferramenta de desenvolvimento da Web, o Visual Web Developer, inclui um assistente de

componente de dados que ajuda a criar um objeto personalizado que contém métodos para ler e
atualizar dados. Como alternativa, você pode criar seu próprio objeto de camada intermediária que
contém métodos. Enquanto seu objeto personalizado expõe os métodos com as assinaturas
apropriadas, você pode referenciá-los de um controle ObjectDataSource. Para obter detalhes,
consulte Passo-a-passo: Vinculação de Dados Para Um Objeto Corporativo Personalizado.
Compatibilidade com Versões Anteriores para Acesso a Dados
A ferramenta de desenvolvimento da Web, o Visual Web Developer, continua oferecendo suporte

a páginas que usam o modelo de vinculação de dados de versões anteriores. Páginas que contêm
datasets e outros componentes executam como faziam antes, e você pode abrir e editar as
páginas no Web Page Designer. O Visual Web Developer não remove os componentes de dados
e não converte os componentes para controles de fonte de dados.
Observação
Componentes de dados, como datasets e conexões de dados, não são mostrados no Web Page
Designer do Visual Web Developer. Portanto, você não pode definir, nem examinar as
propriedades usando a janela Properties. Entretanto, você ainda pode editar o código que é usado
para instanciar os componentes de dados e definir suas propriedades.
Para obter mais informações, consulte Visão Geral de Controles de Fonte de Dados e Passo-a-
passo: Acesso Básico a Dados em Páginas da Web.
Convertendo sites da Web existentes
O Visual Web Developer, pode converter automaticamente seus projetos existentes para o novo e
modernizado layout de site. O processo de conversão preserva a funcionalidade de seu aplicativo
e as opções de projeto que são aplicadas. Páginas da Web code-behind existentes são
convertidas em um novo modelo code-behind que preserva a separação de HTML e código, mas
fornece uma estrutura simplificada. Para mais informações, consulte Conversão do Projeto Da
Web no Visual Studio.NET.
Após a conversão, você pode usar o Web Page Designer para trabalhar com páginas e controles
que foram desenvolvidos em versões anteriores do Visual Web Developer.

Introdução a páginas da Web do ASP.NET
Páginas da Web do ASP.NET permitem que sejam criados conteúdos dinâmicos para seu site da
Web. Com uma página de HTML estático (arquivo .htm ou .html), o servidor atende uma
solicitação Web por ler o arquivo e enviá-lo como ele é para o navegador. Por outro lado, quando
alguém solicita uma página da Web do ASP.NET (arquivo.aspx), a página é executada como um
programa no servidor Web. Enquanto a página estiver sendo executada, ele pode executar
qualquer tarefa que seu site da Web requerer, inclusive calcular valores, leitura ou gravação de
informações no banco de dados, ou chamada de outros programas. Como sua saída, a página
dinamicamente produz marcação (elementos em HTML ou outra linguagem de marcação) e envia
essa saída dinâmica para o navegador.
Este tópico fornece uma visão geral sobre as características fundamentais de como páginas da
Web do ASP.NET funcionam em aplicativos da Web.
Postbacks e Round Trips
Páginas ASP.NET executam como código no servidor. Portanto, para a página ser processada, a
página é configurada para enviar para o servidor quando os usuários clicarem em botões (ou
opcionalmente, quando os usuários marcarem caixas ou interagir com outros controles da página).
Cada vez, a página é enviada de volta a si mesma para que ela possa executar seu código de
servidor novamente e depois processar uma nova versão de si própria para o usuário.
O ciclo de processamento para um página da Web do ASP.NET é:
1. O usuário solicita a página. (A página é solicitada usando um método HTTP GET). A

página executa pela primeira vez, executando processamentos preliminares se você tiver
programado-a para fazer isso.
2. A página dinamicamente processa a marcação para o navegador, que o usuário vê como
uma página da Web semelhante a qualquer outra página.
3. O usuário digita informações ou seleciona a partir das opções disponíveis e clica em um
botão. (Se os usuários clicarem em um link em vez de um botão, simplesmente a página
pode ser redirecionada para outra página, e não ocorre mais processamento na primeira
página.)
4. A página é remetida para o servidor Web. ( O navegador executa um método HTTP POST,
que no ASP.NET é conhecido como um postback). Especificamente, a página é remetida de
volta a si mesma. Por exemplo, se o usuário que estiver trabalhando com a página
Default.aspx clicar em um botão na página , a página a remete de volta para o servidor com
um destino de Default.aspx.
5. No servidor Web, a página executa novamente. As informações que o usuário digitou ou
selecionou estão disponíveis para a página.
6. A página executa o processamento que você a tiver programado para fazer.
7. A página processa ela mesma de volta para o navegador.
Esse ciclo continua, enquanto o usuário estiver trabalhando na página. Cada vez que um botão é
clicado, a informação na página é remetida para o servidor Web e a página é executada
novamente. Cada ciclo é conhecido como um round trip(processamento). Como o processamento
da página ocorre no servidor Web, cada ação que pode fazer a página requer um round trip para o
servidor.
Observação

Uma página da Web do ASP.NET pode executar scripts de cliente, o que não requer um round trip
para o servidor, e que é útil para validação de entrada de usuário e para alguns tipos de interface
de programação. Para obter mais informações, consulte Programando páginas da Web do
ASP.NET com script de cliente.
Postagem cruzada de páginas
Em algumas circunstâncias, você pode querer que uma página poste para uma página diferente,
não a si própria. Isso é chamado de da cross-page posting(postagem cruzada de página). Por
exemplo, você pode ir criando uma série de páginas que processam um pedido do cliente. Cada
página pode enviar para a próxima página na seqüência. Para obter mais informações, consulte
Postagem entre Páginas em Páginas da Web do ASP.NET.
Vida útil da página
Diferente de formulários em aplicativos desktop, uma página da Web do ASP.NET não

inicializada, executa enquanto o usuário trabalha com o formulário, e depois descarrega somente
quando o usuário clicar um botão Close (fechar). Isso ocorre porque a Web está desconectada
inerentemente. Quando um navegador solicita uma página de um servidor Web, o navegador e o
servidor estão conectados somente durante tempo suficiente para processar a solicitação. Depois
que o servidor Web tenha processado uma página para o navegador, a conexão é encerrada. Se
o navegador fizer outra solicitação para o mesmo servidor Web, mesmo para a mesma página, a
solicitação será processada como uma nova solicitação.
A natureza desconectada da Web determina a maneira que uma página ASP.NET executa.
Quando um usuário solicita uma página da Web do ASP.NET, uma nova instância da página é
criada. A página executa seu processamento, processa a marcação para o navegador, e é
descartada. Se o usuário clica em um botão para executar uma nova postagem, uma nova
instância da página é criada, a página executa seu processamento, e novamente será descartada.
Assim, cada nova postagem e round trip resulta em uma nova instância da página.
Para obter mais informações, consulte Páginas da Web ASP.NET.
Preservando o estado da página
No protocolo normal HTTP, a única informação que o servidor tem sobre uma página é a
informação que o usuário especificou usando controles na página, porque o navegador envia
somente essas informações para o servidor quando a página é postada. Outras informações, tais
como valores de variável e definições de propriedade, são descartadas. ASP.NET ajuda a
preservar outras informações de página das seguintes maneiras:
• ASP.NET salva as configurações de controle (propriedades) entre round trips, que é

chamada de salvar o estado de controle.
• O ASP.NET fornece recursos de gerenciamento de estado para que você possa salvar
suas próprias variáveis e informações específicas do aplicativo ou informações específicas de
sessão entre as round trips.
• ASP.NET pode detectar quando uma página é solicitada pela primeira vez e quando a
página é enviada, o que lhe permite programar adequadamente. Por exemplo, você talvez
queira ler informações de um banco de dados na primeira vez que uma página é exibida, mas
não em cada novo postback.
Observação

O servidor pode ser configurado para guardar informações de página para otimizar as páginas,
mas para fins de programação de aplicativos, é melhor pensar em páginas como sendo
descartadas assim que o servidor terminar seu processamento.
Para obter mais informações, consulte Visão Geral sobre o Gerenciamento de Estado do
ASP.NET.
Programando páginas da Web ASP.NET
Você pode criar o código de servidor para suas páginas da Web ASP.NET usando uma variedade
de idiomas no.NET Framework, incluindo Visual Basic, C#, e J#. As páginas da Web ASP.NET
podem conter scripts de cliente que executam dentro do navegador. Algumas funções ASP.NET
geram scripts de cliente e inserem-nos na página. Nesse caso, ASP.NET sempre gera
ECMAScript (JavaScript) para melhor funcionalidade de navegadores cruzados. Além disso, você
pode adicionar seus próprios scripts de cliente para funcionalidade personalizada. Se fizer isso,
você pode utilizar qualquer linguagem de script de cliente que seja compatível com os
navegadores que você estiver como objetivo.
Controles de servidor
Como qualquer página da Web, as páginas da Web ASP.NET podem conter texto estático. Com
mais freqüência, entretanto, você adicionará controles para a página, como caixas de texto, caixas
de seleção e botões. Esses controles permitem ao usuário interagir com a página e enviar
informações para o servidor quando a página é remetida novamente.
O ASP.NET fornece um conjunto de controles conhecido como controles do servidor Web.

Controles do servidor ASP.NET podem ser semelhante aos elementos de formulários HTML
correspondentes. Por exemplo, o controle ASP.NET TextBox é semelhante a um marcador HTML
<input type="text">. Entretanto, os controles do servidor ASP.NET oferecem uma experiência de
programação mais enriquecedora de elementos HTML. Há também controles do servidor
ASP.NET para um intervalo muito maior de funções que o que é oferecido pelos elementos HTML.
Entre os controles do servidor que podem ser usados em um página da Web do ASP.NET está
um controle de calendário, controles com dados vinculados que exibem listas ou grades, um
controle de logon para adicionar segurança a seu site, e muito mais.
Para obter mais informações, consulte Controles de servidores Web do ASP.NET.
Página e eventos de controle do servidor
Um página da Web do ASP.NET e os controles dele oferecem suporte a um modelo de evento

como os encontrados em Windows Forms. Por exemplo, quando os usuários clicar em um
controle Button em um página da Web do ASP.NET, a página é remetida de volta para o servidor,
recriada, e um evento de clique é criado. Você pode adicionar código para a página que responde
a este evento de clique.
A própria página inicia eventos de ciclos de vida quando é inicializada, como os eventos Page_Init
e Page_Load, que oferecem a oportunidade de executar o código quando a página é inicializada
(Lembre-se de que a página é criada e reinicializada em cada round trip). Controles individuais
podem iniciar seus próprios eventos. Controles de botão iniciam um evento Click, controles de
botão de rádio e caixas de seleção iniciam um método CheckedChanged, e caixa de listagem e
controles de lista drop-down iniciam um evento SelectedIndexChanged. Alguns controles, tais
como o controle Calendar, disparam eventos que são mais abstratos do que simples eventos de
clique. Por exemplo, o controle Calendar dispara um evento VisibleMonthChanged quando
usuários navegarem para um mês diferente.

A maioria dos controles servidor ASP.NET suportam somente alguns dos eventos que você pode
tratar no código servidor. Para processar um evento, a página deve executar uma round trip para
que a escolha do usuário possa ser enviada para a página para processamento. Os controles do
servidor não expõe eventos de alta freqüência como onmouseover, porque sempre que esse
evento é iniciado, outra round trip para o servidor deve ocorrer, o que iria afetar
consideravelmente o tempo de resposta na página. Entretanto, você pode configurar controles de
servidor ASP.NET para iniciar eventos do lado do cliente, como onmouseover. Nesse caso, os
controles não irão ser remetidos novamente para o servidor, e você criar um script de cliente para
responder a eventos.
Para obter mais informações sobre como criar e usar eventos e manipuladores de eventos,
consulte Tratamento de Evento de servidor em páginas da Web ASP.NET.
Compatibilidade do navegador
Como o processamento da página da Web do ASP.NET ocorre no servidor Web, páginas da Web
ASP.NET são compatíveis com qualquer navegador ou dispositivo móvel. Uma página da Web
processa automatica e corretamente a marcação (XHTML ou outra linguagem de marcação)
compatível com o navegador para recursos, como estilos e layout. Como alternativa, você pode
criar páginas da Web com controles projetados especificamente para processar a saída para
dispositivos específicos, como telefones celulares. Para obter mais informações, consulte Criando
Aplicativos da Web ASP.NET Mobile.
Documentos e dados XML

As classes XML na namespace System.Xml fornecem um conjunto abrangente e integrado de
classes, permitindo-lhe trabalhar com documentos XML e dados. As classes XML dão suporte a
leitura e escrita XML, edição de dados XML em memória, validação de dados, e transformação
XSLT.
O que há de novo no System.Xml

Os seguintes recursos System.Xml são novo in .NET Framework versão 2.0.
Novo modelo para processamento de dados XML
A versão 2.0 inclui um novo modelo para processamento de dados XML na memória. A
XPathNavigator classe foi atualizada para incluir editar recursos. Pode ser usado para modificar
dados armazenados na classe XmlDocument.
Para obter mais informações consulte Processo dados XML usando o modelo de dados XPath.
Novo processador XSLT
Tem a arquitetura XSLT foi redefinida na versão .NET Framework 2.0. A XslCompiledTransform
classe é o novo processador XSLT. A XslCompiledTransform classe inclui muitos
aprimoramentos de desempenho e otimizações que que facilitam muito mais rápida que a classe
obsoleta XslTransform.
Para obter mais informações consulte Transformações em XSLT.
Suporte a tipo

O XmlWriterXmlReader,. e XPathNavigator Classes tiver sido atualizadas para incluir suporte tipo
Novos métodos nessas classes Ativar você retornar um valor de nó como um objeto Runtime de
idioma comum.
Para obter mais informações consulte Suporte tipo nas classes System.Xml.
Novo modelo para criação XmlReader e objetos XmlWriter
Do XmlReader os métodos estáticos Create Em e XmlWriter classes são a prática recomendada

para criar XmlReader e XmlWriter objetos. Do XmlReader o Create método permite que você
para especificar o conjunto de recursos que você deseja ou XmlWriter Objeto para oferecer
suporte.
Consulte Criando leitores XML e Criando Writers XML Para obter mais informações.
Inference do esquema
A classe classe XmlSchemaInference permite-lhe inferir um esquema de idioma (XSD) de

definição esquema XML da estrutura de um documento XML.
Migrando de versão 1.1 das classes XML

O Microsoft .NET Framework versão 2.0 inclui várias atualizações para as classes XML. Em
ordem para tirar total proveito dos novos recursos, talvez precise mover o seu código existente
para as novas APIs. As seções a seguir descrevem alterações as APIs existentes que podem
exigir que você para atualizar o código existente.
Criação XmlReader
Na versão 2.0, XmlReader objetos são criados usando o método estático Create na classe
XmlReader. Um XmlReaderSettings objeto especifica os recursos que você deseja o criado
XmlReader para oferecer suporte.
Observação
Embora o .NET Framework inclui concreto implementações da classe XmlReader, como o

XmlTextReader, XmlNodeReader.. e as XmlValidatingReader classes, é recomendável que você
cria XmlReader instâncias usando o Create método, e as XmlValidatingReader classes, é
recomendável que você cria XmlReader instâncias usando o Create método, o XmlTextReader,
XmlNodeReader Isso permite que você para tirar proveito dos todos os novos recursos que
tenham sido adicionados para a XmlReader classe.
Versão 1.1
O código a seguir cria um XmlTextReader objeto que ignora espaço em branco e usa um
XmlUrlResolver objeto para resolver o nome do arquivo URI.
C#
// Supply the credentials necessary to access the Web server. XmlUrlResolver resolver = new
XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; // Create the XmlTextReader.
XmlTextReader reader = new XmlTextReader("http://serverName/data/books.xml");
reader.WhitespaceHandling = WhitespaceHandling.None; reader.XmlResolver = resolver;

Versão 2,0
O código a seguir cria um XmlReader objeto com a mesma configuração, usando o Create
método.
C#
// Supply the credentials necessary to access the Web server. XmlUrlResolver resolver = new
XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; // Create the XmlReader.
XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true;
settings.XmlResolver = resolver; XmlReader reader =
XmlReader.Create("http://serverName/data/books.xml", settings);
Para obter mais informações, consulte Criando leitores XML.
Validação XML
Do XmlValidatingReader na versão 2.0, e XmlSchemaCollection Classes tiver sido marcadas

obsoletos. Em vez disso, você deve usar a XmlReaderSettings classe para criar um objeto
validação XmlReader. A XmlSchemaCollection classe é substituída pela XmlSchemaSet classe.
Observação
O XmlReaderSettings e XmlSchemaSet Classes não oferecem suporte à validação de esquema

XML-Data Reduced (XDR). Use a XmlValidatingReader classe se você deve validar usando um
esquema XDR.
Versão 1.1
Do XmlValidatingReader o código a seguir valida dados usando e XmlSchemaCollection

Classes.
C#
XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader("books.xml"));
reader.ValidationType = ValidationType.Schema; reader.Schemas.Add("urn:books", "books.xsd");
reader.ValidationEventHandler += new ValidationEventHandler (ValidationCallBack); while
(reader.Read());
C#
private static void ValidationCallBack(object sender, ValidationEventArgs e) { Console.WriteLine("Validation
Error: {0}", e.Message); }
Versão 2,0
Do XmlReader o código a seguir valida dados usando e XmlSchemaSet Classes.
C#
XmlReaderSettings settings = new XmlReaderSettings(); settings. ValidationType = ValidationType.Schema;
settings.Schemas.Add("urn:books", "books.xsd"); settings.ValidationEventHandler += new

ValidationEventHandler (ValidationCallBack); XmlReader reader =
XmlReader.Create("books.xml",settings); while (reader.Read());
C#
private static void ValidationCallBack1(object sender, ValidationEventArgs e) {
Console.WriteLine("Validation Error: {0}", e.Message); }
Criação XmlWriter
Na versão 2.0, XmlWriter objetos são criados usando o método estático Create na classe
XmlWriter. Um XmlWriterSettings objeto especifica os recursos que você deseja o criado
XmlWriter para oferecer suporte.
Observação
Embora o .NET Framework inclui a XmlTextWriter classe, que é uma implementação da classe
XmlWriter, é recomendável que você criar XmlWriter objetos com o Create método. Isso permite
que você para tirar proveito dos todos os novos recursos adicionada à classe XmlWriter.
Versão 1.1
O código a seguir cria um XmlTextWriter objeto com uma codificação específica.
C#
XmlTextWriter writer = new XmlTextWriter("books.xml", Encoding.Unicode); writer.Formatting =
Formatting.Indented;
Versão 2,0
O código a seguir cria um XmlWriter objeto com a mesma configuração, usando o Create
método.
C#
XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.Encoding =
Encoding.Unicode; XmlWriter writer = XmlWriter.Create("books.xml", settings);
Para obter mais informações, consulte Criando Writers XML.
Processamento XSLT
A XslCompiledTransform classe é o novo processador XSLT. Ele substituirá a XslTransform

classe. A XsltSettings enumeração é usada para ativar as configurações opcionais, como o
suporte para scripts incorporados ou a função XSLT document() XSLT.
Versão 1.1
O código a seguir executa uma transformação XSLT usando a XslTransform classe.
C#

// Create the XslTransform. XslTransform xslt = new XslTransform(); // Create a resolver and set the
credentials to use. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials =
CredentialCache.DefaultCredentials; // Load the style sheet.
xslt.Load("http://serverName/data/xsl/sort.xsl", resolver); // Transform the file. XPathDocument doc =
new XPathDocument(filename); XmlTextWriter writer = new XmlTextWriter("output.xml", null);
xslt.Transform(doc, null, writer, null);
Versão 2,0
O código a seguir executa uma transformação XSLT usando a XslCompiledTransform classe.
C#
// Create the XslCompiledTransform object. XslCompiledTransform xslt = new XslCompiledTransform(); //
Create a resolver and set the credentials to use. XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials; // Load the style sheet.
xslt.Load("http://serverName/data/xsl/sort.xsl", XsltSettings.Default, resolver); // Transform the file.
XmlWriter writer = XmlWriter.Create("output.xml"); xslt.Transform("books.xml", writer);
Para obter mais informações, consulte Migrando da classe XslTransform.
Arquitetura Overview of XML no .NET Framework

Esta seção fornece uma visão geral da arquitetura de XML no .NET Framework. O metas de
design para as classes XML no .NET Framework são:
• Produtividade alta-.
• Com base em padrões.
• Suporte multilíngüe.
• Extensível.
• Arquitetura conectável.
• Concentrada no desempenho, confiabilidade e escalabilidade.
• Integração com o ADO.NET.
Para obter mais informações sobre a arquitetura conectável, consulte Objetivos de Design para
XML no .NET Framework.
O.NET Framework fornece uma oportunidade para criar um conjunto de classes XML integrado e
também mostrar inovações no mundo XML. As classes XML fornecidas são elementos principais
do .NET Framework. Essas classes fornecem uma solução aberto, compatível com padrões,
interoperável para os desafios que os desenvolvedores enfrentam hoje. Para obter mais
informações sobre o conjunto de classes no XML no .NET Framework, consulte e
System.Xml.Schema espaços de nome., System.Xml.Xsl a System.Xml, System.Xml.XPath
Segurança e seus aplicativos System.Xml

Segurança é um aspecto importante de qualquer aplicativo. O primeiro procedimento para criar
um aplicativo seguro é para compreender os tipos de questões de segurança você necessárias
para estar ciente das, e também para compreender as estratégias básicas você pode usar para
proteger seu aplicativo.

Esta seção aborda questões que são específicas para as tecnologias XML. Ele também oferece
algumas diretrizes que podem ajudar a proteger seus aplicativos.
Para obter mais informações, consulte que fornece a documentação mais recente, informações
técnicas, downloads, grupos de notícias, e outros recursos para desenvolvedores Xml. o Centro
do desenvolvedor XML,
Considerações sobre segurança System.Xml

As seções a seguir discutem os tipos de problemas de segurança que possam surgir ao trabalhar
com System.Xml componentes o que você pode fazer para atenuar essas ameaças.
Observação
Os System.Xml componentes dependem do sistema de segurança Microsoft .NET Framework.

Este tópico somente soluciona problemas de segurança especificamente que são tratados pelas
classes XML. Para obter mais informações, consulte Segurança no .NET Framework.
• XmlResolver Class
• XmlReader and XmlReaderSettings Classes
• XmlTextReader Class
• XslCompiledTransform Class
• Document Object Model
Classe XmlResolver
A XmlResolver classe é usada para resolver recursos. É usado para carregar documentos XML, e
para resolver externos recursos, como entidades, DTDs ou esquemas, e importar ou incluir
diretivas. O.NET Framework inclui duas implementações da classe XmlResolver.
A XmlUrlResolver classe é o resolvedor padrão para todas as classes no espaço para nome
System.Xml. Do file:// oferece suporte e http:// Protocolos e solicitações a partir da WebRequest
classe. Em muitos casos, se você não especificar um XmlResolver objeto que seu aplicativo deve
usar, um XmlUrlResolver objeto COM sem credenciais de usuário é usado para acessar recursos
XML.
A XmlSecureResolver classe ajuda a proteger outro XmlResolver objeto, disposição o

XmlResolver objeto e restringindo os recursos que base XmlResolver tem acesso ao. Por
exemplo, a XmlSecureResolver classe pode proibir acesso a determinado sites ou zonas.
Você deve considerar os seguintes itens ao trabalhar com a XmlResolver classe.
• Objetos XmlResolver podem conter informações sigilosas such as credenciais de usuário

que podem ser usadas para acessar e recuperar dados. Do XmlResolver você deve ter
cuidado ao cache XmlResolver objetos e não deve passar o XmlResolver objeto para um
componente não confiável porque o componente não confiável pode usar e suas credenciais
de usuário para acessar dados.
• Se você estiver criando uma propriedade de classe que usa a XmlResolver classe, a
propriedade deve ser definida como uma propriedade somente para gravação. A propriedade
pode ser usada para especificar mas ela não pode ser usada para retornar um XmlResolver
objeto. a ser usado, o XmlResolver Isso permite um uso componente não confiáveis a classe,
mas não permite-lo para recuperar e use o XmlResolver objeto diretamente.

• Se o aplicativo aceita XmlResolver objetos do código não confiável, você não pode
presumir que o URI passado para o GetEntity método é a mesma que retornado pelo método
ResolveUri. Classes derivadas da classe XmlResolver podem substituir o GetEntity método e
retornar dados que são diferentes das que estivesse contido no URI original.
• O aplicativo pode atenuar Negação de memória das ameaças do serviço para o GetEntity
método implementando uma disposição implementada IStream que limita o número de bytes
lidos. Isso ajuda a proteção contra situações onde código mal-intencionado tenta se passar um
fluxo de bytes infinito para o GetEntity método.
XmlReader e classes XmlReaderSettings
Praticamente todos os System.Xml componentes são criados acima do conceito de Análise XML.
Por exemplo, a XmlDocument classe usa a XmlReader classe para analisar um documento e criar
uma representação na memória do documento XML.
É recomendável usar o Create método para criar XmlReader objetos. A XmlReaderSettings

classe especifica o conjunto de recursos você deseja ativar para o XmlReader objeto.
Processamento DTD
Processamento DTD pode levar a uma condição de negação de serviço. Por exemplo, o DTD
pode conter entidades aninhadas ou complexos Modelos de conteúdo que podem tirar uma
quantidade excessiva de tempo para processar.
Processamento DTD é desativado por padrão. Um XmlException encontrar os XmlReader dados

DTD é acionada quando.
Processamento de esquema
O ProcessInlineSchema e ProcessSchemaLocation Sinalizadores de validação de um

XmlReaderSettings objeto não são definidas por padrão. Do XmlReader Isso ajuda a proteger
contra ataques baseada em esquema quando ele está processando dados XML de uma origem
não confiável. Quando esses sinalizadores são definidas, o XmlResolver. do objeto
XmlReaderSettings é usado para resolver locais do esquema encontrados no documento de
ocorrência na XmlReader Locais de esquema não serão resolvidos se a XmlResolver
propriedade estiver definida como null, mesmo que. e ProcessSchemaLocation Sinalizadores
de validação estão definidas o ProcessInlineSchema
Esquemas adicionadas durante a validação adicionar novos tipos e pode alterar o resultado de
validação do documento que está sendo validado. Como resultado, esquemas externas somente
devem ser resolvidas de fontes confiáveis.
Microsoft recomenda desativar o ProcessIdentityConstraints Sinalizador (ativado por padrão)

quando XML validando, não confiáveis, grande documentos em cenários alta disponibilidade em
um esquema com restrições de identidade sobre uma grande parte do documento.
Recursos externos
Dados XML podem incluir referências a recursos externos, como um arquivo de esquema. Por
padrão recursos externos são resolvidos usando um XmlUrlResolver objeto COM sem
credenciais de usuário. Isso significa que, por padrão, você pode acessar qualquer locais que não
exigem credenciais. Você pode proteger isso mais seguindo um destes procedimentos:
• Restringir os recursos que. pode acessar, definindo a

System.Xml.XmlReaderSettings.XmlResolver propriedade a um XmlSecureResolver objeto
a XmlReader

• Não permitir para abrir qualquer recursos externos, definindo a
System.Xml.XmlReaderSettings.XmlResolver propriedade a null. o XmlReader
Compartilhar objetos XmlReaderSettings
Objetos XmlReaderSettings podem conter informações sigilosas such as credenciais de usuário.

Um componente não confiável pode usar o XmlReaderSettings objeto e suas credenciais de
usuário para criar XmlReader objetos para ler dados. Você deve ser cuidado quando cache
XmlReaderSettings Objetos, ou quando passando o XmlReaderSettings objeto de um
componente para outro.
Suporte componentes
• Não aceitar suporte componentes, como NameTable, XmlNamespaceManager,. e
XmlResolver Objetos, de uma fonte não confiável
Processamento de dados
Dados XML podem conter um número de atributos, declarações de espaço para nome, elementos
aninhados grande e assim por diante que exigem uma quantidade considerável de tempo para
processar.
• Você pode criar uma implementação personalizada IStream que limita o tamanho de
entrada usado e fornecer isso para a XmlReader classe.
• Use o ReadValueChunk método para lidar com grandes fluxos de dados. Esse método lê
um pequeno número de caracteres de cada vez em vez de alocar uma única seqüência para o
valor inteiro.
Classe XmlTextReader
A XmlTextReader classe é uma implementação da classe XmlReader legada.
Processamento DTD
Processamento DTD é ativado por padrão. Para desativar processamento DTD, defina a
ProhibitDtd propriedade como true.
Tratamento de entidade
Por padrão entidades gerais não são expandidas. Entidades gerais são expandidas quando você
chamar o ResolveEntity método.
Recursos externos
Dados XML podem incluir referências a recursos externos, como referências DTD. Por padrão
recursos externos são resolvidos usando um XmlUrlResolver objeto COM sem credenciais de
usuário.
Você pode proteger isso mais seguindo um destes procedimentos:
• Restringir os recursos que. pode acessar, definindo a XmlResolver propriedade a um

XmlSecureResolver objeto a XmlTextReader
• Não permitir para abrir qualquer recursos externos, definindo a XmlResolver propriedade
a null. o XmlTextReader
Classe XslCompiledTransform

A XslCompiledTransform classe é um processador XSLT processador XSLT que oferece suporte
à sintaxe XSLT 1.0. Ele permite que você para dados XML usando um folha de estilo XSLT
transformações.
Recursos externos
Folhas de estilos podem incluir referências a recursos externos, como xsl:import ou xsl:include
elementos ou a document() função.
Do xsl:import o XslCompiledTransform oferece suporte de classe ou xsl:include elementos por

padrão. A XslCompiledTransform classe desabilita o suporte para a document() função por
padrão. A XsltSettings classe é usada para ativar a document() função.
O Load e Transform métodos incluir overloads que se um XmlResolver objeto como um dos seus
argumentos. Se não for especificado, um padrão XmlUrlResolver com nenhum credenciais é
usado. um XmlResolver
Você pode controlar recursos como externos são acessados, siga um destes procedimentos:
• Restringir os recursos que o processo XSLT pode acessar, usando um

XmlSecureResolver objeto.
• Não permitir que o processo XSLT aberto qualquer recursos externos passando em null
Para o XmlResolver argumento.
Blocos de script
A XslCompiledTransform classe não oferece suporte blocos de script por padrão. Blocos de
script são ativados através da XsltSettings classe. XSLT script deve ser ativada somente se você
exigem suporte script e você estiver trabalhando em um ambiente totalmente confiável.
Objetos de extensão
Objetos extensão adicionam recursos de programação ao transformações XSLT. Esse recurso é

ativado por padrão. Se Objetos de extensão for passados para o Transform método, elas são
usadas na transformação XSLT.
Modelo de Objeto de Documento
Porque o DOM (modelo de objeto Document) caches todos os dados da memória, operações
DOM, como Consultar, Editar, mover sub-Trees entre documentos, e salvar objetos DOM não são
recomendadas se você estiver trabalhando com dados não confiáveis e estiver preocupado com a
ataques de negação de serviço. Outra opção é para definir um limite para a quantidade de dados
para ler em DOM. Uma maneira para fazer isso é para criar uma implementação personalizada de
fluxo que limita o tamanho de entrada usado e Use isso para carregar o objeto DOM.
Objetos XmlDocument podem conter informações sigilosas such as credenciais de usuário no

objeto incorporado XmlResolver. Se a System.Xml.XmlDocument.XmlResolver propriedade
estiver definida como um XmlResolver objeto com credenciais de usuário, não cache o
XmlDocument objeto ou transmiti-las a um componente não confiável. Um componente não
confiável pode usar o objeto DOM, e as credenciais do usuário incorporado XmlResolver, para
acessar e carregar dados.

System.Xml codificação diretrizes
As seções a seguir fornecem diretrizes gerais podem ser usadas para ajudar a proteger seus
System.Xml aplicativos.
Observação
Os System.Xml componentes dependem do sistema de segurança Microsoft .NET Framework.

Este tópico somente soluciona problemas de segurança especificamente que são tratados pelas
classes XML. Para obter mais informações, consulte Segurança no .NET Framework.
Questões de segurança
As questões de segurança podem ser divididas fora em três categorias gerais.
Acesso externo
Várias tecnologias XML têm a capacidade para recuperar outros documentos durante o
processamento. Por exemplo, uma definição de tipo de documento (DTD) pode residir no
documento sendo analisada. O DTD também pode morar em um documento externo que é
referenciado pelo documento sendo analisada. O idioma de definição esquema XML (XSD) e
tecnologias XSLT também têm a capacidade para incluir informações de outros arquivos. Esses
recursos externos podem apresentar algumas questões de segurança:
• Faça como você garantir que seu aplicativo somente recupera arquivos de sites
confiáveis? Por exemplo, se um documento XML tiver uma referência de arquivo a um arquivo
a partir da Internet, você deseja seu aplicativo para recuperar este arquivo?
• Fazer se você recuperar um arquivo, como você garantir esse arquivo não contém dados
mal intencionados?
Negação de Serviço
Porque documentos XML podem incluir referências a outros arquivos, é difícil para determinar a
quantidade de capacidade de processamento é necessário para analisar um documento XML. Por
exemplo, documentos XML podem incluir um DTD. Se o DTD contém entidades aninhadas ou
complexos Modelos de conteúdo, ele poderá ter uma quantidade excessiva de tempo para
analisar o documento.
Os seguintes cenários são considerados para ser menos vulnerável a ataques de negação de
serviço porque as System.Xml classes fornecem um meio de proteção contra esses ataques.
Para saber sobre os tipos de questões de segurança que possam surgir ao trabalhar com
System.Xml componentes e o que você pode fazer para atenuar essas ameaças, consulte
Considerações sobre segurança System.Xml.
• Analisar texto dados XML.

• Análise binários dados XML se os dados XML binários foi gerados pelo Microsoft SQL
Server 2005.
• Gravação documentos XML e fragmentos do fontes de dados para o sistema de arquivos,
transmite, uma TextWriter, ou uma StringBuilder.
• Carregando documentos para o objeto documento DOM) se você estiver usando um
XmlReader objeto e ProhibitDtd definido como true.
• Navegando o objeto DOM.

Os cenários a seguir não são recomendados se estiver preocupado com a ataques, negação de
serviço ou se você estiver trabalhando em um ambiente não confiável.
• Processamento DTD.
• Processamento de esquema. Isso inclui adicionar um esquema não confiável à coleção de
esquemas, compilar um esquema não confiável e validação usando o esquema não confiável.
• Processamento XSLT.
• Analisar qualquer fluxo arbitrário do usuário fornecidas binários dados XML.
• Operações DOM, como consultar, editando, movendo sub-Trees entre documentos, e
salvar objetos DOM.
Processamento
As tecnologias XSD e XSLT possuem recursos adicionais que podem afetar o desempenho de
processamento. Por exemplo, ele é possível para construir um esquema XML que requer uma
quantidade considerável de tempo para processar quando avaliada em um documento
relativamente pequeno. Também é possível para incorporar blocos de script em um folha de estilo
XSLT. Ambos os casos representar uma ameaça de segurança potencial ao seu aplicativo.
Recursos externos
System.Xml. É usado para carregar documentos XML, e para resolver externos recursos, como
entidades, DTDs ou esquemas, e importar ou incluir diretivas.
As APIs permite que sejam substituí-lo, especificando o XmlResolver objeto para utilizar. Use a
XmlSecureResolver classe caso você precise abrir um recurso que você não faça controle, ou que
não é confiável. A XmlSecureResolver disposição e permite que você para restringir os recursos
que base XmlResolver tem acesso ao. um XmlResolver
Processamento DTD
Não ative processamento DTD se você estiver preocupado com a problemas dos ou se você está
lidando com fontes não confiáveis. Processamento DTD é desativado por padrão em XmlReader
Objetos criado pelo método Create.
Observação
O XmlTextReader permite DTD processamento por padrão. Use a

System.Xml.XmlTextReader.ProhibitDtd propriedade para desativar este recurso.
Se você tiver processamento DTD ativado, você poderá usar pode acessar. Para restringir os
recursos que o XmlSecureResolver o XmlReader Você também pode criar seu aplicativo para
que o processamento XML é a memória e tempo restrita. Por exemplo, configurar limites de tempo
limite em seu aplicativo ASP.NET.
Processamento XSLT
Ao criar um aplicativo que usa a XslCompiledTransform classe, você deve estar ciente dos itens
as seguir e suas implicações:

• Script XSLT é desativado por padrão. XSLT script deve ser ativada somente se você
exigem suporte script e você estiver trabalhando em um ambiente totalmente confiável.
• A função XSLT document() é desativada por padrão. Se você ativar a document() função,
restringir os recursos que podem ser acessados, passando um XmlSecureResolver objeto
para o Transform método
• Objetos extensão são ativados por padrão. Se um XsltArgumentList objeto contendo
objetos de extensão é passado para o Transform método, eles são utilizados.
• Folhas de estilos XSLT podem incluir referências a outros arquivos e blocos de script
incorporado. Um usuário mal-intencionado pode explorar isso, fornecendo você com dados ou
estilo folhas que quando executado pode causar o sistema para processar até que o
computador executará baixa em Recursos.
• Aplicativos XSLT que executados em um ambiente misto confiança podem resultar em
folhas de estilo spoofing. Por exemplo, um usuário mal-intencionado pode carregar um objeto
com um folhas de estilo prejudicial e entregá-lo para outro usuário que subseqüentemente
chama o Transform método e executa a transformação.
Esses problemas de segurança podem ser atenuados com não ativar scripts ou a document()
Função. a menos que o folhas de estilo provém de uma fonte confiável, e por não aceitar
XslCompiledTransform Objetos, folhas de estilos XSLT ou XML fonte de dados de uma fonte
não confiável
Tratamento de exceção
Exceções geradas por componentes de nível inferiores podem divulgar informações de caminho
que você não deseja bubbled backup para o aplicativo. Os aplicativos devem Capturar exceções e
processá-los adequadamente.
Uso XmlTextWriter
Do XmlTextWriter quando você passar para outro aplicativo o fluxo subjacente é exposto a esse
aplicativo. Se precisar de passar para um aplicativo semiconfiável, você deve usar um XmlWriter
objeto criado através do Create método em vez disso. o XmlTextWriter
Dados XML processo In-Memory

O Microsoft .NET Framework inclui dois modelos para processar dados XML.
A XmlDocument classe implementa o núcleo Nível 1 documento DOM) do W3C e as

recomendações 2 Nível DOM principal. O DOM é um na memória (cache) árvore representação
de um documento XML. COM e suas classes relacionados, você pode construir documentos XML,
carregar e acessar dados, modificar dados, e salvar alterações. o XmlDocument,
A XPathDocument classe é armazenamento de dados na memória somente leitura, que é

baseado no modelo de dados XPath. A XPathNavigator classe oferece várias opções de edição e
recursos de navegação usando um modelo cursor sobre documentos XML contidos na leitura-
somente XPathDocument Classe, bem como a XmlDocument classe.
Processo dados XML usando o modelo DOM

XML documento o DOM) trata dados XML como um conjunto padrão de objetos e é usado para
processar dados XML na memória. O System.Xml espaço para nome fornece uma representação
programática de XML documentos, fragmentos, nós, ou nó-define. Se baseia o núcleo Nível 1
DOM W3C (World Wide Web Consortium) (W3C) e as recomendações Nível DOM principal 2.

A XmlDocument classe representa um documento XML. Ele inclui membros para recuperar e criar
todos os outros objetos XML. Usando e suas classes relacionados, você pode construir
documentos XML, carregar e acessar dados, modificar dados, e salvar alterações. o
XmlDocument,
Nesta seção
Ler um documento XML para o DOM.
Discute como ler dados XML em um documento XML.
Inserir nós em um documento XML
Discute como inserir nós em um documento XML.
Remover nós, conteúdo, e valores de um documento XML
Explica como remover nós, incluindo valores de nó.
Modificar nós, conteúdo, e valores em um documento XML
Discute como modificar o conteúdo de nó.
Resolvendo recursos externos
Discute usando a XmlResolver classe para Resolver e acessar recursos externos.
Estendendo o DOM
Discute como estender as classes DOM para fornecer funcionalidade adicional.
Processo dados XML usando o modelo de dados XPath
Discute processamento XML usando a XPathNavigator classe.
Processo dados XML usando o modelo de dados XPath

Do XmlDocument espaço para nome System.Xml fornece uma representação programática da
XML documentos, fragmentos, nós, ou Define nós na memória, Usando. ou XPathDocument
Classes
A XPathDocument classe fornece uma representação de um documento XML usando o modelo

de dados XPath rápida, somente leitura, na memória. A XmlDocument classe fornece uma
representação na memória editável de um documento XML implementação documento DOM) do
W3C principal nível 1 e 2 Nível DOM principal. Ambas as classes implementam a IXPathNavigable
interface e retornar um XPathNavigator objeto usado para selecionar, Avaliar, navegar, e em
alguns casos, editar os dados XML subjacentes.
As seções a seguir descrevem a funcionalidade da XPathNavigator classe com base na classe

que devolve.
Nesta seção
Lendo dados XML usando XPathDocument e XmlDocument

Descreve como criar uma leitura-somente XPathDocument Classe objeto para ler um
documento XML e como criar um objeto de classe editável XmlDocument para ler e editar
um documento XML. Este tópico também descreve como retorno um XPathNavigator
objeto de cada classe para navegar e editar um documento XML.
Selecionar, Evaluating e correspondência dados XML usando XPathNavigator
Descreve os métodos da classe XPathNavigator utilizada para selecionar nós no ou

XmlDocument Objeto utilizando uma consulta XPath, avaliar e examine os resultados de
uma expressão XPath, e determinar se um nó em um documento XML coincide com uma
expressão XPath especificada. um XPathDocument
Acessando dados XML usando XPathNavigator
Descreve os métodos da classe XPathNavigator usada para navegar nós, extrair dados
XML e acessar altamente digitados dados XML no ou XmlDocument Objeto. um
XPathDocument
Editando dados XML usando XPathNavigator
Descreve os métodos da XPathNavigator classe usada para inserir, modificar e remover

nós e valores de um documento XML contido em um XmlDocument objeto.
Validação de esquema usando XPathNavigator
Descreve as maneiras para validar o conteúdo XML contido no ou XmlDocument Objeto.

um XPathDocument
Lendo XML com o XmlReader

A XmlReader classe é uma classe base abstrata que fornece não-armazenados em cache,
somente de encaminhamento, acesso a dados XML somente leitura. Está de acordo para o W3C
(XML) 1.0 e o Namespaces em recomendações XML.
A XmlReader classe oferece suporte ler dados XML de um fluxo ou arquivo. Ele define métodos e
propriedades que permitem a você para percorrer os dados e ler o conteúdo de um nó. O nó atual
se refere o nó em que o leitor está posicionado. O leitor é avançado usando qualquer um dos
métodos de leitura e propriedades retornar o valor do nó atual.
A XmlReader classe permite que você para:
• Verifique se os caracteres são legais caracteres XML, e desse elemento e nomes de

atributos são nomes XML válidos.
• Verifique o documento XML que está formado.
• Validar os dados contra um DTD ou esquema.
• Recuperar dados do fluxo XML ou ignorar indesejados registros usando um modelo de
recebimento.
Nesta seção
Novos recursos na classe XmlReader
Descreve alterações para a XmlReader classe.
Tarefas comuns XmlReader

Descreve as tarefas mais comuns XmlReader.
Usando a classe XmlReader
Descreve como criar XmlReader instâncias, validação de dados, dados de leitura, e assim
por diante.
Comparando XmlReader para leitor SAX
Descreve as diferenças entre a XmlReader classe e o leitor SAX.
Escrevendo XML com o XmlWriter

A XmlWriter classe é uma classe base abstrata que fornece uma forma de gerar fluxos XML
somente de encaminhamento, somente para gravação, armazenado em cache não-. Pode ser
usado para criar documentos XML que estão em conformidade para o W3C (XML) 1.0 (Second
Edition) (www.w3.org/TR/2000/REC-XML-20001006.html) Recomendação e o Namespaces na
recomendação XML (www.w3.org/TR/REC-XML-Names/).
O XmlWriter permite que você se:
• Verifique se os caracteres são legais caracteres XML e desse elemento e nomes de

atributos são nomes XML válidos.
• Verifique se o documento XML é válido.
• Codificar bytes binários como BASE64, ou BinHex, e gravação sem o texto resultante.
• Passar os valores usando tipos Runtime de idioma comuns em vez de seqüências. Isso
permite evitar a Executar conversões valor manualmente.
• Gravar vários documentos em um fluxo de saída.
• Gravar nomes válidos, nomes qualificados e símbolos nome.
Novos recursos na classe XmlWriter

O Microsoft .NET Framework versão 2.0 inclui muitas alterações Design e funcionalidade para a
XmlWriter classe.
Criação XmlWriter
O Create método é o mecanismo preferido para obter XmlWriter objetos. O Create método usa a
XmlWriterSettings classe para especificar quais recursos deve oferecer suporte a XmlWriter
instância.
Para obter mais informações, consulte Criando Writers XML.
Conformance de dados
Objetos XmlWriter criados através do Create método são, por padrão, mais conformant que a
XmlTextWriter implementação. Usando o Create método e a XmlWriterSettings classe oferece
dois outros recursos verificação conformance-.

Verificação de caracteres
Do XmlWriter a System.Xml.XmlWriterSettings.CheckCharacters propriedade configura para

verificar caracteres no fluxo de dados XML para garantir que todos os caracteres sejam dentro do
intervalo de caracteres XML válidos. Caractere verificação inclui, verificando se há caracteres
inválidos em nós de texto e nomes XML, assim como verificação validade de nomes XML não (por
exemplo, um nome xml pode começar com um numérica). Se os dados XML não não vir dentro do
intervalo de caracteres XML legais, é acionada. um XmlException
Verificando a conformidade
Do XmlWriter a System.Xml.XmlWriterSettings.ConformanceLevel propriedade configura para

verificar e garantir que o fluxo sendo lidos compatível com um determinado conjunto de regras.
Dependendo do nível conformidade que for especificado, os dados XML podem ser verificados
para ver que está de acordo com as regras para um documento XML 1.0 válido ou fragmento de
documento. Se os dados não estiver em conformidade, é acionada. um XmlException
Para obter mais informações, consulte Conformance de dados e o XmlWriter.
Suporte a tipo
A XmlWriter classe permite-lhe gravar valores como tipo simples-comuns valores Runtime (CLR)
de idioma.
Você pode usar o WriteValue método para passar valores usando tipos sistema em vez de
seqüências. Dessa forma, você pode gravar valores diretamente sem que seja necessário
executar conversões valor manualmente.
Usando o XmlWriter
A XmlWriter classe grava dados XML em um fluxo, arquivo, TextReader,. ou seqüência
A XmlWriter classe grava dados XML em um fluxo, arquivo, TextReader,. ou seqüência Ele
fornece um meio de criação válidos dados XML de uma maneira somente de encaminhamento,
somente para gravação, armazenado em cache não-. Dá a XmlWriter classe suporte o W3C XML
1.0 e Namespaces em recomendações XML. Esta seção discute como criar uma XmlWriter
instância com um conjunto especificado de recursos, conformidade de dados verificação, gravar
dados digitados, e assim por diante.
Nesta seção
Criando Writers XML
Explica como criar gravadores usando o System.Xml.XmlWriter.Create método.
Conformance de dados e o XmlWriter
Descreve verificações conformidade de dados que podem ser definidas na classe

XmlWriter.
Namespace tratamento no XmlWriter
Discute os recursos espaço para nome na classe XmlWriter.
Dados digitados escrita

Discute como gravar dados digitados.
Gravar atributos
Descreve os métodos disponíveis para gravar atributos.
Elementos de escrita
Descreve os métodos disponíveis para gravar elementos.
Gravar XML usando o XmlTextWriter
Discute como usar a XmlTextWriter classe.
Observação
No Microsoft .NET Framework versão 2.0, é recomendável criar XmlWriter objetos usando o
Create método.
Transformações em XSLT
A transformação XSL Transformation (XSLT) permite que você transformar o conteúdo de um
documento XML de origem em outro documento que seja diferente em formato ou estrutura. Por
exemplo, você pode usar XSLT para transformar XML em HTML para uso em um site da Web ou
para transformá-lo em um documento que contenha apenas os campos necessários para um
aplicativo. Esse processo de transformação é especificado pela recomendação W3C
Transformações em XSL (XSLT) versão 1.0 localizada em www.w3.org/TR/XSLT.
A XslCompiledTransform classe é o processador XSLT no .NET Framework. A

XslCompiledTransform classe oferece suporte a recomendação W3C 1.0 XSLT.
Observação
A XslTransform classe é obsoleto no .NET Framework versão 2.0. A XslCompiledTransform

classe é uma nova implementação do mecanismo XSLT. Ele inclui aprimoramentos de
desempenho e novos recursos de segurança. A prática recomendada é para criar aplicativos
XSLT usando a XslCompiledTransform classe.
Usando a classe XslCompiledTransform

A XslCompiledTransform classe é o processador XSLT do Microsoft .NET Framework. Essa
classe é usada para compilar folhas de estilos e executar transformações XSLT.
Nesta seção
Entradas para a classe XslCompiledTransform
Descreve as opções de entrada XSLT disponíveis.
Opções de saída na classe XslCompiledTransform

Descreve as Opções de saída XSLT disponíveis.
Resolvendo recursos externos durante processamento XSLT
Discute usando a XmlResolver classe para resolver recursos externos.
Estendendo folhas de estilos XSLT
Discute como há suporte para extensões XSLT.
Migrando da classe XslTransform

Tem a arquitetura XSLT foi redefinida na versão 2.0 Framework Microsoft .NET. A XslTransform
classe foi substituída pela classe XslCompiledTransform.
Desempenho
A XslCompiledTransform classe inclui muitos aprimoramentos de desempenho. O novo

processador XSLT compila o folha de estilo XSLT Down to um formato intermediário comum,
semelhante à que o Common Language Runtime (CLR) faz para outras linguagens de
programação. Depois que o folhas de estilo é compilado, ele pode ser armazenadas em cache e
reutilizados.
A XslCompiledTransform classe também inclui outras otimizações que tornam muito mais rápida
que a XslTransform classe.
Segurança
A XslCompiledTransform classe desativa suporte para a função XSLT document() e script

incorporado por padrão. Esses recursos podem ser ativados, criando um XsltSettings objeto com
os recursos habilitados e passando-para o Load método.
Para obter mais informações, consulte Considerações sobre segurança XSLT.
Migrando código
As novas classes XSLT tenham sido designadas para ser muito semelhante às classes existentes.
A XslCompiledTransform classe substitui a XslTransform classe. Folhas de estilo são
compiladas usando o Load método. Transformações são executadas usando o Transform
método. Os procedimentos a seguir mostrar tarefas comuns, XSLT e compare o código usando a
XslTransform classe versus a XslCompiledTransform classe.
Para transformar um arquivo e saída para um URI
Código usando a XslTransform C#

classe. XslTransform xslt = new XslTransform(); xslt.Load("output.xsl");
xslt.Transform("books.xml", "books.html");
Código usando a C#
XslCompiledTransform classe. XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("output.xsl"); xslt.Transform("books.xml", "books.html");
Para compilar um folhas de estilo e usar um resolvedor com credenciais padrão

Código usando a C#
XslTransform classe. XslTransform xslt = new XslTransform(); XmlUrlResolver resolver = new
XmlUrlResolver(); resolver.Credentials =
CredentialCache.DefaultCredentials; xslt.Load("sort.xsl", resolver);
Código usando a C#
XslCompiledTransform XslCompiledTransform xslt = new XslCompiledTransform();
classe. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials =
CredentialCache.DefaultCredentials; xslt.Load("sort.xsl",
XsltSettings.Default, resolver);
Para usar um parâmetro XSLT
Código usando a C#
XslTransform classe. XslTransform xslt = new XslTransform(); xslt.Load("order.xsl"); //Create
the XsltArgumentList. XsltArgumentList argList = new XsltArgumentList();
//Create a parameter which represents the current date and time. DateTime
d = DateTime.Now; argList.AddParam("date", "", d.ToString()); //Create
the XmlTextWriter. XmlTextWriter writer = new
XmlTextWriter("output.xml", null); //Transform the file.
xslt.Transform(new XPathDocument(filename), argList, writer, null);
Código usando a C#
XslCompiledTransform XslCompiledTransform xslt = new XslCompiledTransform();
classe. xslt.Load("order.xsl"); // Create the XsltArgumentList. XsltArgumentList
argList = new XsltArgumentList(); // Create a parameter which represents
the current date and time. DateTime d = DateTime.Now;
argList.AddParam("date", "", d.ToString()); // Create the XmlWriter.
XmlWriter writer = XmlWriter.Create("output.xml", null); // Transform the
file. xslt.Transform(new XPathDocument(filename), argList, writer);
Para ativar scripts XSLT
Código usando a C#
XslTransform classe. XslTransform xslt = new XslTransform(); xslt.Load("output.xsl");
Código usando a C#
XslCompiledTransform // Create the XsltSettings object with script enabled. XsltSettings settings
classe. = new XsltSettings(false,true); // Execute the transform.
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("calc.xsl", settings, new XmlUrlResolver());
Para carregar os resultados em um objeto DOM
Observação
A XslCompiledTransform classe não tem um método que retorna os resultados de

transformação XSLT como um XmlReader objeto. No entanto, você pode saída para um arquivo

XML e carregar o arquivo XML para outro objeto.
Código usando a C#
XslTransform classe. // Execute the transformation. XslTransform xslt = new XslTransform();
xslt.Load("output.xsl"); XmlReader reader = xslt.Transform(new
XPathDocument("books.xml"), null, new XmlUrlResolver()); // Load the
results into a DOM object. XmlDocument doc = new XmlDocument();
doc.Load(reader);
Código usando a C#
XslCompiledTransform // Execute the transformation. XslCompiledTransform xslt = new
classe. XslCompiledTransform(); xslt.Load("output.xsl");
xslt.Transform("books.xml", "output.xml"); // Load the results into a DOM
object. XmlDocument doc = new XmlDocument();
doc.Load("output.xml");
Para transmitir os resultados em outro armazenamento de dados
Código usando a C#
XslTransform classe. // Execute the transformation. XslTransform xslt = new XslTransform();
xslt.Load("output.xsl"); XmlReader reader = xslt.Transform(new
XPathDocument("books.xml"), null, new XmlUrlResolver()); // Load the
results into an XPathDocument object. XPathDocument doc = new
XPathDocument(reader);
Código usando a C#
XslCompiledTransform // Execute the transformation. XslCompiledTransform xslt = new
classe. XslCompiledTransform(); xslt.Load("output.xsl"); MemoryStream ms =
new MemoryStream(); xslt.Transform(new XPathDocument("books.xml"),
null, ms); // Load the results into an XPathDocument object. ms.Seek(0,
SeekOrigin.Begin); XPathDocument doc = new XPathDocument(ms);
Considerações sobre segurança XSLT

O idioma XSLT tem um rico conjunto de recursos que lhe um grande aumento da capacidade e
flexibilidade. Ele inclui diversos recursos que, enquanto útil, também pode ser explorados por
fontes externas. Para usar XSLT com segurança, você deve entender os tipos de problemas de
segurança que surgirem ao usar XSLT, e as estratégias básicas que você pode empregar para
atenuar esses riscos.
Extensões XSLT
Dois populares extensões XSLT são folhas de estilo objetos scripts e extensão. Essas extensões
permitem que o processador XSLT para executar código.
• Objetos extensão adicionam recursos de programação ao Transformações em XSL.

• Scripts podem ser incorporadas ao folhas de estilo usando o msxsl:script elemento de
extensão.
Objetos de extensão
Objetos extensão são adicionados usando o AddExtensionObject método. O conjunto de

permissões FullTrust é necessário para suporte a objetos de extensão. Isso garante que elevação
de permissões não acontecer quando código objeto de extensão é executado. Tentativa de
chamar o AddExtensionObject método sem resultados permissões FullTrust em uma exceção de
segurança sendo geradas.
Scripts da folha de estilos
Scripts podem ser incorporadas a uma folhas de estilo usando o msxsl:script elemento de
extensão. Suporte script é um recurso opcional na classe XslCompiledTransform que é desativada
por padrão. Script pode ser habilitada ao definir a System.Xml.Xsl.XsltSettings.EnableScript
propriedade como true e passar o XsltSettings objeto para o Load método.
Diretrizes
Ativar scripting somente quando o folhas de estilo provém de uma fonte confiável. Se você não
pode verificar a origem do folhas de estilo, ou se o folhas de estilo não não vêm de uma fonte
confiável, passar em null para o argumento configurações XSLT.
Recursos externos
O idioma XSLT tem recursos, como xsl:import, xsl:include,. ou a document() função, onde o
processador necessita para resolver referências URI A XmlResolver classe é usada para resolver
recursos externos. Recursos externos talvez precise ser resolvido nos dois casos a seguir:
• Durante a compilação um folhas de estilo, e xsl:include Resolução. é usado para xsl:import

o XmlResolver
• Do XmlResolver ao executar a transformação, é usado para resolver a document() função.
Observação
A document() função é desativada por padrão na classe XslCompiledTransform. Esse recurso

pode ser ativado ao definir a System.Xml.Xsl.XsltSettings.EnableDocumentFunction propriedade
como true e passar o XsltSettings objeto para o Load método.
A Load um dos seus argumentos. e Transform Cada incluir overloads que aceitam uma
XmlResolver como métodos Se não for especificado, um padrão XmlUrlResolver com nenhum
credenciais é usado. um XmlResolver
Diretrizes
Ativar a document() função somente quando o folhas de estilo provêm de uma fonte confiável.
A lista a seguir descreve quando se desejar especificar um XmlResolver objeto:
• Se o processo XSLT precisa acessar um recurso de rede que exija autenticação, você
pode usar com as credenciais necessárias. um XmlResolver
• Se você quiser restringir os recursos que o processo XSLT pode acessar, você poderá
usar com a permissão correta Definir. um XmlSecureResolver Use a XmlSecureResolver
classe caso você precise abrir um recurso que você não faça controle, ou que não é confiável.
• Se você desejar personalizar comportamento, você pode implementar sua próprias
XmlResolver Classe e usá-lo para resolver recursos.
• Se você desejar garantir que nenhum recursos externos são acessados, você pode
especificar null para o XmlResolver argumento.

Consulte também
Transformações em XSLT com a classe XslTransform

Observação
A XslTransform classe é obsoleta no Microsoft .NET Framework versão 2.0. Você pode executar
Extensible Stylesheet Language para transformações transformações (XSLT) usando a
XslCompiledTransform classe. Consulte Usando a classe XslCompiledTransform e Migrando da
classe XslTransform Para obter mais informações.
O objetivo da XSLT é para transformar o conteúdo de um documento XML de origem em outro

documento que seja diferente em formato ou estrutura (por exemplo, para transformar XML em
HTML para uso em um site da Web ou para transformá-lo em um documento que contenha
apenas os campos necessários para um aplicativo). Esse processo de transformação é
especificado pelo W3C (World Wide Web Consortium) (W3C) Recomendação versão 1.0 XSLT
localizado em www.w3.org/TR/XSLT. No, .NET Framework a XslTransform classe, encontrada no
espaço para nome System.Xml.Xsl, é o processador XSLT que implementa a funcionalidade
dessa especificação. Existe um pequeno número dos recursos que não foram implementados da
recomendação W3C 1.0 XSLT, listada em Saídas de um XslTransform. A figura a seguir mostra a
arquitetura de transformação a .NET Framework.
Visão Geral
Arquitetura de transformação
A recomendação XSLT usa XML Path Language (XPath) para selecionar partes de um documento
XML, XPath é uma linguagem de consulta usada para navegar nós de uma árvore de
documentos. Como mostrado no diagrama, a .NET Framework Implementação do XPath é usada
para selecionar partes de XML armazenados em várias classes, como um XmlDocument, um
XmlDataDocument, e um XPathDocument. Um XPathDocument é um armazenamento de dados
XSLT otimizado, e quando usado com XslTransform, ele fornece transformações XSLT com bom
desempenho.
A seguinte lista de tabela normalmente usa classes ao trabalhar com XslTransform e XPath e
suas funções.

Classe ou
interface Função
XPathNavigator É uma API que fornece um modelo de estilo cursor para navegar em um
armazenamento, juntamente com suporte a consultas XPath. Ele não
fornece a edição de armazenamento subjacente. Para edição, use a
XmlDocument classe.
IXPathNavigable Ele é uma interface que fornece um CreateNavigator método para para o
armazenamento. um XPathNavigator
XmlDocument Ele permite edição do documento. Ele implementa IXPathNavigable,
permitindo cenários edição documento-onde transformações XSLT são
necessárias posteriormente. Para obter mais informações, consulte Entrada
XmlDocument para XslTransform.
XmlDataDocument Ele é derivado da XmlDocument. Ele Bridges o relacional e mundos XML
por meio. Para otimizar o armazenamento de dados estruturados dentro do
documento XML de acordo com mapeamentos especificados em um
DataSet o DataSet Ele implementa IXPathNavigable, permitindo cenários
onde transformações XSLT podem ser executadas sobre dados
recuperados de um banco de dados relacionais. Para obter mais
informações, consulte Integração XML com dados relacional e ADO.NET.
XPathDocument Essa classe é otimizada para XslTransform consultas XPath,
processamento e e ele fornece um cache de alto desempenho somente
leitura. Ele implementa IXPathNavigable e é o armazenamento preferencial
a ser usado para transformações XSLT.
XPathNodeIterator Ele fornece navegação pela conjuntos de nó XPath. Todos os métodos de
Seleção XPath no XPathNavigator retorno um XPathNodeIterator. Vários
XPathNodeIterator objetos podem ser criados sobre o mesmo
armazenamento, que representa cada um conjunto de nós selecionado.
Extensões XSLT MSXML
O msxsl:script e msxsl:node-set funções são as extensões XSLT Microsoft XML Core Services
(MSXML) somente suporte para a XslTransform classe.
Exemplo
Código o exemplo seguinte carrega um folha de estilo XSLT, lê um arquivo denominado

meusdados.xml em e executa uma transformação sobre os dados em um arquivo fictício chamado
myStyleSheet.xsl, enviar a saída formatada para o console. an XPathDocument,
C#
using System; using System.IO; using System.Xml; using System.Xml.XPath; using System.Xml.Xsl; public
class Sample { private const String filename = "mydata.xml"; private const String stylesheet =
"myStyleSheet.xsl"; public static void Main() { XslTransform xslt = new XslTransform();
xslt.Load(stylesheet); XPathDocument xpathdocument = new XPathDocument(filename); XmlTextWriter
writer = new XmlTextWriter(Console.Out); writer.Formatting=Formatting.Indented;
xslt.Transform(xpathdocument, null, writer, null); } }

Modelo de objeto de esquema (SOM) do XML
Um esquema XML é uma ferramenta poderosa e complexa para criar e validando estrutura em
documentos XML compatíveis. Semelhante ao dados modelagem em um banco de dados
relacional, um esquema fornece uma maneira de definir a estrutura de documentos XML,
especificando os elementos que podem ser usados nos documentos,, bem como o estrutura e
tipos que esses elementos devem seguir para poder ser válido para que esquema específica.
O esquema Object Model (SOM) fornece um conjunto de classes no espaço para nome
System.Xml.Schema que permitem a você para ler um esquema de um arquivo ou para criar um
esquema na memória programaticamente. O esquema então pode ser traversed, editando,
compilados, validado, ou gravadas em um arquivo.
Visão geral do modelo de objeto do esquema XML

O esquema Objeto Modelo (SOM) no Microsoft .NET Framework é uma API Rich que permite que
você se criar, editar, e validar esquemas programaticamente. O som opera em documentos de
esquema XML de forma semelhante à maneira como o DOM (modelo de objeto Document) opera
em documentos XML. Documentos de esquema XML são válidos arquivos XML que, uma vez
carregados no som, transmitir significado sobre a estrutura e validade de outros documentos XML
que estão de acordo com o esquema.
Um esquema é um documento XML que define uma classe de documentos XML, especificando a
estrutura ou modelo de documentos XML para um esquema específico. Um esquema identifica as
restrições sobre o conteúdo dos documentos XML, e descreve o vocabulário (regras ou gramática)
que compatíveis documentos XML devem seguir a fim de ser considerada Valid esquema com
esse esquema específica. Validação de um documento XML é o processo que garante que o
documento está de acordo com a gramática especificada pelo esquema.
A seguir estão maneiras a API som no .NET Framework permite-lhe criar, editar, e validar
esquemas.
• Carregar e salvar esquemas válidas para e dos arquivos.

• Crie esquemas na memória usando classes de tipo forte.
• Interagir com a XmlSchemaSet classe para cache, compilar, e recuperarem esquemas.
• Interagir com o Create método da XmlReader classe para validar documentos da instância
XML com base em esquemas.
• Criar editores para criar e manter esquemas.
• Editar um esquema que pode ser complied e salvos para uso na validação dos
documentos da instância XML dinamicamente.
O modelo de objeto de esquema
O som consiste de um conjunto abrangente de classes no espaço para nome

System.Xml.Schema correspondente aos elementos em um esquema XML. Por exemplo, o
<xsd:schema>...</xsd:schema> elemento mapeia para a System.Xml.Schema.XmlSchema classe, e
todas as informações que podem estar contidas em um <xsd:schema/> elemento podem ser
representadas usando a XmlSchema classe. Da mesma forma, e
System.Xml.Schema.XmlSchemaAttribute Classes respectivamente. e
<xsd:attribute>...</xsd:attribute> elementos mapear para o <xsd:element>...</xsd:element> o
System.Xml.Schema.XmlSchemaElement Este mapeamento continua para todos os elementos de
um Esquema XML criando um modelo de objeto de esquema XML no espaço para nome
System.Xml.Schema ilustrado no diagrama a seguir.

Para obter mais informações sobre cada classe no espaço para nome System.Xml.Schema,
consulte a System.Xml.Schema documentação de referência espaço para nome da biblioteca de
classe do .NET Framework.

Leitura e escrita esquemas XML
Schema Object Model o som (API) pode ser usado para ler e gravar idioma de definição esquema
XML (XSD) esquemas de arquivos ou outras fontes e criar esquemas na memória XML usar as
classes no espaço para nome System.Xml.Schema que mapeiam para as estruturas definidas na
recomendação Esquema XML W3C (World Wide Web Consortium) (W3C).
Leitura e escrita esquemas XML
Do Read a XmlSchema classe fornece e Write métodos para ler e gravar esquemas XML. O Read
método retorna um XmlSchema objeto que representa o esquema XML e leva um opcional
ValidationEventHandler como um parâmetro para lidar com avisos de validação de esquema e
erros encontrados ao ler um esquema XML.
O Write método grava esquemas XML para Stream, TextWriter e XmlWriter objetos e pode levar
um objeto como um parâmetro opcional XmlNamespaceManager. Um XmlNamespaceManager é
usado para tratar espaços para nome encontrado em um esquema XML. Para obter mais
informações sobre a XmlNamespaceManager classe, consulte Gerenciar Namespaces usando o
XmlNamespaceManager.
O exemplo de código a seguir ilustra Leitura e Gravação esquemas XML de e para um arquivo. O
exemplo de código utiliza o example.xsd arquivo, lê-lo em um XmlSchema objeto usando o static
Read método, e seguida, gravar o arquivo para o console e um novo new.xsd arquivo. O exemplo
de código também fornece um ValidationEventHandler como um parâmetro para o static Read
método para lidar com quaisquer avisos de validação de esquema ou erros encontrados ao ler o
esquema XML. Se (null. não for especificado sem avisos ou erros são relatados,) a
ValidationEventHandler
C#
using System; using System.IO; using System.Text; using System.Xml; using System.Xml.Schema; class
XmlSchemaReadWriteExample { static void Main() { try { XmlTextReader reader = new
XmlTextReader("example.xsd"); XmlSchema myschema = XmlSchema.Read(reader, ValidationCallback);
myschema.Write(Console.Out); FileStream file = new FileStream("new.xsd", FileMode.Create,
FileAccess.ReadWrite); XmlTextWriter xwriter = new XmlTextWriter(file, new UTF8Encoding());
xwriter.Formatting = Formatting.Indented; myschema.Write(xwriter); } catch(Exception e) {
Console.WriteLine(e); } } static void ValidationCallback(object sender, ValidationEventArgs args) { if
(args.Severity == XmlSeverityType.Warning) Console.Write("WARNING: "); else if (args.Severity ==
XmlSeverityType.Error) Console.Write("ERROR: "); Console.WriteLine(args.Message); } }
O exemplo utiliza a example.xsd como entrada.
<?xml version="1.0"?> <xs:schema id="play" targetNamespace="http://tempuri.org/play.xsd"

elementFormDefault="qualified" xmlns="http://tempuri.org/play.xsd"
xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name='myShoeSize'> <xs:complexType>
<xs:simpleContent> <xs:extension base='xs:decimal'> <xs:attribute name='sizing' type='xs:string' />
</xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:schema>

Criando esquemas XML
As classes no espaço para nome System.Xml.Schema Mapear para as estruturas definidas na
recomendação Esquema XML W3C (World Wide Web Consortium) (W3C) e pode ser usado para
criar esquemas XML na memória.
Criando um esquema XML
Nos exemplos de código a seguir, a API som é usado para criar um cliente Esquema XML na
memória.
Criando Elemento e atributos
Exemplos de código criar o cliente Esquema da parte inferior Backup, criação o filho elementos,
atributos, e seus tipos correspondentes primeiro, e os elementos de primeiro nível.
No exemplo de código a seguir, a FirstName e XmlSchemaAttribute Classes do SOM. e LastName

elementos, bem como o CustomerId atributo do esquema do cliente é criado usando o
XmlSchemaElement Além das propriedades Name do e XmlSchemaAttribute Classes. e
XmlSchemaAttribute classes, que correspondem ao atributo " name " do) ter propriedades
correspondentes em, fixedValue, form, e assim por diante e <xs:attribute /> elementos em um
esquema XML, todos os outros atributos permitidos pelo esquema o XmlSchemaElement
(defaultValue o <xs:element /> o XmlSchemaElement
C#
// Create the FirstName and LastName elements. XmlSchemaElement firstNameElement = new
XmlSchemaElement(); firstNameElement.Name = "FirstName"; XmlSchemaElement lastNameElement =
new XmlSchemaElement(); lastNameElement.Name = "LastName"; // Create CustomerId attribute.
XmlSchemaAttribute idAttribute = new XmlSchemaAttribute(); idAttribute.Name = "CustomerId";
idAttribute.Use = XmlSchemaUse.Required;
Criar tipos esquema
O conteúdo do elementos e atributos é definido por seus tipos. Do XmlSchemaElement para criar
elementos e atributos cujos tipos são uma do esquema interna tipos, a SchemaTypeName
propriedade do ou XmlSchemaAttribute classes estão definidas com o nome qualificado
correspondente do tipo interno usando a XmlQualifiedName classe. Do XmlSchemaSimpleType
para criar um tipo definido pelo usuário para elementos e atributos, um novo tipo simples ou
complexos é criado usando ou XmlSchemaComplexType Classe.
Observação
Para criar sem nome tipos simples ou complexos que sejam filhos de um elemento ou atributo
anônimos definir a SchemaType propriedade de. (somente tipos simples aplicar para atributos), ou
XmlSchemaAttribute classes para o tipo simples ou complexos sem nome, em vez da
SchemaTypeName propriedade do ou XmlSchemaAttribute Classes o XmlSchemaElement o
XmlSchemaElement
Esquemas XML permitir ambos anônimo e simples nomeado tipos para ser derivado por restrição
de outros tipos simples (internas ou definida pelo usuário) ou construído como uma lista ou união
de outros tipos simples. A XmlSchemaSimpleTypeRestriction classe é usada para criar um tipo

simples, restringindo o tipo interno xs:string. Você também pode usar ou
XmlSchemaSimpleTypeUnion classes para criar tipos Lista ou união. o
XmlSchemaSimpleTypeList A System.Xml.Schema.XmlSchemaSimpleType.Content propriedade
indica se ele é uma restrição de tipo simples, lista, ou união.
No exemplo de código a seguir, tipo do FirstName elemento é o tipo xs:string interno, tipo do
LastName elemento é um tipo simples nomeado que é uma restrição do tipo xs:string interno, com
um MaxLength aspecto Valor de 20, e tipo do CustomerId atributo é o tipo xs:positiveInteger interno.
O Customer elemento é um tipo complexo anônimo cuja partícula é a seqüência de. elementos e
LastName cujos atributos contém o CustomerId atributo a FirstName
Observação
Você também pode usar ou XmlSchemaAll Classes como a partícula do tipo complexo para
duplicam <xs:choice /> ou <xs:all /> semântica. o XmlSchemaChoice
C#
// Create the simple type for the LastName element. XmlSchemaSimpleType lastNameType = new
XmlSchemaSimpleType(); lastNameType.Name = "LastNameType"; XmlSchemaSimpleTypeRestriction
lastNameRestriction = new XmlSchemaSimpleTypeRestriction(); lastNameRestriction.BaseTypeName =
new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMaxLengthFacet
maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "20";
lastNameRestriction.Facets.Add(maxLength); lastNameType.Content = lastNameRestriction; // Associate
the elements and attributes with their types. // Built-in type. firstNameElement.SchemaTypeName = new
XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // User-defined type.
lastNameElement.SchemaTypeName = new XmlQualifiedName("LastNameType",
"http://www.tempuri.org"); // Built-in type. idAttribute.SchemaTypeName = new
XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema"); // Create the top-level
Customer element. XmlSchemaElement customerElement = new XmlSchemaElement();
customerElement.Name = "Customer"; // Create an anonymous complex type for the Customer element.
XmlSchemaComplexType customerType = new XmlSchemaComplexType(); XmlSchemaSequence sequence
= new XmlSchemaSequence(); sequence.Items.Add(firstNameElement);
sequence.Items.Add(lastNameElement); customerType.Particle = sequence; // Add the CustomerId attribute
to the complex type. customerType.Attributes.Add(idAttribute); // Set the SchemaType of the Customer
element to // the anonymous complex type created above. customerElement.SchemaType = customerType;
Criando e Compiling esquemas
Nesse ponto, os elementos filho e atributos, seus tipos correspondentes, e o elemento de nível
superior Customer ter sido criado usando a API som na memória. No exemplo de código a seguir,
o elemento de esquema é criado usando a XmlSchema classe, a elementos de primeiro nível e
tipos são adicionados a ele usando a System.Xml.Schema.XmlSchema.Items propriedade e o
esquema completa é compilado usando a XmlSchemaSet classe e gravada para o console.
C#
// Create an empty schema. XmlSchema customerSchema = new XmlSchema();
customerSchema.TargetNamespace = "http://www.tempuri.org"; // Add all top-level element and types to
the schema customerSchema.Items.Add(customerElement); customerSchema.Items.Add(lastNameType); //
Create an XmlSchemaSet to compile the customer schema. XmlSchemaSet schemaSet = new

XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add(customerSchema); schemaSet.Compile(); foreach (XmlSchema schema in
schemaSet.Schemas()) { customerSchema = schema; } // Write the complete schema to the Console.
customerSchema.Write(Console.Out);
O System.Xml.Schema.XmlSchemaSet.Compile método valida o esquema do cliente contra as

regras para um esquema XML e torna propriedades Post Schema--compilation disponíveis.
Observação
Todas as propriedades Post Schema--compilation na API som diferem da Post Schema--

Validation-InfoSet.
O ValidationEventHandler é um delegado que chama o método ValidationCallback de retorno de

chamada para tratar erros e avisos de validação de esquema. adicionados a XmlSchemaSet
A seguir é exemplo de código completa, e o esquema do cliente gravados no console.
C#
using System; using System.Xml; using System.Xml.Schema; class XmlSchemaCreateExample { static void
Main(string[] args) { // Create the FirstName and LastName elements. XmlSchemaElement
firstNameElement = new XmlSchemaElement(); firstNameElement.Name = "FirstName";
XmlSchemaElement lastNameElement = new XmlSchemaElement(); lastNameElement.Name =
"LastName"; // Create CustomerId attribute. XmlSchemaAttribute idAttribute = new
XmlSchemaAttribute(); idAttribute.Name = "CustomerId"; idAttribute.Use = XmlSchemaUse.Required; //
Create the simple type for the LastName element. XmlSchemaSimpleType lastNameType = new
XmlSchemaSimpleType(); lastNameType.Name = "LastNameType"; XmlSchemaSimpleTypeRestriction
lastNameRestriction = new XmlSchemaSimpleTypeRestriction(); lastNameRestriction.BaseTypeName =
new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); XmlSchemaMaxLengthFacet
maxLength = new XmlSchemaMaxLengthFacet(); maxLength.Value = "20";
lastNameRestriction.Facets.Add(maxLength); lastNameType.Content = lastNameRestriction; // Associate
the elements and attributes with their types. // Built-in type. firstNameElement.SchemaTypeName = new
XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // User-defined type.
lastNameElement.SchemaTypeName = new XmlQualifiedName("LastNameType",
"http://www.tempuri.org"); // Built-in type. idAttribute.SchemaTypeName = new
XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema"); // Create the top-level
Customer element. XmlSchemaElement customerElement = new XmlSchemaElement();
customerElement.Name = "Customer"; // Create an anonymous complex type for the Customer element.
XmlSchemaComplexType customerType = new XmlSchemaComplexType(); XmlSchemaSequence sequence
= new XmlSchemaSequence(); sequence.Items.Add(firstNameElement);
sequence.Items.Add(lastNameElement); customerType.Particle = sequence; // Add the CustomerId attribute
to the complex type. customerType.Attributes.Add(idAttribute); // Set the SchemaType of the Customer
element to // the anonymous complex type created above. customerElement.SchemaType = customerType;
// Create an empty schema. XmlSchema customerSchema = new XmlSchema();
customerSchema.TargetNamespace = "http://www.tempuri.org"; // Add all top-level element and types to
the schema customerSchema.Items.Add(customerElement); customerSchema.Items.Add(lastNameType); //

Create an XmlSchemaSet to compile the customer schema. XmlSchemaSet schemaSet = new
XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add(customerSchema); schemaSet.Compile(); foreach (XmlSchema schema in
schemaSet.Schemas()) { customerSchema = schema; } // Write the complete schema to the Console.
customerSchema.Write(Console.Out); } static void ValidationCallback(object sender, ValidationEventArgs
args) { if (args.Severity == XmlSeverityType.Warning) Console.Write("WARNING: "); else if (args.Severity
== XmlSeverityType.Error) Console.Write("ERROR: "); Console.WriteLine(args.Message); } }
<?xml version="1.0" encoding="utf-8"?> <xs:schema xmlns:tns="http://www.tempuri.org"
targetNamespace="http://www.tempuri.org" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Customer"> <xs:complexType> <xs:sequence> <xs:element name="FirstName"
type="xs:string" /> <xs:element name="LastName" type="tns:LastNameType" /> </xs:sequence>
<xs:attribute name="CustomerId" type="xs:positiveInteger" use="required" /> </xs:complexType>
</xs:element> <xs:simpleType name="LastNameType"> <xs:restriction base="xs:string"> <xs:maxLength
value="20" /> </xs:restriction> </xs:simpleType> </xs:schema>
Atravessando esquemas XML

Atravessando um Esquema XML usando o esquema Objeto Modelo (SOM) API fornece acesso a
elementos, atributos, e tipos armazenados no SOM. Atravessando um XML esquema carregada
no som é também a primeira etapa da edição um Esquema XML usando a API som.
Atravessando o esquema XML
As seguintes propriedades da classe XmlSchema fornecem acesso à coleção de todos os itens

adicionados ao esquema XML globais.
Propriedade Tipo de objeto armazenado na coleção ou matriz

Elements XmlSchemaElement
Attributes XmlSchemaAttribute
AttributeGroups XmlSchemaAttributeGroup
Groups XmlSchemaGroup
Includes XmlSchemaExternalXmlSchemaInclude ou XmlSchemaRedefine,
XmlSchemaImport
Items (XmlSchemaObject fornece acesso a todos os elementos nível globais,
atributos e tipos.)
Notations XmlSchemaNotation
SchemaTypes XmlSchemaType, XmlSchemaSimpleType, XmlSchemaComplexType
UnhandledAttributes (XmlAttribute) fornece acesso a atributos que não pertencem ao
espaço para nome do esquema
Observação
Todas as propriedades listadas na tabela acima, exceto para a Items propriedade, são Post
Schema--Compilation-InfoSet propriedades (PSCI) que não estão disponíveis até que o esquema
tiver sido compilada. A Items propriedade é uma propriedade Pre Schema--compilation que pode
ser usada antes o esquema tem foi compilada para acessar e editar todos os elementos nível
globais, atributos e tipos.

A UnhandledAttributes propriedade fornece acesso a todos os atributos que não pertencem ao
espaço para nome do esquema. Esses atributos não são processados pelo processador de
esquema.
O exemplo de código a seguir demonstra atravessando o esquema do cliente criada no tópico

Criando esquemas XML. O exemplo de código demonstra atravessando o esquema usando as
coleções descritas acima e grava todos os elementos e atributos no esquema no console.
O exemplo traverses o esquema do cliente nas etapas a seguir.
1. Adiciona o esquema do cliente para um novo XmlSchemaSet objeto e então compila ele.
Quaisquer avisos de validação de esquema e erros encontrados ler ou Compilar o esquema
são tratados pelo ValidationEventHandler delegado.
2. Do XmlSchemaSet recupera o objeto compilado XmlSchema por Iterando sobre a
Schemas propriedade. Como o esquema é compilada, POST Schema--Compilation-InfoSet
propriedades (PSCI) são acessíveis.
3. Itera por cada XmlSchemaElement na coleção Values do POST-Schema - coleção de
compilação System.Xml.Schema.XmlSchema.Elements gravar o nome de cada elemento
para o console.
4. Obtém o Customer elemento usando a XmlSchemaComplexType Classe de tipo
complexo.
5. Se o tipo complexo tem os atributos, obterá e grava seu nome para o console. Para
enumerar sobre cada XmlSchemaAttribute um IDictionaryEnumerator
6. Obtém a partícula de seqüência do tipo complexo usando a XmlSchemaSequence classe.
7. Itera por cada XmlSchemaElement na coleção
System.Xml.Schema.XmlSchemaSequence.Items gravar o nome de cada elemento filho
para o console.
A seguir é o exemplo código completo.
C#
using System; using System.Collections; using System.Xml; using System.Xml.Schema; class
XmlSchemaTraverseExample { static void Main() { // Add the customer schema to a new XmlSchemaSet and
compile it. // Any schema validation warnings and errors encountered reading or // compiling the schema
are handled by the ValidationEventHandler delegate. XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
schemaSet.Add("http://www.tempuri.org", "customer.xsd"); schemaSet.Compile(); // Retrieve the compiled
XmlSchema object from the XmlSchemaSet // by iterating over the Schemas property. XmlSchema
customerSchema = null; foreach (XmlSchema schema in schemaSet.Schemas()) { customerSchema =
schema; } // Iterate over each XmlSchemaElement in the Values collection // of the Elements property.
foreach (XmlSchemaElement element in customerSchema.Elements.Values) { Console.WriteLine("Element:
{0}", element.Name); // Get the complex type of the Customer element. XmlSchemaComplexType
complexType = element.ElementSchemaType as XmlSchemaComplexType; // If the complex type has any
attributes, get an enumerator // and write each attribute name to the console. if
(complexType.AttributeUses.Count > 0) { IDictionaryEnumerator enumerator =
complexType.AttributeUses.GetEnumerator(); while (enumerator.MoveNext()) { XmlSchemaAttribute
attribute = (XmlSchemaAttribute)enumerator.Value; Console.WriteLine("Attribute: {0}", attribute.Name); }
} // Get the sequence particle of the complex type. XmlSchemaSequence sequence =

complexType.ContentTypeParticle as XmlSchemaSequence; // Iterate over each XmlSchemaElement in the
Items collection. foreach (XmlSchemaElement childElement in sequence.Items) {
Console.WriteLine("Element: {0}", childElement.Name); } } } static void ValidationCallback(object sender,
ValidationEventArgs args) { if (args.Severity == XmlSeverityType.Warning) Console.Write("WARNING: ");
else if (args.Severity == XmlSeverityType.Error) Console.Write("ERROR: ");
Console.WriteLine(args.Message); } }
A System.Xml.Schema.XmlSchemaElement.ElementSchemaType propriedade pode ser

XmlSchemaSimpleType, ou XmlSchemaComplexType se ele for um tipo simples definida pelo
usuário ou um tipo complexo. Também pode ser XmlSchemaDatatype se ele é um dos tipos de
dados internos definido na Recomendação Esquema XML do W3C. No esquema do cliente, e a
FirstName. do elemento Customer é XmlSchemaComplexType, e LastName são
XmlSchemaSimpleType elementos a ElementSchemaType
Exemplo de código no tópico Criando esquemas XML utilizado a

System.Xml.Schema.XmlSchemaComplexType.Attributes coleção para adicionar o atributo
CustomerId para o Customer elemento. Esta é uma propriedade Pre Schema--compilation. A
propriedade Post Schema--Compilation-InfoSet correspondente é a
System.Xml.Schema.XmlSchemaComplexType.AttributeUses coleção, que contém todos os
atributos do tipo complexo, incluindo aqueles que são herdadas a derivação de tipo.
Editar Esquemas XML

Editar um esquema XML é um dos recursos mais importantes do esquema Objeto Modelo (SOM).
Todas as propriedades Pre Schema--compilation do som poderá usar para alterar os valores
existentes em um esquema XML. O esquema XML então pode ser recompiled para refletir as
alterações.
A primeira etapa na edição um esquema carregada no som é para atravessar o esquema. Você
deve estar familiarizado com atravessando um esquema usando a API som antes de tentar editar
um esquema. Você também deve estar familiarizado com as propriedades e POST Schema--
compilation antes do POST Schema--Compilation-InfoSet (PSCI).
Editar um esquema XML
Nesta seção, dois exemplos de código são fornecidos, ambos os quais editar o esquema do
cliente criada no tópico Criando esquemas XML. O primeiro exemplo de código adiciona um novo
PhoneNumber elemento para o Customer elemento e o segundo exemplo de código adiciona um
novo Title atributo para o FirstName elemento. O primeiro exemplo também usa o POST-Schema -
coleção de compilação System.Xml.Schema.XmlSchema.Elements como o meio de atravessando
o esquema do cliente enquanto o segundo exemplo de código usa o Pre-Schema - coleção de
compilação System.Xml.Schema.XmlSchema.Items.
Exemplo do elemento PhoneNumber
Este primeiro exemplo de código adiciona um novo PhoneNumber elemento para o Customer
elemento do esquema do cliente. O exemplo de código edita o esquema do cliente nas etapas a
seguir.

3. Cria o PhoneNumber elemento usando a XmlSchemaElement classe, a xs:string restrição de
tipo simples Usando. e XmlSchemaSimpleTypeRestriction classes, adiciona um aspecto
padrão à propriedade Facets da restrição, e adiciona a restrição à propriedade Content de
tipo simples e o tipo simples para do elemento PhoneNumber o XmlSchemaSimpleType o
SchemaType
4. Itera por cada XmlSchemaElement na coleção Values do POST-Schema - coleção de
compilação System.Xml.Schema.XmlSchema.Elements.
5. Do QualifiedName se do elemento é "Customer", obtém o Customer elemento usando a
XmlSchemaComplexType classe e a partícula de seqüência do tipo complexo usando a
XmlSchemaSequence Classe de tipo complexo.
6. Adiciona o novo PhoneNumber elemento à seqüência contendo o existente FirstName e
LastName elementos usando o Pre-Schema - coleção de compilação Items da seqüência.
7. Finalmente, reprocesses e compila o objeto modificado XmlSchema Usando e grava-para
o console. e Compile métodos de classe XmlSchemaSet a Reprocess
C#
using System; using System.Xml; using System.Xml.Schema; class XmlSchemaEditExample { static void
Main(string[] args) { // Add the customer schema to a new XmlSchemaSet and compile it. // Any schema
validation warnings and errors encountered reading or // compiling the schema are handled by the
ValidationEventHandler delegate. XmlSchemaSet schemaSet = new XmlSchemaSet();
schema; } // Create the PhoneNumber element. XmlSchemaElement phoneElement = new
XmlSchemaElement(); phoneElement.Name = "PhoneNumber"; // Create the xs:string simple type
restriction. XmlSchemaSimpleType phoneType = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); //
Add a pattern facet to the restriction. XmlSchemaPatternFacet phonePattern = new
XmlSchemaPatternFacet(); phonePattern.Value = "\\d{3}-\\d{3}-\\d(4)";
restriction.Facets.Add(phonePattern); // Add the restriction to the Content property of the simple type //
and the simple type to the SchemaType of the PhoneNumber element. phoneType.Content = restriction;
phoneElement.SchemaType = phoneType; // Iterate over each XmlSchemaElement in the Values collection
// of the Elements property. foreach (XmlSchemaElement element in customerSchema.Elements.Values) {
// If the qualified name of the element is "Customer", // get the complex type of the Customer element //
and the sequence particle of the complex type. if (element.QualifiedName.Name.Equals("Customer")) {
XmlSchemaComplexType customerType = element.ElementSchemaType as XmlSchemaComplexType;
XmlSchemaSequence sequence = customerType.Particle as XmlSchemaSequence; // Add the new
PhoneNumber element to the sequence. sequence.Items.Add(phoneElement); } } // Reprocess and compile
the modified XmlSchema object and write it to the console. schemaSet.Reprocess(customerSchema);
schemaSet.Compile(); customerSchema.Write(Console.Out); } static void ValidationCallback(object sender,

A seguir é o esquema do cliente modificado criada no tópico Criando esquemas XML.

type="xs:string" /> <xs:element name="LastName" type="tns:LastNameType" /> <xs:element
name="PhoneNumber"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="\d{3}-
\d{3}-\d(4)" /> </xs:restriction> </xs:simpleType> </xs:element> </xs:sequence> <xs:attribute
name="CustomerId" type="xs:positiveInteger" use="required" / > </xs:complexType> </xs:element>
<xs:simpleType name="LastNameType"> <xs:restriction base="xs:string"> <xs:maxLength value="20" />
</xs:restriction> </xs:simpleType> </xs:schema>
Exemplo do atributo de título
Este exemplo de código segundo, adiciona um novo Title atributo para o FirstName elemento do
esquema do cliente. No primeiro exemplo de código, o tipo do elemento FirstName é xs:string. Para
o FirstName elemento para que um atributo junto com conteúdo de seqüência, seu tipo deve ser
alterado para um tipo complexo com um modelo de conteúdo simples de extensão conteúdo.
O exemplo de código edita o esquema do cliente nas etapas a seguir.
3. Cria um novo tipo complexo para o FirstName elemento usando a
XmlSchemaComplexType classe.
4. Do XmlSchemaSimpleContent cria uma nova extensão de conteúdo simples, com um tipo
base de xs:string, usando e XmlSchemaSimpleContentExtension Classes.
5. Cria o novo Title atributo usando a XmlSchemaAttribute classe, COM e adiciona o atributo
à extensão de conteúdo simples. de xs:string um SchemaTypeName
6. Define o modelo de conteúdo do conteúdo simples para a extensão de conteúdo simples e
o modelo de conteúdo do tipo complexo para o conteúdo simples.
7. Adiciona o novo tipo complexo para o Pre-Schema - coleção de compilação
System.Xml.Schema.XmlSchema.Items.
8. Itera por cada XmlSchemaObject no Pre-Schema - coleção de compilação
System.Xml.Schema.XmlSchema.Items.
Observação
Do System.Xml.Schema.XmlSchema.Items porque o FirstName elemento é um elemento global

não no esquema, não está disponível em ou System.Xml.Schema.XmlSchema.Elements
Coleções. O exemplo de código localiza o FirstName elemento, localizando o Customer elemento

primeiro.
O primeiro exemplo de código traversed o esquema usando o POST-Schema - coleção de
compilação System.Xml.Schema.XmlSchema.Elements. Neste exemplo, o Pre-schema -.
coleção de compilação System.Xml.Schema.XmlSchema.Items é usada para atravessar o
esquema Enquanto as duas coleções fornecem acesso aos elementos globais no esquema,
Iterando através da Items coleção é mais demorada porque você deve iterar sobre todos os
elementos no esquema globais e ele não tem nenhuma propriedade PSCI. As coleções PSCI
(System.Xml.Schema.XmlSchema.Elements., System.Xml.Schema.XmlSchema.Attributes)
fornecer acesso direto a seus elementos globais, atributos, e tipos e suas propriedades PSCI,
System.Xml.Schema.XmlSchema.SchemaTypes, e assim por diante
1. Se cujos QualifiedName é "Customer", obtém do elemento Customer usando a

XmlSchemaComplexType classe e a partícula de seqüência do tipo complexo usando a
XmlSchemaSequence classe tipo complexo. é um elemento, o XmlSchemaObject
2. Itera por cada XmlSchemaParticle no Pre-Schema - coleção de compilação
System.Xml.Schema.XmlSchemaSequence.Items.
3. Se que. é um elemento, o QualifiedName é "FirstName", define do elemento FirstName
para o novo FirstName tipo complexo ao XmlSchemaParticleSchemaTypeName
4. Finalmente, reprocesses e compila o objeto modificado XmlSchema Usando e grava-para
o console. e Compile métodos de classe XmlSchemaSet a Reprocess
C#
using System; using System.Xml; using System.Xml.Schema; class XmlSchemaEditExample { static void
Main(string[] args) { // Add the customer schema to a new XmlSchemaSet and compile it. // Any schema
validation warnings and errors encountered reading or // compiling the schema are handled by the
ValidationEventHandler delegate. XmlSchemaSet schemaSet = new XmlSchemaSet();
schema; } // Create a complex type for the FirstName element. XmlSchemaComplexType complexType =
new XmlSchemaComplexType(); complexType.Name = "FirstNameComplexType"; // Create a simple
content extension with a base type of xs:string. XmlSchemaSimpleContent simpleContent = new
XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension simpleContentExtension = new
XmlSchemaSimpleContentExtension(); simpleContentExtension.BaseTypeName = new
XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // Create the new Title attribute
with a SchemaTypeName of xs:string // and add it to the simple content extension. XmlSchemaAttribute
attribute = new XmlSchemaAttribute(); attribute.Name = "Title"; attribute.SchemaTypeName = new
XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
simpleContentExtension.Attributes.Add(attribute); // Set the content model of the simple content to the
simple content extension // and the content model of the complex type to the simple content.
simpleContent.Content = simpleContentExtension; complexType.ContentModel = simpleContent; // Add
the new complex type to the pre-schema-compilation Items collection.
customerSchema.Items.Add(complexType); // Iterate over each XmlSchemaObject in the pre-schema-
compilation // Items collection. foreach (XmlSchemaObject schemaObject in customerSchema.Items) { // If
the XmlSchemaObject is an element, whose QualifiedName // is "Customer", get the complex type of the

Customer element // and the sequence particle of the complex type. if (schemaObject is
XmlSchemaElement) { XmlSchemaElement element = schemaObject as XmlSchemaElement; if
(element.QualifiedName.Name.Equals("Customer")) { XmlSchemaComplexType customerType =
element.ElementSchemaType as XmlSchemaComplexType; XmlSchemaSequence sequence =
customerType.Particle as XmlSchemaSequence; // Iterate over each XmlSchemaParticle in the pre-schema-
compilation // Items property. foreach (XmlSchemaParticle particle in sequence.Items) { // If the
XmlSchemaParticle is an element, who's QualifiedName // is "FirstName", set the SchemaTypeName of the
FirstName element // to the new FirstName complex type. if (particle is XmlSchemaElement) {
XmlSchemaElement childElement = particle as XmlSchemaElement; if
(childElement.Name.Equals("FirstName")) { childElement.SchemaTypeName = new
XmlQualifiedName("FirstNameComplexType", "http://www.tempuri.org"); } } } } } } // Reprocess and
compile the modified XmlSchema object and write it to the console. schemaSet.Reprocess(customerSchema);
schemaSet.Compile(); customerSchema.Write(Console.Out); } static void ValidationCallback(object sender,
A seguir é o esquema do cliente modificado criada no tópico Criando esquemas XML.
<?xml version="1.0" encoding=" utf-8"?> <xs:schema xmlns:tns="http://www.tempuri.org"

type="tns:FirstNameComplexType" /> <xs:element name="LastName" type="tns:LastNameType" />
</xs:sequence> <xs:attribute name="CustomerId" type="xs:positiveInteger" use="required" / >
</xs:complexType> </xs:element> <xs:simpleType name="LastNameType"> <xs:restriction
base="xs:string"> <xs:maxLength value="20" /> </xs:restriction> </xs:simpleType> <xs:complexType
name="FirstNameComplexType"> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute
name="Title" type="xs:string" /> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:schema>
Incluindo ou importar esquemas XML

Um esquema XML pode conter <xs:import />, <xs:include />,. e <xs:redefine /> elementos Esses
elementos de esquema consultar outros esquemas XML podem ser usadas para complementar a
estrutura do esquema que inclui ou importa-los. O XmlSchemaImport, XmlSchemaInclude e
XmlSchemaRedefine classes, mapeie para esses elementos no esquema Objeto modelo o som
(API).
Incluindo ou importando um esquema XML
O exemplo de código a seguir complementa o esquema do cliente criada no tópico Criando

esquemas XML com o esquema de endereço. Supplementing o esquema do cliente com o
esquema de endereço torna tipos de endereço disponível no esquema do cliente.
O esquema de endereço pode ser incorporada usando uma <xs:include /> ou <xs:import />
elementos para usar os componentes do esquema de endereço como. - é, ou usando um
<xs:redefine /> elemento para modificar qualquer um dos seus componentes para atender a
necessidade do esquema do cliente Como o esquema de endereço tem uma targetNamespace que
é diferente do esquema do cliente, o <xs:import /> elemento e portanto semântica de importação é
usada.

O exemplo de código inclui o esquema de endereço nas etapas a seguir.
1. Adiciona o esquema do cliente e o esquema de endereço a um novo XmlSchemaSet

objeto e então compila-los. Quaisquer avisos de validação de esquema e erros encontrados
ler ou compilar os esquemas são tratados pelo ValidationEventHandler delegado.
2. Do XmlSchemaSet recupera os objetos compilados XmlSchema para esquemas tanto o
cliente e endereço de por Iterando sobre a Schemas propriedade. Como os esquemas são
compiladas, POST Schema--Compilation-InfoSet propriedades (PSCI) são acessíveis.
3. Cria um XmlSchemaImport objeto, define a Namespace Propriedade da importação ao
espaço para nome do esquema do endereço, define a Schema Propriedade da importação
para o XmlSchema objeto do esquema de endereço, e adiciona a importação à Includes
propriedade do esquema do cliente.
4. Reprocesses e compila o objeto modificado XmlSchema do esquema usando o do cliente
e grava-para o console. e Compile métodos de classe XmlSchemaSet a Reprocess
5. Finalmente, recursivamente grava todos os os esquemas importadas para o esquema do
cliente para o console usando a Includes propriedade do esquema do cliente. Do a
Includes propriedade fornece acesso a todos inclui, importações, ou redefines adicionado a
um esquema.
A seguir é exemplo de código concluída e os esquemas Cliente e Endereço gravadas o console.
C#
using System; using System.Xml; using System.Xml.Schema; class XmlSchemaImportExample { static void
Main(string[] args) { // Add the customer and address schemas to a new XmlSchemaSet and compile them.
// Any schema validation warnings and errors encountered reading or // compiling the schemas are handled
by the ValidationEventHandler delegate. XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add("http://www.tempuri.org", "customer.xsd");
schemaSet.Add("http://www.example.com/IPO", "address.xsd"); schemaSet.Compile(); // Retrieve the
compiled XmlSchema objects for the customer and // address schema from the XmlSchemaSet by iterating
over // the Schemas property. XmlSchema customerSchema = null; XmlSchema addressSchema = null;
foreach (XmlSchema schema in schemaSet.Schemas()) { if (schema.TargetNamespace ==
"http://www.tempuri.org") customerSchema = schema; else if (schema.TargetNamespace ==
"http://www.example.com/IPO") addressSchema = schema; } // Create an XmlSchemaImport object, set the
Namespace property // to the namespace of the address schema, the Schema property // to the address
schema, and add it to the Includes property // of the customer schema. XmlSchemaImport import = new
XmlSchemaImport(); import.Namespace = "http://www.example.com/IPO"; import.Schema =
addressSchema; customerSchema.Includes.Add(import); // Reprocess and compile the modified
XmlSchema object // of the customer schema and write it to the console.
schemaSet.Reprocess(customerSchema); schemaSet.Compile(); customerSchema.Write(Console.Out); //
Recursively write all of the schemas imported into the // customer schema to the console using the Includes
// property of the customer schema. RecurseExternals(customerSchema); } static void
RecurseExternals(XmlSchema schema) { foreach (XmlSchemaExternal external in schema.Includes) { if
(external.SchemaLocation != null) { Console.WriteLine("External SchemaLocation: {0}",
external.SchemaLocation); } if (external is XmlSchemaImport) { XmlSchemaImport import = external as
XmlSchemaImport; Console.WriteLine("Imported namespace: {0}", import.Namespace); } if
(external.Schema != null) { external.Schema.Write(Console.Out); RecurseExternals(external.Schema); } } }
static void ValidationCallback(object sender, ValidationEventArgs args) { if (args.Severity ==

XmlSeverityType.Warning) Console.Write("WARNING: "); else if (args.Severity == XmlSeverityType.Error)
Console.Write("ERROR: "); Console.WriteLine(args.Message); } }
<xs:import namespace="http://www.example.com/IPO" /> <xs:element name="Customer">
<xs:complexType> <xs:sequence> <xs:element name="FirstName" type="xs:string" /> <xs:element
name="LastName" type="tns:LastNameType" /> </xs:sequence> <xs:attribute name="CustomerId"
type="xs:positiveInteger" use="required" / > </xs:complexType> </xs:element> <xs:simpleType
name="LastNameType"> <xs:restriction base="xs:string"> <xs:maxLength value="20" /> </xs:restriction>
</xs:simpleType> </xs:schema> <schema targetNamespace="http://www.example.com/IPO"
xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ipo="http://www.example.com/IPO">
<annotation> <documentation xml:lang="en"> Addresses for International Purchase order schema
Copyright 2000 Example.com. All rights reserved. </documentation> </annotation> <complexType
name="Address"> <sequence> <element name="name" type="string"/> <element name="street"
type="string"/> <element name="city" type="string"/> </sequence> </complexType> <complexType
name="USAddress"> <complexContent> <extension base="ipo:Address"> <sequence> <element
name="state" type="ipo:USState"/> <element name="zip" type="positiveInteger"/> </sequence>
</extension> </complexContent> </complexType>  <simpleType name="USState"> <restriction base="string"> <enumeration value="AK"/>
<enumeration value="AL"/> <enumeration value="AR"/>  </restriction>
</simpleType> </schema>
Para obter mais informações sobre e XmlSchemaRedefine classes, consulte documentação de

referência de classe espaço para nome e Especificações do esquema do W3C XML a
System.Xml.Schema., e <xs:redefine /> elementos e XmlSchemaImport, XmlSchemaInclude a
<xs:import />, <xs:include />
Integração XML com dados relacional e ADO.NET

A XmlDataDocument classe é uma classe derivada de e contém dados XML. o XmlDocument, A
vantagem de é que ele fornece uma ponte entre dados relacionais e hierárquico. o
XmlDataDocument É um XmlDocument que pode ser vinculados a e ambas as classes podem
sincronizar alterações feitas nos dados contidos em duas classes. um DataSet Um XmlDocument
que esteja vinculado ao permite XML para integrar com dados relacionais, e você que não têm
com os dados representados como o XML ou em um formato Relacional. um DataSet Você pode
fazer ambos e não ser restrito a um única representação dos dados.
Os benefícios de ter dados em dois modos de exibição disponíveis são:
• A parte do documento XML estruturada pode ser mapeado para um DataSet, e ser
eficiente armazenados, indexado, e pesquisados.
• Transformações, validação e navegação pode ser feito com eficiência através de um
modelo Cursor em vez dos dados XML que são armazenados relationally. Às vezes, ele pode
ser feito com mais eficiência em estruturas que se o XML será armazenado em um
XmlDocument modelo relacionais.
• O DataSet pode armazenar uma parte do XML. Isto é, você pode usar XPath ou
XslTransform Para armazenar a. apenas os elementos e atributos de juros um DataSet A
partir daí, as alterações podem ser feitas o subconjunto de dados, menores e filtrados com as
alterações propagando aos dados maiores no XmlDataDocument.

Você também pode executar uma transformação sobre os dados que foi carregados em do SQL
Server. o DataSet Outra opção é para vincular WinForm gerenciados classes-Estilo- .NET
Framework e controles WebForm para uma DataSet que foi preenchido de um fluxo de entrada
XML.
Além de suporte XslTransform, um XmlDataDocument Dados Relacionais expõe para XPath

consultas e validação. Basicamente, todos os serviços XML estão disponíveis sobre dados
relacionais, e instalações relacionais como vínculo de controle, CodeGen, e assim por diante,
estão disponíveis sobre uma projeção de XML estruturada sem comprometer fidelidade XML.
Porque XmlDataDocument é herdada de um XmlDocument, ele fornece uma implementação de

DOM W3C. O fato de alguma forma. que é associado a, e armazenará um subconjunto de seus
dados em, um DataSet faz não restringir ou alterar seu uso como a XmlDataDocument uma
XmlDocument Código escrito para consumir um XmlDocument funciona inalterado contra um
XmlDataDocument. O DataSet Fornece exibição relacional dos mesmos dados definindo tabelas,
colunas, relações, e restrições, e é um armazenamento de dados do usuário Autônomo, na
memória.
A ilustração a seguir mostra as associações diferentes que dados XML tem com e
XmlDataDocument. o DataSet
A ilustração mostra dados XML que podem ser carregados diretamente em que permite a
manipulação direta com XML da maneira Relacional. a DataSet, Ou, o XML pode ser carregado
em uma classe de DOM, que é o XmlDataDocument, e posteriormente carregado e sincronizado
com derivado o DataSet.. o DataSet Porque as alterações feitas aos dados em um
armazenamento de dados, são refletidas no outro armazenamento. e XmlDataDocument estão
sincronizados em um único conjunto a DataSet
Do XmlDocument o XmlDataDocument herda todos os recursos de edição e navegação. Há

momentos ao usar. e seus recursos herdados, sincronizados com é uma opção mais apropriada
que carregar XML diretamente na XmlDataDocument a DataSet, o DataSet A tabela a seguir
mostra os itens a serem considerados ao escolher o método a ser usado para carregar o DataSet.
Quando se carregar XML diretamente para um Quando se sincronizar um

DataSet XmlDataDocument com um DataSet
Consultas de dados na DataSet são mais fácil com Consultas XPath são necessárias sobre os
SQL que XPath. dados no DataSet.
Preservação do elemento ordenação no código- Preservação do elemento ordenação no

fonte XML é não crítica. código-fonte XML é essencial.
Espaço em branco entre elementos e formatação Espaço em branco e formatação

não precise ser preservado no código-fonte XML. manutenção no código-fonte XML é crítica.

Se carregar e gravar XML diretamente em e fora de um DataSet Endereços suas necessidades,
consulte Carregar um DataSet de XML e Gravar um DataSet como dados XML.
Do DataSet se carregando de um XmlDataDocument Endereços suas necessidades, consulte

Sincronizando um Datasetwith um documento XML.
Resolver externos recursos XML nomeados por um URI

O XmlResolver é uma classe abstrata que localiza externos recursos XML que tiver sido
nomeados por um URI. É usado para carregar documentos XML, e para resolver externos
recursos, como entidades, DTDs ou esquemas, e importar ou incluir diretivas. As XmlResolver
alças digite todos os aspectos do negociar a conexão com os recursos, inclusive tratamento
credenciais de segurança, abrindo a conexão com a fonte de dados, e retornar o recurso sob a
forma de um fluxo ou outro objeto.
O.NET Framework inclui duas implementações da classe XmlResolver.
• A XmlUrlResolver classe é o resolvedor padrão para todas as classes no espaço para

nome System.Xml. Do file:// oferece suporte e http:// Protocolos e solicitações a partir da
WebRequest classe. Em muitos casos, se você não especificar um XmlResolver objeto que
seu aplicativo deve usar, um XmlUrlResolver objeto COM sem credenciais de usuário é usado
para acessar recursos XML.
• A XmlSecureResolver classe ajuda a proteger outro XmlResolver objeto, disposição o
Resolvendo recursos usando o XmlResolver

A XmlValidatingReader classe usa XmlResolver para resolver externos DTDs, entidades, e
esquemas. A fim de resolver esses recursos externos, a XmlResolver propriedade no
XmlValidatingReader deve ser definida. O exemplo a seguir mostra como definir o resolvedor
para resolver um recurso DTD externo utilizado pelo XmlValidatingReader.
C#
XmlValidatingReader vreader = new XmlValidatingReader(new
XmlTextReader("http://www.alpineskihouse.org/abc.xml")); vreader.XmlResolver = new XmlUrlResolver();
while(vreader.Read()) { . . . }
Para resolver um DTD, XmlValidatingReader chama o GetEntity método para obter uma
representação de fluxo da entidade. Se o URI do DTD for um URI relativo,, XmlValidatingReader
chama o ResolveUri método e retorna um URI absoluto para e baseUri. fornecido relativeUri a Se
XmlResolver não sabe como resolver o Uri determinado, então ele retornará uma null referência.
Além disso, se as configurações de segurança forem necessários para acessar o recurso externo,,
a Credentials propriedade pode ser definida de acordo. Essa propriedade permite ao usuário
para definir configurações de autenticação para URIs. Para obter mais informações sobre fornecer
credenciais, consulte Fornecer credenciais de autenticação para XmlResolver quando leitura de
um arquivo.
O GetEntity método em usa XmlUrlResolver as informações na Credentials propriedade como

apropriado para obter acesso ao recurso. Não há nenhum get acessador para esta propriedade
por razões de segurança. Ao substituir XmlResolver, GetEntity é o método que utiliza as
informações de credenciais na Credentials propriedade.

Se você não fornecer a ser usado, em seguida um padrão XmlUrlResolver é criado e null
credenciais são usados. para um XmlResolver o XmlValidatingReader
Resolver todos os outros recursos XML é muito semelhante a resolver DTDs. XmlResolver.
precisa saber apenas como negociar a conexão com o recurso externo, e retornar uma
representação de fluxo de conteúdo Ele é o objeto que está fazendo a chamada para
XmlResolver que tenha a tarefa de interpretar o fluxo.
Fornecer credenciais de autenticação para XmlResolver

quando leitura de um arquivo
Ao resolver uma URL para um arquivo que contém os dados XML para leitura, o arquivo pode ter
uma diretiva de acesso restrito. Se a autenticação for necessária para acessar um recurso de
rede, use a Credentials propriedade para especificar as credenciais necessárias. Se a
Credentials propriedade não está definida, então credenciais serão configuradas para null.
Por exemplo, suponha que as credenciais são necessárias ao solicitar dados a partir da Web para
fins de autenticação. Se o diretório virtual da Web permitir acesso anônimo, então a propriedade
não precisa a ser definido para acesso anônimo. No entanto, se a pasta não permitir acesso
anônimo, então você precisará fornecer credenciais. O exemplo a seguir cria um XmlReader que
usa com credenciais padrão para acessar o site http://localhost/bookstore/Inventory.xml. um
XmlUrlResolver
C#
// Create a resolver with default credentials. XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; // Set the reader settings object to
use the resolver. settings.XmlResolver = resolver; // Create the XmlReader object. XmlReader reader =
XmlReader.Create("http://ServerName/data/books.xml", settings);
Credenciais diferentes podem ser fornecidos para URIs diferentes e adicionados a um cache de
credenciais. Essas credenciais são usados para verificar autenticação para o URIs
independentemente da fonte original do XML diferentes. A seguir mostra exemplo adicionando
credenciais a um cache.
C#
// Create the credentials. NetworkCredential myCred = new
NetworkCredential(UserName,SecurelyStoredPassword,Domain); CredentialCache myCache = new
CredentialCache(); myCache.Add(new Uri("http://www.contoso.com/"), "Basic", myCred);
myCache.Add(new Uri("http://app.contoso.com/"), "Basic", myCred); // Set the credentials on the
XmlUrlResolver object. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = myCache;
// Compile the style sheet. XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("http://serverName/data/xsl/order.xsl",XsltSettings.Default, resolver);
Como usar a classe XmlSecureResolver:
A XmlSecureResolver classe ajuda a proteger outro XmlResolver objeto, disposição o

Para restringir o acesso usando uma URL

• Criar um XmlSecureResolver objeto somente que tem permissão para acessar o site da
intranet local.
C#
XmlSecureResolver myResolver = new XmlSecureResolver(new XmlUrlResolver(),
"http://myLocalSite/");
Para restringir o acesso usando uma permissão defina

1. Criar um WebPermission objeto.
C#
WebPermission myWebPermission = new WebPermission(PermissionState.None);
2. Permitir acesso apenas às seguintes URLs dois.

C#
myWebPermission.AddPermission(NetworkAccess.Connect,"http://www.contoso.com/");
myWebPermission.AddPermission(NetworkAccess.Connect,"http://litwareinc.com/data/");
3. Adicionar as permissões da Web ao objeto PermissionSet.

C#
PermissionSet myPermissions = new PermissionSet(PermissionState.None);
myPermissions.AddPermission(myWebPermission);
4. Crie um XmlSecureResolver objeto usando o conjunto de permissões.

C#
XmlSecureResolver myResolver = new XmlSecureResolver(new XmlUrlResolver(), myPermissions);
Para restringir o acesso usando provas

• Você pode restringir o acesso usando Evidence. O Evidence é aplicada a base
XmlResolver. é usado para criar o PermissionSet que As XmlSecureResolver chamadas
PermitOnly No criado PermissionSet antes de abrir os recursos.
A lista a seguir resume alguns cenários possíveis e o tipo de prova para fornecer para cada
cenário.
o Você estiver trabalhando em um ambiente totalmente confiáveis:
Use seu conjunto para criar as provas.
C#
Evidence myEvidence = this.GetType().Assembly.Evidence; XmlSecureResolver myResolver; myResolver
= new XmlSecureResolver(new XmlUrlResolver(), myEvidence);
o Você está trabalhando em um ambiente semiconfiável e você tiver código ou dados
provenientes de uma fonte externa. Você sabe a origem da fonte externa e tiver um URI que
pode ser verificada:
Use o URI para criar as provas.
C#
Evidence myEvidence = XmlSecureResolver.CreateEvidenceForUrl(sourceURI); XmlSecureResolver
myResolver = new XmlSecureResolver(new XmlUrlResolver(), myEvidence);
o Você estão trabalhando em um ambiente semiconfiável e você tiver código ou
dados provenientes de uma fonte externa e você não souber a origem da fonte externa:
Definir o evidence Parâmetro para null. Isso permite sem acesso aos recursos.

Ou-
Se seu aplicativo exigir alguns acesso aos recursos, solicitar evidência do chamador.
Use o XmlSecureResolver para resolver recursos XML
System.Xml. É usado para carregar documentos XML, e para resolver externos recursos, como
entidades, DTDs ou esquemas, e importar ou incluir diretivas.
Você pode substituí-lo, especificando o XmlResolver objeto para utilizar. Especificando você
pode restringir os recursos que base XmlResolver pode acessar. an XmlSecureResolver,
Para criar um objeto XmlReader que usa um XmlSecureResolver

1. Criar Definir com a permissão correta. um XmlSecureResolver
2. Criar um XmlReaderSettings objeto que usa o XmlSecureResolver objeto.
C#
XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = myResolver;
3. Use o XmlReaderSettings objeto para criar o XmlReader objeto.

C#
XmlReader reader = XmlReader.Create("books.xml", settings);
Para usar o XmlSecureResolver para carregar um folha de estilo XSLT
1. Criar Definir com a permissão correta. um XmlSecureResolver

2. Do XmlSecureResolver passar para o Load método.
C#
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("http://serverName/data/xsl/sort.xsl", null, myResolver);
Codificação de caracteres de nomes XML e conversão de tipos

de dados XML
O XmlConvert é uma classe de suporte que codifica e decodifica nomes, bem como converte
tipos de dados. A XmlConvert classe é funcionalmente equivalente para o Classe
System.Convert, mas com um partiality com os padrões XML. O sistema tipo é baseado no
esquema XML tipo do esquema de idioma (XSD) de definição, e os valores retornados são
sempre independente localidade.
Espaços para nomes em um documento XML

Espaços para nome XML associar nomes de elemento e atributo em um documento XML a URIs
personalizados e predefinidos. Os prefixos definidos para espaço para nome URIs são usados
para qualificar nomes das elemento e atributo nos dados XML para implementar essa associação.
Espaços para nomes impedir conflitos Nome de elemento e atributo, e permite elementos e
atributos com o mesmo nome a ser tratada de forma diferente e validada de forma diferente.

Suporte tipo nas classes System.Xml
No.NET Framework versão 2.0, as classes principais XML foram aprimoradas para incluir recursos
de suporte tipo. O XmlWriterXmlReader,. e XPathNavigator Classes incluir recursos suporte tipo
incluindo a capacidade para converter entre tipos de esquema XML e tipos Runtime (CLR) de
idioma comum
No.NET Framework versão 2.0, o XmlReader, XmlWriter., e XPathNavigator Classes foram

aprimorados para incluir recursos de suporte tipo
• O XmlReader e XPathNavigator Classes cada incluir uma SchemaInfo propriedade que

retorna as informações de esquema em um nó.
• O ReadContentAs e métodos na classe XmlReader ler um valor de texto e convertê-la
em um valor CLR em um único chamada de método. e ReadElementContentAs
• O WriteValue método na classe XmlWriter converte um tipo Clr em um tipo de esquema
XML ao escrever fora XML.
• O ValueAs e TypedValue propriedades na XPathNavigator classe retornar um valor de nó
e convertê-la em um valor CLR em um único chamada de método.
Observação
No.NET Framework versão 1.0 a XmlConvert classe era necessário para converter entre tipos de
esquema XML e CLR.
Mapear tipos de dados XML para tipos CLR

A tabela a seguir descreve o mapeamento padrão entre os tipos de dados XML e os tipos Runtime
(CLR) de idioma comuns.
A tabela a seguir descreve os mapeamentos padrão de um tipo de dados XML para um tipo Clr.
Observação
Prefixos e xs a xdt são mapeados para a http://www.w3.org/2001/XMLSchema e o espaço para
nome http://www.w3.org/2003/05/XPath-datatypes URIs respectivamente.
Tipo XML Tipo Clr
xs:anyURI Uri
xs:base64Binary Byte[]
xs:boolean Boolean
xs:byte SByte
xs:date DateTime
xs:dateTime DateTime
xs:decimal Decimal
xs:double Double
xs:duration TimeSpan
xs:ENTITIES String[]

xs:ENTITY String
xs:float Single
xs:gDay DateTime
xs:gMonthDay DateTime
xs:gYear DateTime
xs:gYearMonth DateTime
xs:hexBinary Byte[]
xs:ID String
xs:IDREF String
xs:IDREFS String[]
xs:int Int32
xs:integer Decimal
xs:language String
xs:long Int64
xs:gMmonth DateTime
xs:Name String
xs:NCName String
xs:negativeInteger Decimal
xs:NMTOKEN String
xs:NMTOKENS String[]
xs:nonNegativeInteger Decimal
xs:nonPositiveInteger Decimal
xs:normalizedString String
xs:NOTATION XmlQualifiedName
xs:positiveInteger Decimal
xs:QName XmlQualifiedName
xs:short Int16
xs:string String
xs:time DateTime
xs:token String
xs:unsignedByte Byte
xs:unsignedInt UInt32
xs:unsignedLong UInt64
xs:unsignedShort UInt16

xdt:dayTimeDuration TimeSpan
xdt:yearMonthDuration TimeSpan
xdt:untypedAtomic String
xdt:anyAtomicType Object
xs:anySimpleType String
Nó de documento XPathNavigator
Nó de elemento XPathNavigator
Nó de Atributo XPathNavigator
Nó NameSpace XPathNavigator
Nó texto XPathNavigator
Nó comentário XPathNavigator
Nó de instrução de processamento XPathNavigator
Observações de implementação de suporte tipo XML

Este tópico descreve alguns detalhes de implementação que você deseja que esteja ciente das.
Mapeamentos lista
O IList, ICollection e String Tipos são usados para representar tipos Lista de idioma (XSD) de
definição Esquema XML., IEnumerable, Type[]
Mapeamentos de união
Do XmlAtomicValue Tipos UNION são representados usando ou String TIPO. O tipo de fonte ou
tipo de destino, portanto, deve sempre ser String ou XmlAtomicValue.
Se o XmlSchemaDatatype objeto representa um tipo de lista ao objeto converterá o valor

seqüência de entrada a uma lista de um ou mais objetos. Se a XmlSchemaDatatype representa
uma união Digite então uma tentativa será feita para analisar o valor de entrada como um tipo
membro da união. Se falhar a tentativa de Análise depois a conversão é feita com o próximo
membro da união e assim por diante até que a conversão seja bem-sucedida, ou existem outros
tipos nenhum membro para tentar, nesse caso, uma exceção é gerada.
Diferenças entre CLR e tipos de dados XML
A seguir descreve determinadas diferenças que podem ocorrer entre tipos CLR e tipos de dados
XML e como eles são tratados.
Observação
O xs prefixo é mapeado para o http://www.w3.org/2001/XMLSchema e espaço para nome URI.
System.TimeSpan e xs:duration

O xs:duration tipo parcialmente é ordenado em que existem determinados valores de duração
que são diferente, porém equivalente. Isso significa que para o xs:duration tipo valor como 1 mês
(P1M) é menor que dias 32 (P32D), maiores que (P27D) dias 27 e equivalente a 28, 29 ou 30
dias.
A TimeSpan classe não oferece suporte parcial este pedido. Em vez disso, ele seleciona um
número específico de dias para 1 ano e mês 1; 365 dias e 30 dias respectivamente.
Para obter mais informações sobre o xs:duration tipo, consulte Part 2 do esquema XML do W3C:
recomendação tipos de dados em http://www.w3.org/TR/XMLSCHEMA-2/.
XS:Time, tipos Data gregoriano, e System.DateTime
Quando um xs:time valor é mapeado para um DateTime objeto, o MinValue campo é usado para
inicializar as Propriedades de Data do objeto DateTime (.,) com o menor valor possível DateTime,
como Year, Month e Day
Da mesma forma, instâncias de xs:gMonth, xs:gDay, xs:gYear, xs:gYearMonth e

xs:gMonthDay são também mapeados para um DateTime objeto. Propriedades não utilizadas no
objeto DateTime são inicializadas com os da MinValue.
Observação
Você não pode contar com o System.DateTime.Year Valor quando o conteúdo for digitado como
xs:gMonthDay. O System.DateTime.Year valor é sempre definido como 1904, nesse caso.
XS:anyURI e System.URI
Quando uma instância do xs:anyURI que representa um URI relativo é mapeado para um Uri, o
Uri objeto não tem um URI de base.
Consulte também
Conversão de tipos de dados XML

A maioria dos métodos encontrado na classe XmlConvert são usados para converter dados entre
seqüências e formatos digitada strongly-. Métodos são localidade independente. Isso significa que
que não faça levar em conta quaisquer configurações de localidade ao fazer a conversão.
String de leitura como tipos
O exemplo a seguir lê uma seqüência e os converte para um DateTime tipo.
Fornecido a entrada XML a seguir:
Entrada
<Element>2001-02-27T11:13:23</Element>
Esse código Converte a seqüência para o DateTime formato:
C#

reader.ReadStartElement(); DateTime vDateTime = XmlConvert.ToDateTime(reader.ReadString());
Console.WriteLine(vDateTime);
Seqüências de escrita como tipos
O seguinte exemplo leituras e o converte em uma seqüência. um Int32
Fornecido a entrada XML a seguir:
Entrada
<TestInt32>-2147483648</TestInt32>
Esse código converte o Int32: em um String
C#
Int32 vInt32=-2147483648; writer.WriteElementString("TestInt32",XmlConvert.ToString(vInt32));

Serviços da Web XML no código gerenciado
XML Web services fornecem a habilidade para trocar mensagens em um ambiente frouxamente
acoplado usando protocolos padrões tais como HTTP, XML, XSD, SOAP, e WSDL. As
mensagens podem ser estruturadas e digitadas ou vagamente definidas. Como protocolos
padrões servem como base para XML Web Services, seus aplicativos XML Web Services podem
se comunicar com uma ampla variedade de implementações, plataformas e dispositivos. Os
tópicos nesta seção Focam sobre como criar e implantar XML Web Services e como acessar XML
Web Services no código gerenciado. Consulte a lista abaixo para obter links para outros tópicos
que abordam XML Web Services.
Introdução à programação serviços XML da Web no código

gerenciado
XML Web Services tornam possível a troca de dados na forma de mensagens XML entre sistemas
heterogêneos. Embora a lógica de acesso remoto a dados e aplicativos é um novo conceito, é
moda fazer isso. tentativas anteriores, tais como DCOM, IIOP, e Java/RMI, exigiam uma forte
integração entre o cliente e o servidor e usavam formatos de dados binários expecíficos para a
plataforma e a implementação. Enquanto esses protocolos exigem uma tecnologia de
componentes particular ou convenção de chamada de objetos, XML Web Services não exigem. A
única suposição feita entre o cliente e o servidor é que destinatários irão entender as mensagens
que recebem. Em outras palavras, o cliente e servidor concordam em um contrato, nesse caso
descrito usando WSDL e XSD, e então comunicam gerando mensagens que horam o contrato
sobre um tranporte específico como HTTP. Como resultado, programas gravados em qualquer
linguagem, usando qualquer modelo de componente, e sendo executado em qualquer sistema
operacional pode acessar XML Web Services. Além disso, a flexibilidade de usar um formato de
texto como XML possibilita que a troca de mensagens para evolver com tempo de uma maneira
frouxamente acoplada. Estea coplamento frouxo é obrigatório em ambientes onde a atualização
simultânea de todas as partes na troca de mensagens não é possível.
Você cria XML Web Services usando a estrutura página ASP.NET, ativando esses XML Web
Services para acessar os muitos recursos da .NET Framework, tais como autenticação, cache, e
gerenciamento de estado. Como ASP.NET e o.NET Framework são a base para XML Web
Services no código gerenciado, os desenvolvedores podem se concentrar na criação ou acessar
XML Web Services sem precisar escrever código de infra-estrutura.
No modelo aplicativo ASP.NET, páginas da Web destinam-se ao uso do navegador da

extensão.aspx. Para diferenciar XML Web Services de páginas regulares ASP.NET, XML Web
Services usam a extensão.asmx.
Há duas funções fundamentais ao trabalhar com XML Web Services:
• Criar um XML Web Services — Quando você cria um XML Web Services, você está
criando um aplicativo que expõe a funcionalidade para clientes XML Web Services.
• Acessar um XML Web Services — Quando você acessa um XML Web Services, seu
aplicativo cliente localiza, referencia, e usa a funcionalidade contida em um XML Web Services
separado. O cliente de um XML Web Services é tipicamente um aplicativo que está apto a
enviar, receber e processar mensagens para e oriundas de XML Web Services. Entretanto, o
requisito mínimo é que o cliente deve ser capaz de enviar mensagens para o XML Web
Services. Isso inclui todos os aplicativos usando o .NET Framework.

XML Web Services pode ser aplicativos autônomos ou subcomponentes de maior um aplicativo da
Web. Por exemplo, suponha que você estiver criando um aplicativo da Web que vende Livros on-
line. Seu aplicativo da Web pode interagir com XML Web Services da seguinte forma:
• Criando um XML Web Services — Seu Aplicativo expõe sua ordem processando a lógica
como um XML Web Services, que seus Web sites afiliados podem usar em seus aplicativos da
Web para vender livros através de seu armazenamento on-line sem exigir que seus clientes
visitem seu site.
• Acessando um XML Web Service — Seu Aplicativo acessa um XML Web Services
fornecido por outra empresa on-line que é especializada em escrever e fornecer revisões de
livros para vendedores de livros on-line. Quando um visitante da sua loja on-line vê os detalhes
de um livro específico, eles também vêem as revisões desse livro na mesma página.
Lembre-se, XML Web Services podem ser acessados de praticamente qualquer outro tipo de
aplicativo, incluindo outros XML Web Services, aplicativos de Web, aplicativos Windows, e
aplicativos de console. O requisito mínimo é que o cliente deve ser capaz de enviar mensagens
para o XML Web Services.
Programação na Web com XML Web Services

XML Web Services permitem a troca de dados e a chamada remota da lógica de aplicativo usando
mensagens XML para mover dados através de firewalls e entre sistemas heterogêneos.
O Visual Studio fornece ferramentas para criação XML Web Services em ambos os códigos
gerenciados e não gerenciados. Para código gerenciado, Visual Studio torna possível para
desenvolvedores criar XML Web Services que totalmente aproveitem o poder do .NET
Framework. Além disso, Visual Studio também torna possível para desenvolvedores criar XML
Web Services usando Servidor ATL e C++ nativo.
XML Web Services criados no código gerenciado usam o modelo de aplicativo ASP.NET.
O Visual Studio simplifica o processo de localizar e acessar XML Web Services usando a noção
de referências da Web. Adicionando uma referência da Web a um aplicativo cliente resulta na
geração de uma classe proxy que serve como uma representação local do XML Web Services
com a qual o cliente pode interagir. Este recurso está disponível a aplicativos escritos no código
gerenciado ou não gerenciado. Ao adicionar uma referência da Web, o Visual Studio gera a classe
proxy no mesmo idioma de programação assim como o aplicativo cliente.
Aplicativos cliente XML Web Services criados no código gerenciado usam o modelo de
aplicativo ASP.NET.
Criando XML Web Services em código gerenciado

Você cria XML Web Services no código gerenciado usando a estrutura página ASP.NET
Framework. Você inicia criando um arquivo.asmx. Esse arquivo contém a diretiva WebService,
que identifica a classe pública que implementa a lógica XML Web Services. O classe de XML Web
Service contém um ou mais métodos públicos para exposição em um XML Web Services. Esses
métodos XML Web Services são prefaceados com o atributo WebMethod. ASP.NET trata infra-
estrutura para expor esses métodos como um XML Web Services. Para obter mais informações,
consulte Modelo de código para serviços Web XML no código gerenciado.
Para criar XML Web Services no código gerenciado usando o Visual Studio, você precisa acessar
um servidor Web configurado para desenvolver aplicativos ASP.NET. Você desenvolve XML Web
Services em código gerenciado em um servidor de desenvolvimento. Por padrão, o servidor de
desenvolvimento é o computador no qual você instalou o Visual Studio. Normalmente, você
desenvolve e contrói o projeto num servidor de desenvolvimento, para em seguida implantá-lo em
outro servidor (o servidor de implantação) que irá hospedar o XML Web Services. Entretanto, se
ocorrer desenvolvimento diretamente no servidor que hospedará o XML Web Services, o servidor
de desenvolvimento e implantação serão os mesmos.
Nesta seção
Modelo de código para XML Web Services no código gerenciado
Descreve o modelo de código usado pelos serviços da Web no código gerenciado.
Explorando conteúdo Serviço da Web XML
Descreve o conteúdo de um serviço da Web que você pode exibir em um navegador da

Web.
Criando projetos serviço da Web ASP.NET
Fornece instruções sobre como criar um XML Web Services usando o modelo de projeto
serviço da Web ASP.NET.
Adicionar um XML Web Service a um projeto da Web existente no código gerenciado
Fornece instruções sobre como adicionar um serviço da Web para um projeto da Web
existente.
Usando o atributo WebService
Fornece instruções sobre como aplicar o atributo

System.Web.Services.WebServiceAttribute.
Herança da classe WebService
Fornece instruções sobre como fazer herança da classe

System.Web.Services.WebService.
Criar um método serviço XML da Web
Fornece instruções sobre como criar um método exposto por um serviço da Web.
Usando o atributo WebMethod
Fornece instruções sobre como aplicar o atributo

System.Web.Services.WebMethodAttribute.
Depurando XML Web Services no código gerenciado
Fornece instruções sobre como depurar um serviço da Web usando métodos múltiplos.
Implantando XML Web Services em código gerenciado
Fornece instruções sobre como implantar um serviço da Web usando métodos variados.

Fornece links para vários tópicos XML Web Services.
Introdução à programação XML Web Services no código gerenciado
Descreve o paradigma de programação de serviços da Web.
Acessando XML Web Services no código gerenciado
Descreve o processo e fornece instruções sobre como acessar serviços da Web no código
gerenciado.
Personalizando mensagens SOAP
Descreve como personalizar mensagens SOAP, incluindo como trabalhar com vários
métodos de codificação XML.
Usando cabeçalhos SOAP
Descreve como utilizar cabeçalhos SOAP em XML Web Services criados usando
ASP.NET e como incluir informações adicionais com mensagens SOAP.
Criando XML Web Services usando ASP.NET
Fornece informações do .NET Framework SDK sobre criação de XML Web Services
usando ASP.NET.
Tratamento e inclusão de exceções nos XML Web Services
Descreve como tratar e incluir excessões em XML Web Services criados usando
ASP.NET.
XML Web Services criados com Servidor ATL
Descreve como criar, distribuir e consumir XML Web Services usando Servidor ATL e C++.
Acessando XML Web Services no código gerenciado

Um cliente XML Web Services é qualquer componente ou aplicativo que faz referência e usa um
XML Web Services. Não necessariamente isso precisará ser um aplicativo baseadas no cliente;
na verdade, em muitos casos seus clientes XML Web Services podem ser outros aplicativos da
Web, como formulários da Web ou mesmo outros XML Web Services.
Nesta seção
Modelo de código para acessar XML Web Services no código gerenciado
Descreve o processo de acesso a serviços da Web em código gerenciado.
Localizando XML Web Services
Fornece instruções sobre como localizar serviços da Web para acessar.
Gerando um proxy XML Web Service
Fornece instruções sobre como gerar uma classe proxy para um serviço da Web.

Acessando um serviço da Web XML no código gerenciado
Fornece instruções sobre como acessar um serviço da Web de um aplicativo cliente escrito
em código gerenciado.
Acessando assincronamente um XML Web Service em código gerenciado
Fornece instruções sobre como acessar de forma assíncrona um serviço da Web de um

aplicativo cliente escrito em código gerenciado.
Fornece um portal para toda documentação de serviços da Web.
Introdução à programação de XML Web Services em código gerenciado
Descreve o paradigma da programação de serviços da Web.
Criando XML Web Services em código gerenciado
Descreve o processo e fornece instruções sobre como criar serviços da Web em código
gerenciado.
Criando clientes XML Web Services
Descreve o processo e fornece instruções sobre criação de clientes XML Web Services.
Personalizando mensagens SOAP
Descreve como personalizar mensagens SOAP, incluindo como trabalhar com vários
métodos de codificação XML.
Descreve como utilizar cabeçalhos SOAP nos serviços da Web criados usando ASP.NET e
como incluir informações adicionais com mensagens SOAP.
How to: Access XML Web Services from a Browser
Fornece instruções sobre acessar serviços da Web ASP.NET em um navegador da Web

usando HTTP-GET, HTTP-POST e HTTP-SOAP.
XML Web Services criados com servidor ATL
Descreve o processo e provém instruções sobre como criar e acessar serviços da Web
usando um servido ATL e C++.
Criado usando clientes do serviço XML da Web ASP.NET e

Serviços XML da Web
Irrevocably nos últimos anos, uma força tem restyled a paisagem de desenvolvimento de
aplicativos mais de qualquer outro — na Internet. Organizações tornaram progressivamente

dependem dos recursos digital e canais de comunicação que são fornecidos pela Internet e
tecnologias relacionadas. Como resultado, muito poucos aplicativos são criados e desenvolvidos
que atualmente não fazer considerar como melhor para incorporar e aproveitar tecnologias da
Internet para totalmente dinamizar os benefícios da computação conectado.
Quando não pursuing totalmente novo desenvolvimento de aplicativos, as organizações podem

ser encontradas tentativa de criar aplicativos que agregar vários aplicativos tradicionais, orientado
tarefas-em um aplicativo simples, composto. Isso às vezes inclui integrar aplicativos que existe
dentro dos limites de uma entidade separada, como outra empresa ou um provedor de serviços.
No entanto, um dilema ainda maior surge quando tentam integrar aplicativos legados criado
usando uma variedade de tecnologias, modelos de objeto, sistemas operacionais, e linguagens de
programação. Como você tornar todos eles funcionam juntos? A resposta é a Internet
programável.
Extensible linguagem de marcação (XML) como um formato Descrição dados abertas tem
fornecidos aumento para a realidade de um Internet programável. Da mesma forma TCP / IP
fornecido conectividade universal para a Internet, e HTML fornecido um idioma padronizada para
exibir informações em uma grande variedade de plataformas para consumo humano, XML fornece
um idioma padronizada para trocar dados para consumo automatizado. Ele fornece a capacidade
para representar dados em um formato que permite que computadores para enviar e receber
dados em um estilo previsível, habilitando programabilidade que ultrapassa sistemas fechados,
controlado amplamente aceitos. XML é liberating porque sua simplicidade e extensibilidade
permite que você para definir quase tudo, permitindo sala para expansão. Uma dos blocos
construção fundamental da Internet programável é serviços XML da Web.
O Microsoft oferece suporte para criar serviços XML da Web, usando tecnologias projetado para
atender às necessidades de diferentes audiências. Especificamente, o Microsoft oferece aos
desenvolvedores a opção de criar os Serviços XML da Web usando ASP.NET, ATL Server,
sistema de interação remota.NET, e o 2.0 Toolkit SOAP. Remotos ASP.NET e.NET fazer Criando
Serviços XML da Web mais fácil, conforme eles são criados na parte superior do.NET Framework.
O 2.0 Toolkit SOAP fornece suporte serviços XML da Web compatível com a Microsoft Visual
Studio 6.0 e aplicativos herdados, permitindo que eles para fins de interoperabilidade com
serviços da Web XML construído sobre o .NET Framework.
Nesta seção
Visão geral do XML Web Services
Fornece uma visão geral neutra da plataforma dos XML Web Services.
XML Web Services Usando ASP.NET
Detalhes como criar serviços XML da Web, usando o ASP.NET.
Criando clientes XML Web Services
Detalhes como criar um cliente para um serviço XML da Web, independentemente da

plataforma ou tecnologia usada para criar do XML Web Service.
Tratamento e inclusão de exceções nos XML Web Services
Descreve como para lidar com exceções de um serviço XML da Web criados com clientes
serviço XML da Web ASP.NET e criados com o.NET Framework.

Detalhes como cabeçalhos SOAP pode ser definido, processada, e manipulados para
clientes chamar serviços XML da Web criados com ASP.NET.
Personalizando SOAP Message formatação
Descreve como para controlar o SOAP enviados para e do Serviços XML da Web criados
com ASP.NET.
Modificação de mensagens SOAP usando extensões SOAP
Explica como criar extensões Modifique a mensagem SOAP enviada através da rede para
serviços XML da Web criados com ASP.NET e seus clientes.
Descreve as etapas para criar um extensão do formato da descrição do serviço (SDFE).
Como personalizar a geração de descrições de serviço e classes proxy:
Fornece código de exemplo que define um extensão do formato da descrição do serviço.
Tipos de dados com suporte pelos serviços XML da Web criados usando ASP.NET
Lista os tipos de dados suporte para serviços XML da Web criados com ASP.NET.
Atributos para criados usando clientes do serviço XML da Web ASP.NET e Serviços da Web XML
Lista os atributos que podem ser aplicadas aos criados com clientes serviço XML da Web
ASP.NET e Serviços XML da Web.
Programação de rede
Mostra como usar classes de acesso a Internet para implementar ambos os aplicativos
baseados na Web e na Internet.
COMO: Acessar um Serviço da Web XML no Código Gerenciado
Acessando um XML Web Services a partir de código gerenciado é um processo simples. Primeiro,
você adiciona uma referência da Web no seu projeto para o XML Web Services que você deseja
acessar. A referência da Web cria uma classe proxy com métodos que servem como proxies para
cada método exposto do XML Web Services. Em seguida, você adiciona o namespace para a
referência da Web. Finalmente, você criar uma instância de classe proxy e acessar os métodos de
classe assim como acessaria os métodos de uma outra classe qualquer. Para obter mais
informações, consulte Modelo de Código para Acessar XML Web Services em Código
Gerenciado.
Por padrão, adicionar uma referência da Web adiciona também métodos para a classe proxy para
acessar o XML Web Services de forma assíncrona. Para obter mais informações, consulte
Acessar um XML Web Services de forma assíncrona em código gerenciado.
Para acessar um XML Web Services no código gerenciado

1. Crie o aplicativo a partir do qual você deseja acessar um XML Web Services. Este
aplicativo pode até ser outro XML Web Services.

2. Adicionar uma referência da Web para o XML Web Services com o qual seu aplicativo irá
interagir. Para obter instruções, consulte Adicionando e Removendo Referências da Web.
3. Crie uma instância do objeto do proxy em seu código cliente onde você deseja acessar o
XML Web Services.
4. Acesse os métodos do XML Web Services como você faria com qualquer outro
componente.
No código de exemplo abaixo, o aplicativo cliente (Application1) está acessando um XML
Web Services para o qual ele tem uma referência da Web (Converter) que contém uma
classe proxy (Service1), que possui um método (ConvertTemperature) para chamar o
XML Web Services. As duas linhas de código em negrito representam o código que é
necessário para acessar o XML Web Services.
C#
using System; namespace Application1 { class Class1 { static void Main() { Converter.Service1 cService
= new Converter.Service1(); Console.WriteLine("Temperature in degrees Fahrenheit: "); double
dFahrenheit = Convert.ToDouble(Console.ReadLine()); double dCelsius =
cService.ConvertTemperature(dFahrenheit); Console.Write("Temperature in degrees Celsius: ");
Console.WriteLine(dCelsius.ToString()); } } }
COMO: Acessar um Serviço da Web XML Assincronamente no Código Gerenciado
Cada método Web em uma classe proxy de serviço da Web possui uma cópia assíncrona. A
classe proxy gera automaticamente métodos assíncronos e um evento correspondente para cada
método Web. Quando o método assíncrono é chamado, ele é executado em outro segmento e
dispara o evento correspondente quando ele retorna. Você pode executar código quando um
método assíncrono retorna, através da criação de um manipulador para seus eventos
correspondentes.
Chamar um método Web de forma assíncrona com o Visual Basic

1. Declare uma instância da classe proxy de serviço da Web usando a palavra-chave
WithEvents, conforme mostrado abaixo:
Dim WithEvents myWebService As New Service1
Observação
O seu projeto deve conter uma referência da Web para o serviço da Web.
2. No editor de código, use a palavra-chave Handles para criar um manipulador de eventos

para o evento MethodCompleted, que corresponde ao método que você deseja chamar. Por
exemplo, se você estivesse chamando um método chamado HelloWorld assincronamente,
você deveria criar um método semelhante ao seguinte:
Private Sub HelloWorldComplete(ByVal sender As Object, _ ByVal completed As
localhost.HellowWorldCompletedEventArgs) _ Handles myWebService.HelloWorldCompleted ' Insert
code to implement the method here End Sub
Observe que o método que manipula o evento MethodCompleted deve corresponder a

assinatura do evento. Isso comumente exige um argumento Object para representar o
remetente, e uma instância do EventArgs do método, a qual consiste no mesmo namespace
que a classe proxy de serviço da Web. Você também pode usar o Code Editor para criar
automaticamente manipuladores de eventos para você. Para obter mais informações,
consulte How to: Create Event Handlers in the Visual Basic Code Editor.

3. Chame o método Web usando o formulário MethodAsync do método. Por exemplo, se
você estivesse chamando um método Web chamado HelloWorld assincronamente, ele
deveria ser da seguinte forma:
HelloWorldAsync
Observe que o valor de retorno do método está disponível na propriedade Result do

EventArgs.
Chamar um método Web de forma assíncrona com C#
1. Declare uma instância da classe proxy de serviço da Web, conforme mostrado abaixo:
private localhost.Service1 myWebService = new localhost.Service1 ();
Observação
O seu projeto deve conter uma referência da Web para o serviço da Web.
2. No Code Editor, adicione um manipulador para o evento MethodCompleted que

corresponde ao método que você deseja chamar. Por exemplo, se você estivesse
chamando um método chamado HelloWorld assincronamente, você deveria criar um
método semelhante ao seguinte:
private void HelloWorldCompleted(Object sender, localhost.HelloWorldCompletedEventArgs
Completed) { // Insert code to implement the method here }
Observe que o método que manipula o evento MethodCompleted deve corresponder a

assinatura do evento. Isso comumente exige um argumento Object para representar o
remetente e uma instância do EventArgs do método, a qual consiste no mesmo namespace
que a classe proxy de serviço da Web. Você também pode usar o Code Editor para criar
automaticamente manipuladores de eventos para você. Para obter mais informações,
consulte Como criar manipuladores de eventos no Editor de Código Visual C# (guia de
programação C#):.
3. No Construtor para a classe, adicione o manipulador de evento do MethodCompleted à
lista de manipuladores para tal evento, como mostrado abaixo:
private void Form1_Load(object sender, EventArgs e) { myWebService.HelloWorldCompleted += new
localhost.HelloWorldCompletedEventHandler(HelloWorldCompleted); }
4. Chame o método Web usando o formulário MethodAsync do método. Por exemplo, se

você estivesse chamando um método Web chamado HelloWorld assincronamente, ele
deveria ser da seguinte forma:
HelloWorldAsync();
Observe que o valor de retorno do método está disponível na propriedade Result do

EventArgs.
Como: Acessar XML Web Services de um navegador
Depois que você publicar um serviço da Web criados com ASP.NET, você pode testar sua
funcionalidade usando um navegador para chamar ele via o HTTP-GET ou HTTP-POST. Acessar
o arquivo.asmx em um navegador e clique em hiperlinks para os métodos Serviço da Web, ou
acessar métodos individuais diretamente, acrescentando uma seqüência de consulta a URL.asmx.
Observação

Por padrão, um serviço da Web criados com ASP.NET é capaz de oferecem suporte a vários
protocolos, incluindo SOAP sobre HTTP e implementações de HTTP-GET e HTTP-POST onde
SOAP XML não-é retornado em resposta.
Para testar um serviço da Web em um navegador usando HTTP-GET

1. Implantar o serviço da Web em um servidor Web. Para obter mais informações, consulte
Publicação serviço XML da Web e implantação.
2. Acessar um navegador da Web e digite a URL para o serviço da Web no endereço barra,
usando o seguinte formato:
http://servername/apppath/webservicename.asmx
Parte caminho Value (Valor)
servername O nome do servidor no qual o serviço da Web foi implantado.
Apppath O nome do seu diretório virtual e o restante do caminho do aplicativo da

Web.
webservicename.asmx O nome do arquivo.asmx Serviço da Web.
Por exemplo, suponha que você ter publicado um serviço da Web chamada StockServices.
When published, the base URL for this service is
http://<servername>/apppath/StockServices.asmx. You could test this service by entering
this HTTP-GET request in the browser's address bar:
http://<servername>/apppath/StockServices.asmx
O servidor, em resposta a essa solicitação, exibe página Descrição HTML o serviço da Web
na.
3. Página Descrição HTML a serviços da Web mostra todos os métodos Serviço da Web aos
quais um serviço da Web específico. Vincular ao método serviço Web desejado e insira os
parâmetros necessários para testar o método e receber a resposta XML.
Para diretamente teste um método de serviço da Web em um navegador usando HTTP-GET
Publicação serviço XML da Web e implantação.
2. Acessar um navegador da Web e digite o URL para o método de serviço da Web no
endereço barra, usando este formato:
http://servername/vdir/webservicename.asmx/Methodname?parameter=value
Parâmetro Value (Valor)
servername O nome do servidor no qual o serviço da Web for implantado.
Apppath O nome do seu diretório virtual e o restante do caminho do aplicativo da

Web.
webservicename.asmx O nome do arquivo.asmx Serviço da Web.

Methodname O nome de um método público que seja exposto pelo seu serviço Web.
Se deixar em branco, a Web página Descrição do serviço no é mostrada,
listando cada método público no arquivo.asmx disponíveis. (Opcional)
Parâmetro O parâmetro apropriado nome e valor para qualquer parâmetro exigido

pelo seu método. Se deixar em branco, a Web página Descrição do
serviço no é mostrada, listando cada método público no arquivo.asmx
disponíveis. (Opcional)
Observação
O nome do método Serviço da Web nessa sintaxe diferencia maiúsculas e minúsculas, mas não
são o servidor, projeto, e nomes de serviço da Web.
Por exemplo, suponha que o StockServices Serviço da Web do procedimento anterior contém
um método de serviço da Web chamado GetQuote; o método serviço Web aceita um símbolo
de ações como um parâmetro, retornando o preço como um número de ponto flutuante de
precisão dupla. Insira a solicitação HTTP-GET a seguir na barra Endereços do navegador
para testar esse método:
http://<servername>/apppath/StockServices.asmx/GetStockQuote?tickerName=MSFT
3. O servidor envia uma resposta contendo um documento XML, que é exibida no navegador.
Por exemplo GetQuote, o XML tem o preço atual de ações você solicitar. O resultado pode
aspecto como o seguinte:
<?xml version="1.0" ?>
<double>74.5</double>
Para testar um serviço da Web em um navegador usando HTTP-POST
Publicação serviço XML da Web e implantação. Este procedimento usa o seguinte serviço
da Web implantado como um math.asmx arquivo que seja acessível a partir da raiz virtual
de um http://www.contoso.com Site, como um exemplo:
C#
<%@ WebService Language="C#" Class="Math" %> using System.Web.Services; public class Math :
WebService { [ WebMethod ] public int Add(int num1, int num2) { return num1+num2; } [
WebMethod ] public int Subtract(int num1, int num2) { return num1-num2; } }
Visual Basic
<%@ WebService Language="VB" Class="Math" %> Imports System.Web.Services Public Class Math
Inherits WebService <WebMethod> _ Public Function Add(num1 As Integer, num2 As Integer) As
Integer Return num1 + num2 End Function <WebMethod> _ Public Function Subtract(num1 As
Integer, num2 As Integer) As Integer Return num1 - num2 End Function End Class
2. Crie uma página HTML com um formulário que tenha o method atributo definido como
POST. Use o seguinte formato:
<form method=POST action='http://www.contoso.com/math.asmx/Subtract'> <input type="text"
size="5" name='num1'\"></td> - <input type="text" size="5" name='num2'\"></td> = <input
type=submit value="Subtract"> </td> </form>

Parâmetro Value (Valor)
Método POST Se você desejar para testar seu serviço da Web usando HTTP-POST, use
POST.
AÇÃO URL para o método de serviço da Web. No exemplo anterior, math.asmx é o serviço
da Web e Subtract é o método Serviço da Web.
Tipo ="text" Para cada parâmetro do método Serviço da Web, criar input marcas com o atributo
Tipo definido como "text". Isso permite que você para digitar um valor de parâmetro
em Controle de entrada de texto.
Nome O nome do parâmetro método Serviço da Web. Adicionar quantos controles de

='num1' entrada de texto no formulário pois há parâmetros no método de serviço da Web.
Por exemplo, se um método de serviço da Web tiver três parâmetros, três controles
de entrada de texto são necessárias que cada ter seu name atributo definido como o
nome do parâmetro.
Tipo = Adicionar um botão Enviar para você pode enviar os dados de volta para o método
enviar serviço Web.
3. Acessar um navegador da Web e digite o URL para o documento HTML criado na etapa
anterior.
O documento HTML criado na etapa anterior é exibido.
4. Insira os valores apropriados para o método de serviço da Web nas caixas de texto e
clique no submit botão.
Por exemplo, e 3 se você inseriu 6 para as caixas dois texto para método Serviço da Web o
exemplo na Subtract, o seguinte resultado é retornado:
<?xml version="1.0" ?> <int xmlns="http://tempuri.org/">3</int>
Consulte também
COMO: Explorar conteúdo de Serviços da Web XML
O arquivo.asmx representa o ponto endereçável de entrada de XML Web Services criados com
código gerenciado. A maneira como você acessa esse arquivo via HTTP determina o tipo de
resposta recebida.
Página de Ajuda de Serviço
Quando chamado em um navegador da Web sem fornecimento de uma seqüência de caracteres

de consulta reconhecido, o arquivo.asmx retorna uma página de ajuda de serviço, gerada
automaticamente, para o XML Web Service. Isso é o equivalente a fazer um HTTP-GET no
arquivo.asmx.
Este método de Serviço ajuda a página a fornecer uma lista dos métodos fornecidos pelo XML
Web Service e que você pode acessar programaticamente. Esta página contém links para cada
método que levará você a informações adicionais sobre esse método. Além disso, esta página
contém um link para o documento de descrição do XML Web Service.

Acessar a Página de Ajuda de Serviço
• Na campo Endereço do navegador, digite o URL básico para o XML Web Service usando
este formato:
http://servername/projectname/xmlwebservicename.asmx
Parâmetro Valor
servername O servidor no qual o XML Web Service está instalado.
projectname Nome do projeto do seu XML Web Service e quaisquer informações

adicionais de diretório necessárias para acessar o arquivo.asmx para seu
XML Web Service.
webservicename.asmx O nome do arquivo.asmx para o XML Web Service.
Por exemplo, para acessar um XML Web Service chamado Service1.asmx, que faz parte de
um projeto chamado WebService1 em sua máquina local, você deve digitar o seguinte:
http://localhost/XmlWebService1/Service1.asmx
A página de ajuda de serviço do método fornece informações adicionais relacionadas àquele

método de XML Web Service específico.
A página fornece a possibilidade de chamar o método usando o protocolo HTTP-POST. O método

XML Web Service, no entanto, deve suportar o protocolo HTTP-POST para ativar essa
funcionalidade.
Na parte inferior da página, a página de ajuda de serviço do método fornece exemplos de

mensagens de solicitação e resposta para os protocolos que o método XML Web Service suporta.
Descrição do Serviço
A página de ajuda de serviço também fornece um link para a descrição de serviço do XML Web
Service, que é uma definição formal dos recursos do XML Web Service. A descrição de serviço é
um documento que usa a gramática WSDL (Web Services Description Language) (WSDL). A
descrição de serviço define o contrato para os formatos das mensagens que os clientes precisam
seguir para trocar mensagens com o XML Web Service. Para obter mais informações, consulte
Descrição do XML Web Service.
Acessar a descrição de serviço

• No campo Endereço do navegador, digite o URL básico para o XML Web Service e
forneça a seqüência de caracteres de consulta WSDL utilizando este formato:
http://servername/projectname/xmlwebservicename.asmx?WSDL
Parâmetro Valor
servername O servidor no qual o XML Web Service está instalado.

XML Web Service.

Por exemplo, para acessar a descrição de serviço de um XML Web Service chamado
Service1.asmx, que faz parte de um projeto chamado WebService1 em sua máquina local,
você deve digitar o seguinte:
http://localhost/XmlWebService1/Service1.asmx?WSDL
Acessando XML Web Services de um navegador da Web
Você pode acessar um XML Web Service que ofereça suporte ao protocolo HTTP-GET em um
navegador da Web. Por padrão, os XML Web Services que você cria no Visual Studio, usando o
modelo de projeto de Web Service ASP.NET, suportam HTTP-GET, HTTP-POST, e HTTP-SOAP.
Nem todos os protocolos podem oferecer suporte a todos os métodos. Em geral, os protocolos
HTTP-GET e HTTP-POST são mais restritos que o HTTP-SOAP, em relação aos tipos de dados
que eles suportam.
Acessar um XML Web Service de um navegador da Web
• Na campo Endereço do navegador, digite o URL básico para o XML Web Service com o
nome e parâmetros do método na seqüência de caracteres de consulta, usando o seguinte
formato:
http://servername/projectname/xmlwebservicename.asmx/methodname?parametername0=value0&par
ametername1=value1&...&parameternamen=valuen
Parâmetro Valor
servername O servidor no qual o XML Web Service está instalado

XML Web Service.
methodname O nome do método Web com diferenciação de letras maiúsculas de

minúsculas.
parametername Os nomes dos parâmetros do método da Web.
Valor Os valores codificados da URL de cada um dos parâmetros do método da

Web.
Por exemplo, para acessar o método ReturnThisString de um XML Web Service chamado
Service1.asmx, com um parâmetro chamado MyString definido com o valor de "This is my
test String", e que é parte de um projeto chamado WebService1 na sua máquina local, você
deve digitar o seguinte:
http://localhost/XmlWebService1/Service1.asmx/ReturnThisString?MyString=This+is+my+test+string
Consulte também

COMO: Criar Projetos de Serviço da Web ASP.NET
Você pode iniciar um projeto que inclui os arquivos necessários para criar um XML Web Services
em Visual Basic ou Visual C#, usando os modelos de projeto fornecidos pelo Visual Studio.
Para criar um projeto XML Web Services

1. No menu File, aponte para New, e clique Web Site.
2. Na caixa de diálogo New Web Site, selecione o ícone ASP.NET Web Service.
3. Digite o endereço do servidor Web no qual você irá desenvolver o XML Web Services. Por
exemplo, usar " http://MyServer/Application " ou " http://MyServer " simplesmente para
desenvolver o diretório raiz. Você também pode criar seu site no sistema de arquivos,
escolhendo um endereço arquivo, como " C:\Application "
4. Clique OK para criar o projeto.
O Visual Studio cria automaticamente os arquivos necessários e referências para suporte um XML
Web Services . Quando concluído, a IDE exibe o arquivo código de serviço no modo de exibição
de código. Para obter mais informações, consulte ASP.NET XML Web Service Basics.
Consulte também
COMO: Usar o Atributo WebService
Você pode usar o atributo WebService para especificar o namespace, que usa como padrão "
http://tempuri.org. " e o texto de descrição para o XML Web Services. Por padrão o modelo do
projeto de serviço da Web ASP.NET não gera uma classe que inclui este atributo. Separe
múltiplas propriedades com uma vírgula.
Aplicar o atributo WebService

• Insira o atributo WebService antes da declaração de classe e defina as propriedades
Namespace e Description como mostrado abaixo:
C#
[System.Web.Services.WebService( Namespace="http://servername/xmlwebservices/",
Description="Some descriptive text could go here.")] public class Service1 :
System.Web.Services.WebService { // Implementation code. }
COMO: Herdar da Classe WebService
Por padrão, XML Web Services criados usando o modelo de projeto serviço da Web ASP.NET
herdam da classe System.Web.Services.WebService. Herança dessa classe torna possível para o
XML Web Services acessar os objetos intrínsecos do ASP.NET, como Application e Sessão. Para
obter mais informações, consulte Inheritance in Visual Basic ou Herança (guia de programação
C#).
Observação
Se sua classe não herdar a partir da classe WebService, o criador de componente para o XML
Web Services não estará disponível.

Se o XML Web Services não herdar desta classe, ele pode acessar os objetos intrínsecos
ASP.NET a partir da propriedade System.Web.HttpContext.Current. Isso pode ser o caso quando
seu XML Web Services necessitar herdar de uma classe base personalizada. A classe que
implementar o XML Web Services deve ser pública e deve ter um construtor público padrão (um
construtor sem parâmetros). Isso torna possível para o ASP.NET criar uma instância da classe de
XML Web Service para processar solicitações XML Web Services de entrada.
Para herdar a partir da classe System.Web.Services.WebService

• Você pode herdar da classe System.Web.Services.WebService como mostra o exemplo
abaixo:
C#
public class Service1 : System.Web.Services.WebService { [System.Web.Services.WebMethod(
Description="Get SessionID", EnableSession=true)] public string GetSessionID() { return
this.Session.SessionID; } }
COMO: Criar um Método de Serviço da Web XML
Quando você cria um XML Web Services em código gerenciado, você indica os métodos que
estão disponíveis através daquele XML Web Services, colocando o atributo WebMethod antes da
declaração de método de um método Public. Métodos Private não podem servir como o ponto de
entrada para um XML Web Services, embora eles possam ser da mesma classe e o código do
XML Web Services poder chamá-los. O atributo WebMethod deve ser aplicado a cada método
público que estiver disponível como parte XML Web Services. Para obter mais informações,
consulte COMO: Usar o Atributo WebMethod.
Os procedimentos abaixo supõem que você está trabalhando com métodos públicos de uma
classe que é a implementação de um serviço XML Web. Para obter mais informações, consulte
Modelo de código para XML Web Services no código gerenciado.
Para criar um método de XML Web Services

1. Clique duas vezes no seu arquivo .vb ou .cs (por exemplo, Service1.vb ou Service1.cs)
no Solution Explorer para abrir o Editor de Código.
2. Adicionar um método público para a classe especificada na propriedade Class de diretiva
de processamento do arquivo WebService.asmx como mostrado abaixo:
C#
public class Service1 : System.Web.Services.WebService { [System.Web.Services.WebMethod()] public
double ConvertTemperature(double dFahrenheit) { return ((dFahrenheit - 32) * 5) / 9; } }
Anexar o atributo WebMethod a um método Public indica que você deseja o método
exposto como parte do XML Web Services. Para obter mais informações, consulte Modelo
de código para XML Web Services no código gerenciado.
COMO: Usar o Atributo WebMethod
Anexando o atributo WebMethod a um método Public indica que você deseja o método exposto
como parte do XML Web Service. Você também pode usar as propriedades deste atributo para
configurar o comportamento do método do XML Web Service. Para obter mais informações,
consulte Modelo de código para XML Web Services no código gerenciado.
O atributo WebMethod fornece as seguintes propriedades:
• BufferResponse

• CacheDuration
• Description
• EnableSession
• MessageName
• TransactionOption
BufferResponse
A propriedade BufferResponse do atributo WebMethod habilita o buffer de respostas para um

método do XML Web Service. Quando definida como true, a configuração padrão, o ASP.NET faz
um buffer inteiro da resposta antes de enviá-la para para o cliente. O buffer é muito eficiente e
ajuda a melhorar o desempenho, minimizando a comunicação entre o processo ativo e o processo
do IIS. Quando definida como false, o ASP.NET faz buffers da resposta em blocos de 16 KB.
Normalmente, você deve definir essa propriedade para false somente se você não quiser todo o
conteúdo da resposta na memória de uma só vez. Por exemplo, você está mandando de volta
uma coleção que está transmitindo seus itens a partir de um banco de dados. A menos que seja
especificado em contrário, o valor padrão é true. Para obter mais informações, consulte
Propriedade WebMethodAttribute.BufferResponse.
Fazendo um buffer da resposta de um método de XML Web Service
• Use a propriedade BufferResponse do atributo WebMethod, como mostrado abaixo:

C#
public class Service1 : System.Web.Services.WebService {
[System.Web.Services.WebMethod(BufferResponse=false)] public DataSet GetBigData() {
//implementation code } }
CacheDuration
A propriedadeCacheDuration do atributo WebMethod permite fazer um cache dos resultados

para um método de XML Web Service. O ASP.NET fará cache dos resultados para cada conjunto
único de parâmetros. O valor desta propriedade especifica o número de segundos que o ASP.NET
deve manter o cache dos resultados. Um valor de zero desativa o cache de resultados. A menos
que seja especificado em contrário, o valor padrão é zero. Para obter mais informações, consulte
Propriedade WebMethodAttribute.CacheDuration.
Armazenando em cache os resultados de um método de XML Web Service
• Use a propriedade CacheDuration do atributo WebMethod , como mostrado abaixo:

C#
[System.Web.Services.WebMethod(CacheDuration=60)] public double ConvertTemperature(double
dFahrenheit) { return ((dFahrenheit - 32) * 5) / 9; } }
Description
A propriedade Description do atributo WebMethod fornece uma descrição para um método de

XML Web Service que será exibido na página de ajuda do serviço. A menos que seja especificado
em contrário, o valor padrão é uma string vazia. Para obter mais informações, consulte
Propriedade WebMethodAttribute.Description.
Fornecendo uma descrição para um método de XML Web Service

• Use a propriedade Description do atributo WebMethod , como mostrado abaixo:
' Visual Basic Public Class Service1 Inherits System.Web.Services.WebService
<System.Web.Services.WebMethod( _ Description:="This method converts a temperature " & _ "in
degrees Fahrenheit to a temperature in degrees Celsius.")> _ Public Function ConvertTemperature(ByVal
dFahrenheit As Double) _ As Double ConvertTemperature = ((dFahrenheit - 32) * 5) / 9 End Function
End Class // C# public class Service1 : System.Web.Services.WebService {
[System.Web.Services.WebMethod( Description="Converts F to C a temperature in " + "degrees
Fahrenheit to a temperature in degrees Celsius.")] public double ConvertTemperature(double
dFahrenheit) { return ((dFahrenheit - 32) * 5) / 9; } }
EnableSession
A propriedade EnableSession do atributo WebMethod habilita o estado da sessão para um

método de XML Web Service. Uma vez ativada, o XML Web Service pode acessar a coleção de
estado da sessão diretamente do HttpContext.Current.Session ou com a propriedade
WebService.Session, se ela herda a partir da classe base WebService. A menos que seja
especificado em contrário, o valor padrão é false. Para obter mais informações, consulte
Propriedade WebMethodAttribute.EnableSession.
Ativando o estado da sessão em um método de XML Web Service
• Use a propriedade EnableSession do atributo WebMethod , como mostrado abaixo:

C#
[System.Web.Services.WebMethod(EnableSession=true)] public double ConvertTemperature(double
dFahrenheit) { Session["Conversions"] = (int) Session["Conversions"] + 1; return ((dFahrenheit - 32) * 5)
/ 9; } [System.Web.Services.WebMethod(EnableSession=true)] public int GetNumberOfConversions() {
return (int) Session["Conversions"]; } }
MessageName
A propriedade MessageName do atributo WebMethod permite o XML Web Service identificar

cada método sobrecarregado usando um alias. A menos que seja especificado em contrário, o
valor padrão é o nome do método. Ao especificar a propriedade MessageName, as mensagens
SOAP resultantes refletirão esse nome em vez do nome original do método. Para obter mais
informações, consulte Propriedade WebMethodAttribute.MessageName.
Fornecendo um nome de mensagem para um método de XML Web Service

• Use a propriedade MessageName do atributo WebMethod , como mostrado abaixo:
C#
[System.Web.Services.WebMethod(MessageName="AddDoubles")] public double Add(double
dValueOne, double dValueTwo) { return dValueOne + dValueTwo; }
[System.Web.Services.WebMethod(MessageName="AddIntegers")] public int Add(int iValueOne, int
iValueTwo) { return iValueOne + iValueTwo; } }
A mensagem de solicitação SOAP para o método que adiciona doubles, AddDoubles, será
semelhante a seguir:
POST /myWebService/Service1.asmx HTTP/1.1 Host: localhost Content-Type: text/xml; charset=utf-8
Content-Length: length SOAPAction: "http://tempuri.org/AddDoubles" <?xml version="1.0"

encoding="utf-8"?> <soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"> <soap:Body> <AddDoubles
xmlns="http://tempuri.org/"> <dValueOne>double</dValueOne> <dValueTwo>double</dValueTwo>
</AddDoubles> </soap:Body> </soap:Envelope> HTTP/1.1 200 OK Content-Type: text/xml;
charset=utf-8 Content-Length: length
A mensagem de resposta SOAP para o método que adiciona doubles, AddDoubles, será
semelhante a seguir:
<?xml version="1.0" encoding="utf-8"?> <soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"> <soap:Body> <AddDoublesResponse
xmlns="http://tempuri.org/"> <AddDoublesResult>double</AddDoublesResult>
</AddDoublesResponse> </soap:Body> </soap:Envelope>
TransactionOption
A propriedade TransactionOption do atributo WebMethod permite o método de XML Web

Service participar como o objeto raiz de uma transação. Apesar de você poder definir a
propriedade TransactionOption para qualquer valor da enumeração TransactionOption, um
método de XML Web service só possui dois comportamentos possíveis; ele não participa de uma
transação (Disabled, NotSupported, Supported), ou ele cria uma nova transação (Required,
RequiresNew). A menos que seja especificado em contrário, o valor padrão é
TransactionOption.Disabled. Para obter mais informações, consulte Propriedade
WebMethodAttribute.TransactionOption.
Além dos pré-requisitos para qualquer método de XML Web Service, você tem de adicionar uma
referência para System.EnterpriseServices.dll. Este namespace contém métodos e
propriedades que expõem o modelo de transação distribuída encontrado no serviços COM+ . A
classe System.EnterpriseServices.ContextUtil permite você votar na transação usando os
métodos SetComplete ou SetAbort. Para obter mais informações, consulte Participando de
transações nos XML Web Services criados com ASP.NET e Transações automáticas e XML Web
Services.
Criando uma nova transação com um método de XML Web Service

1. Adicione uma referência para System.EnterpriseServices.dll. Para obter mais
informações, consulte Adicionando e removendo referências.
2. Adicione o namespace System.EnterpriseServices ao XML Web Service, como mostrado
abaixo:
C#
3. Use a propriedade TransactionOption do atributo WebMethod, como mostrado abaixo:

C#
public class Service1 : System.Web.Services.WebService { [System.Web.Services.WebMethod(
TransactionOption=TransactionOption.RequiresNew)] public string DoSomethingTransactional() { //
The transaction was successful... ContextUtil.SetComplete(); return
ContextUtil.TransactionId.ToString(); } }

Como Depurar XML Web Services em Código Não Gerenciado
Quando você estiver pronto para compilar e executar seu XML Web Service, você deve
primeiramente compilar o projeto de serviço da Web ASP.NET. Depois de compilado, você pode
executar o XML Web Service. Para obter mais informações, consulte Preparação para Depuração:
Projetos de Serviço da Web ASP.NET.
Você pode escolher entre três métodos para compilar e executar seu XML Web Service:
Método Descrição
Com o Este método inicia o navegador padrão e carrega a página inicial especificada.
depurador Executar uma página no depurador possibilita que você navegue no código linha
por linha, e use ferramentas adicionais de análise e informação em tempo de
execução. Caso o Visual Studio detecte que os arquivos chave foram alterados, ele
também compilará o projeto antes iniciar o navegador com a página inicial
especificada.
Sem o Esse método possibilita que você possa executar seu código como ele normalmente
depurador seria executado fora do contexto das ferramentas de desenvolvimento, e, portanto,
nenhuma informação em tempo de execução estará disponível através dessas
ferramentas. Caso o Visual Studio detecte que os arquivos chave foram alterados,
ele compilará o projeto antes de iniciar o navegador com a página inicial
especificada. Entretanto, você pode anexar o depurador para o processo conforme
necessário.
Exibir no Este método compila o projeto e abre uma página da Web escolhida no Solution
navegador Explorer. O Visual Studio compila e executa o projeto em um navegador padrão
dentro do Visual Studio.
Compilar e executar um XML Web Service com o depurador

1. No Solution Explorer, clique com o botão direito do mouse no arquivo .asmx do XML Web
Service que você deseja executar, e clique Set As Start Page no menu de atalho.
2. No menu Debug, clique em Start.
Este comando instrui o Visual Studio a executar o XML Web Service no depurador.
3. Para interromper a execução do formulário e retornar ao Code Editor, feche o navegador,
ou clique em Stop Debugging no menuDebug.
Compilar e executar um XML Web Service sem o depurador
1. No Solution Explorer, clique com o botão direito do mouse no arquivo.asmx do XML Web
Service que você deseja executar, e clique Set As Start Page no menu de atalho.
O Visual Studio salva todos os arquivos no projeto e os compila. Uma vez compilados, o
Visual Studio inicia o navegador padrão e navega para a página inicial do projeto.
3. Para interromper a execução do XML Web Service e retornar ao Code Editor, feche o
navegador.
Compilar e executar um XML Web Service usando a opção View in Browser
1. No Solution Explorer, clique com o botão direito do mouse no arquivo.asmx do XML Web
Service que você deseja executar, e clique em View in Browser no menu de atalho.

O Visual Studio compila o XML Web Service e inicia a página inicial especificada dentro do
IDE.
2. Para interromper a execução do XML Web Service e retornar para o Code Editor, feche o
navegador.
COMO: Implantar Serviços da Web XML no Código Gerenciado
Quando se usa o Visual Studio .NET para criar XML Web Services no código gerenciado, você
usa um modelo de implantação padrão: você compila seu projeto e depois você implanta os
arquivos resultantes para um servidor de produção. O arquivo .dll do projeto contém o arquivo de
classe code-behind dos XML Web Services (.asmx.vb ou .asmx.cs) juntamente com todos os
outros arquivos de classe incluídos em seu projeto, mas não o próprio arquivo .asmx. Você então
implanta este arquivo .dll único do projeto para o servidor de produção sem qualquer código-fonte.
Quando o XML Web Services recebe uma solicitação, o arquivo .dll do projeto é carregado e
executado.
Compilando e implantando um XML Web Services no código gerenciado
Suponha que você tenha um simples projeto de serviço da Web ASP.NET chamado WebService1
que contém o seguinte:
• Uma página de entrada de XML Web Services denominada Service.asmx.

• Um arquivo de código nomeado Service.vb (ou .cs).
Quando você compila o projeto, ocorre o seguinte:
• O Visual Studio salva todos os arquivos no projeto que você modificou desde a última
compilação.
• O Visual Studio copia o arquivo Service1.asmx e os arquivos de projeto padrão para o
servidor Web de desenvolvimento.
• O arquivo de classe Service.vb (ou .cs) e o arquivo de classe Global.asax são compilados
no arquivo .dll do projeto, que então é copiado para o servidor no diretório padrão \bin do
diretório virtual de destino. Se o projeto for definido para compilar uma versão de depuração, o
Visual Studio cria um arquivo .pdb do projeto no diretório \bin.
Observação
Se ocorrerem erros de compilação, a implantação não terá êxito. Para obter mais informações,
consulte Como Depurar XML Web Services em Código Não Gerenciado.
Para implantar o XML Web Services em um servidor que não seja o servidor de desenvolvimento,
você pode adicionar um Web Setup project ou você pode copiar os arquivos necessários para o
servidor de destino. Para tornar seu XML Web Services disponível para outros, você precisará
implantá-lo em um servidor da Web que é acessível para os clientes que você deseja dar suporte.
Para obter mais informações, consulte Implantando aplicativos e componentes e COMO: Copiar
um projeto.
Implantar o XML Web Services através da cópia do projeto
1. No Solution Explorer, selecione o projeto que você deseja copiar.

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

3. Clique no ícone ao lado da caixa suspensa Connect to: para abrir a caixa de diálogo
Open Web Site.
4. Na caixa Open Web Site, selecione a localidade para a qual você deseja copiar o projeto.
5. Usando os ícones de seta, selecione arquivos do site da Web de origem para copiá-los
para o site da Web remoto.
6. Clique em Copy Web Site para copiar o site da Web.
Após implantar seu XML Web Services, você precisa levar em consideração como tornar possível
que desenvolvedores o localizem, caso você pretenda que outras pessoas o usem. Para obter
mais informações, consulte How to: Enable Discovery for XML Web Services.
COMO: Gerar um Proxy de Serviço da Web XML
Para acessar um XML Web Service de um aplicativo cliente, você primeiro adiciona uma
referência da Web, que é uma referência a um XML Web Service. Quando você cria uma
referência da Web, o Visual Studio cria uma classe proxy XML Web Service automaticamente e o
adiciona ao seu projeto. Esta classe do proxy expõe os métodos do XML Web Service e organiza
a transferência dos argumentos apropriados entre o XML Web service e o seu aplicativo. O Visual
Studio usa o WSDL (Web Services Description Language) (WSDL) para criar o proxy. Para obter
mais informações, consulte Infra-estrutura serviços XML da Web.
Você pode usar a propriedade URL da referência da Web para especificar a URL para o XML Web
Service. Ao adicionar uma referência da Web, essa propriedade é definida por padrão para o URL
do XML Web Service que você selecionou, que é um URL estático. Uma referência da Web pode
usar um URL estático ou um URL dinâmico. Se você definir a propriedade de comportamento URL
da referência da Web para dinâmico, o aplicativo obtém o URL em tempo de execução a partir da
seção AppSettings elemento (esquema configurações gerais) do arquivo de configuração do seu
aplicativo. Para obter mais informações, consulte Referências da Web.
Após adicionar uma referência da Web a um aplicativo cliente, você pode chamar os métodos
expostos do XML Web Services e acessar os resultados exatamente como você faria como
qualquer outro método de um componente. Para obter mais informações, consulte Como: Chamar
um serviço da Web.
Se você não conseguir adicionar uma referência da Web, quando por exemplo o XML Web service
não está acessível a partir da máquina em que você está usando o Visual Studio, você pode usar
a ferramenta XML Web Services Description Language Tool (Wsdl.exe) para gerar uma classe de
um proxy XML Web service cliente. Para obter mais informações, consulte Criando um proxy XML
Web service.
Como gerar uma classe de um proxy XML Web service
• Adicione uma referência da Web no seu projeto. Para obter mais informações, consulte
Como: Adicionar e remover referências da Web. Uma classe de um proxy é automaticamente
gerada e adicionada à sua solução, que então pode ser instanciada como uma outra classe
qualquer.
COMO: Criar um Cliente de Aplicativo de Console
Exemplo do código
Criar um aplicativo de console que atua como um cliente de serviços da Web é bem simples.
Depois que uma classe proxy for criada, uma nova instância da classe proxy pode ser criada,
contanto que ele seja acessível pelo aplicativo de console. A maneira mais fácil para torná-lo

acessível é para compilar a classe proxy em montagem para o aplicativo Console. Como
alternativa, a classe proxy podem ser compilado em um conjunto e implantado onde o aplicativo
Console possam acessá-lo.
Para criar um aplicativo cliente console Serviço da Web

1. Criar um proxy para o serviço da Web.
C#
Wsdl http://www.contoso.com/Counter.asmx?WSDL
Para obter mais informações, consulte Criando um proxy de serviço da Web XML.
2. Criar um aplicativo de console.
3. Criar uma instância da classe proxy em seu código do cliente.
C#
Counter myCounter = new Counter();
4. Chame o método da classe proxy que se comunica com o método de serviço da Web.
C#
UsageCount = counter.ServiceUsage();
5. Compilar o aplicativo Console em um executável. No exemplo a seguir, o aplicativo

Console foi salvo como UsageMonitor.
C#
csc /t:exe /r:System.Web.dll,System.XML.dll,System.Web.Services.dll UsageMonitor.cs Counter.cs
Exemplo
C#
using System; class UsageMonitor { public static void Main(string[] args) { int UsageCount; // Create an
instance of the Web service class. Counter myCounter = new Counter(); // Call the Web service method
ServiceUsage. UsageCount = myCounter.ServiceUsage(); // Output the results to the console. if (UsageCount
== 1) Console.WriteLine("Web service has been utilized >" + UsageCount.ToString() + "< time."); else
Console.WriteLine("Web service has been utilized >" + UsageCount.ToString() + "< times."); } }
COMO: Manipular Exceções Lançadas por um Método de Serviço da Web
O exemplo de código a seguir de um cliente chamar um método de serviço da Web captura um

SoapException acionada pelo método serviço Web. O cliente depois preenche uma Tabela HTML
com as propriedades do.For caught SoapException mais no tratamento falhas SOAP recebidas
por clientes de serviços da Web, consulte Tratamento e exceções Throwing nos Serviços XML da
Web.
Exemplo
C#
<%@ Import Namespace="System.Web.Services.Protocols" %> <%@ Import Namespace="System.Xml" %>
<%@ Page Language="C#" %> <html> <head> <script runat=server language=c#> void Page_Load(Object
o, EventArgs e){ // Create a new instance of the Web service proxy class. ThrowSoapException
throwSoapException = new ThrowSoapException(); // Make a call to the Web service method, which throws
an // exception. try { throwSoapException.myThrow(); } catch (SoapException error) { // Populate the table

with the exception details. ErrorTable.Rows.Add(BuildNewRow("Fault Code Namespace",
error.Code.Namespace)); ErrorTable.Rows.Add(BuildNewRow("Fault Code Name", error.Code.Name));
ErrorTable.Rows.Add(BuildNewRow( "SOAP Actor that threw Exception", error.Actor));
ErrorTable.Rows.Add(BuildNewRow("Error Message", error.Message));
ErrorTable.Rows.Add(BuildNewRow("Detail", HttpUtility.HtmlEncode(error.Detail.OuterXml))); return; } }
// This populates a row in an HtmlTable. HtmlTableRow BuildNewRow(string Cell1Text, string Cell2Text) {
HtmlTableRow row = new HtmlTableRow(); HtmlTableCell cell1 = new HtmlTableCell(); HtmlTableCell
cell2 = new HtmlTableCell(); //Set the contents of the two cells. cell1.Controls.Add(new
LiteralControl(Cell1Text)); //Add a cell to the row. row.Cells.Add(cell1); cell2.Controls.Add(new
LiteralControl(Cell2Text)); //Add a cell to the row. row.Cells.Add(cell2); return row; } </script> <head>
<body> <table id="ErrorTable" CellPadding=5 CellSpacing=0 Border="1" BorderColor="black"
runat="server" /> </body>
COMO: Implementar um Cliente Serviço da Web Assíncrono Usando a Técnica de Callback
A técnica de retorno de chamada é uma maneira para implementar um cliente do serviço da Web
para se comunicar com um método de serviço da Web de forma assíncrona, mesmo que o
método pode ser destinado a acesso assíncrono. A técnica é explicado no tópico comunicação
com Asynchronously serviços XML da Web.
Este exemplo for baseada em uma classe PrimeFactorizer de serviço da Web com um método
Factorize, para o qual a ferramenta WSDL.exe gerou dois métodos proxy cliente assíncrona,
BeginFactorize e EndFactorize.
Para implementar a técnica de retorno de chamada

1. Definir um função callback que implementa o delegado AsyncCallback.
C#
public static void FactorizeCallback(IAsyncResult ar)
2. Criar uma instância do AsyncCallback delegado.

C#
AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);
3. Chamar o método Begin, passando o função callback como o segundo argumento e um

objeto fornecendo estado (no neste exemplo, a implementação do cliente do
PrimeFactorizer) como o terceiro argumento.
C#
IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);
4. Verifique a propriedade IsCompleted em retornado pelo método Begin. o IAsyncResult O

valor é definido como true Depois o cliente tem recebeu uma resposta de um servidor.
5. Dentro do função callback, acessar o objeto estado. O IAsyncState parâmetro na
propriedade AsyncState possui o objeto passado como o terceiro parâmetro para o Begin
método.
C#
PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
6. Dentro do função callback, chame o método final sobre o objeto estado obtidos na etapa
anterior.

C#
long[] results = pf.EndFactorize(ar);
Exemplo
C#
using System; using System.Runtime.Remoting.Messaging; using MyFactorize; class TestCallback { public
static void Main(){ long factorizableNum = 12345; PrimeFactorizer pf = new PrimeFactorizer(); //Instantiate
an AsyncCallback delegate to use as a parameter //in the BeginFactorize method. AsyncCallback cb = new
AsyncCallback(TestCallback.FactorizeCallback); // Begin the Async call to Factorize, passing in our //
AsyncCalback delegate and a reference // to our instance of PrimeFactorizer. IAsyncResult ar =
pf.BeginFactorize(factorizableNum, cb, pf); // Keep track of the time it takes to complete the async call // as
the call proceeds. int start = DateTime.Now.Second; int currentSecond = start; while (!ar.IsCompleted){ if
(currentSecond < DateTime.Now.Second) { currentSecond = DateTime.Now.Second;
Console.WriteLine("Seconds Elapsed..." + (currentSecond - start).ToString() ); } } // Once the call has
completed, you need a method to ensure the // thread executing this Main function // doesn't complete prior
to the call-back function completing. Console.Write("Press Enter to quit"); int quitchar = Console.Read(); }
// Set up a call-back function that is invoked by the proxy class // when the asynchronous operation
completes. public static void FactorizeCallback(IAsyncResult ar) { // You passed in our instance of
PrimeFactorizer in the third // parameter to BeginFactorize, which is accessible in the // AsyncState
property. PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState; long[] results; // Get the completed results.
results = pf.EndFactorize(ar); //Output the results. Console.Write("12345 factors into: "); int j; for (j = 0;
j<results.Length;j++){ if (j == results.Length - 1) Console.WriteLine(results[j]); else Console.Write(results[j]
+ ", "); } } }
COMO: Implementar um Cliente Serviço da Web Assíncrono Usando a Técnica de Espera
A técnica de espera é uma maneira para implementar um cliente do serviço da Web para se
comunicar com um método de serviço da Web de forma assíncrona, mesmo que o método pode
ser destinado a acesso assíncrono. A técnica é explicado no tópico comunicação com
Asynchronously serviços XML da Web.
Este exemplo for baseada em uma classe PrimeFactorizer de serviço da Web com um método
Factorize, para o qual a ferramenta WSDL.exe gerou dois métodos proxy cliente assíncrona,
BeginFactorize e EndFactorize.
Para implementar a técnica de espera

1. O cliente de serviços da Web chama o Begin método da classe proxy gerado.
C#
IAsyncResult ar = pf.BeginFactorize(factorizableNum, null, null);
2. O cliente de serviços da Web acessa um WaitHandle objeto através da AsyncWaitHandle

propriedade do retornado IAsyncResult. O cliente chama um dos métodos de espera, a
WaitHandle classe e espera para um ou mais objetos de sincronização a ser sinalizado.
Se um cliente usa essa técnica para assincronamente chamar apenas um método de
serviço da Web, ele poderá chamar WaitOne para aguardar o processamento desse
método para concluir. Outros métodos espera são WaitAny e WaitAll.
C#

ar.AsyncWaitHandle.WaitOne();
3. Quando o método de espera retorna, o cliente chama o End método para obter os
resultados.
C#
results = pf.EndFactorize(ar);
Exemplo
C#
// -----------------------------------------------------------------------// Async Variation 2. // Asynchronously
invoke the Factorize method, //without specifying a call back. using System; using
System.Runtime.Remoting.Messaging; // MyFactorize, is the name of the namespace in which the proxy
class is // a member of for this sample. using MyFactorize; class TestCallback { public static void Main(){
long factorizableNum = 12345; PrimeFactorizer pf = new PrimeFactorizer(); // Begin the Async call to
Factorize. IAsyncResult ar = pf.BeginFactorize(factorizableNum, null, null); // Wait for the asynchronous
operation to complete. ar.AsyncWaitHandle.WaitOne(); // Get the completed results. long[] results; results =
pf.EndFactorize(ar); //Output the results. Console.Write("12345 factors into: "); int j; for (j = 0;
j<results.Length;j++){ if (j == results.Length - 1) Console.WriteLine(results[j]); else Console.Write(results[j]
+ ", "); } } }
Passo-a-passo: Redirecionando um Aplicativo para Apontar para um Serviço da Web XML

Diferente na Instalação
Esta explicação passo a passo demonstra como criar um aplicativo da Web que pode ser
redirecionado para alcançar um XML Web Services diferente usando a propriedade URL
Behavior, uma classe Installer, e um projeto de instalação da Web. Isso é útil quando você
precisa alcançar um XML Web Services localmente durante o desenvolvimento e deseja usar uma
versão de produção do XML Web Services quando seu aplicativo for implantado.
Observação
As caixas de diálogo e comandos de menu você vê pode diferir das descritas na Ajuda
dependendo das configurações ativas ou edição. Para alterar as configurações, escolha Import
and Export Settings no menu Tools. Para mais informações, consulte Configurações do Visual
Studio.
Criando o projeto de aplicativos da Web
A primeira etapa é criar um projeto de aplicativos da Web ASP.NET que contém uma referência
da Web para um XML Web Services.
Para criar o projeto
• Crie um aplicativo da Web que tenha uma referência da Web para um XML Web Services.
Uma referência da Web para qualquer XML Web Services válido bastará para esta explicação
passo a passo. Por exemplo, você pode usar o aplicativo da Web descrito em Passo-a-Passo:
acessando um XML Web Services utilizando Visual Basic ou Visual C#
Adicionando uma classe Installer

Classes Installer, também conhecidas como componentes de instalação, são classes .NET
Framework chamadas como ações personalizadas durante a instalação. Nesse caso, você
adicionará um projeto de biblioteca de classes à solução. Nesse projeto de biblioteca de classes,
você irá criar uma classe Installer e substituirá seu método Install, adicionando código para
modificar o aplicativo da Web do arquivo .config. Para obter mais informações sobre classes
Installer, consulte Introdução aos componentes de instalação.
Para criar o projeto de biblioteca de classes
1. Clique com o botão direito do mouse no nó solução no Solution Explorer e clique em

Add, em seguida clique em New Project.
2. Na caixa de diálogo Add New Project, no nó Visual Basic, selecione Class Library.
3. Nomeie o projeto InstallerClassLibrary.
Para adicionar e implementar uma classe Installer
1. Clique com o botão direito do mouse no nó de projeto InstallerClassLibrary no Solution

Explorer, e em seguida, clique em Add, e depois Class.
2. Na caixa de diálogo Add New Item, selecione Installer Class e altere o Name para
WebServiceInstaller.vb.
Quando você clicar em Add, a classe será adicionado ao projeto, e o designer para a classe
Installer abrirá.
3. Clique duas vezes no designer para abrir o editor de códigos.
4. No WebServiceInstaller.vb, adicione o seguinte código na parte inferior do módulo de
classe Installer (logo acima da declaração End Class); esse código implementa o método
Install:
Visual Basic
Public Overrides Sub Install(ByVal stateSaver As _ System.Collections.IDictionary) ' Gets the

parameter passed across in the CustomActionData. Dim installlog As New
System.IO.StreamWriter("Installation.log") installlog.AutoFlush = True Try Dim ProvidedName As
String = Me.Context.Parameters.Item("ServerName") Dim SvcName As String =
Me.Context.Parameters.Item("ServiceName") installlog.WriteLine("Starting Edit of the config file") If
ProvidedName = "" Or SvcName = "" Then Throw New InstallException("No arguments specified")
End If ' Uses reflection to find the location of the config file. Dim Asm As System.Reflection.Assembly
= _ System.Reflection.Assembly.GetExecutingAssembly Dim strConfigLoc As String strConfigLoc =
Asm.Location Dim strTemp As String strTemp = strConfigLoc strTemp =
strTemp.Remove(strTemp.LastIndexOf("\"), Len(strTemp) - _ strTemp.LastIndexOf("\")) strTemp =
strTemp.Remove(strTemp.LastIndexOf("\"), Len(strTemp) - _ strTemp.LastIndexOf("\")) Dim
FileInfo As System.IO.FileInfo = New System.IO.FileInfo( _ strTemp & "\web.config")
installlog.WriteLine("File info: " & strTemp) If Not FileInfo.Exists Then Throw New
InstallException("Missing config file") End If ' Loads the config file into the XML DOM. Dim
XmlDocument As New System.Xml.XmlDocument() XmlDocument.Load(FileInfo.FullName) ' Finds
the right node and change it to the new value. Dim Node As System.Xml.XmlNode Dim FoundIt As
Boolean = False For Each Node In _ XmlDocument.Item("configuration").Item("appSettings") ' Skips
any comments. If Node.Name = "add" Then If Node.Attributes.GetNamedItem("key").Value = _
"servername.service" Then ' Note that "Service1.asmx" should be replaced with the ' actual name of the
XML Web service file. Node.Attributes.GetNamedItem("value").Value = "http://" _ & ProvidedName

& "/" & SvcName & "/Service1.asmx" FoundIt = True End If End If Next Node If Not FoundIt Then
Throw New InstallException("Config file did not contain a ServerName section") End If ' Writes out
the new config file. XmlDocument.Save(FileInfo.FullName) Finally installlog.WriteLine("Ending edit
of config file") installlog.Close() End Try End Sub
O código acima primeiro cria um arquivo de log de instalação que irá gravar o andamento
de uma ação personalizada. O namespace System.Reflection é usado para localizar o
assembly que está sendo instalado e para localizar o arquivo .config associado. O modelo
de documento do XML é usado para fazer uma iteração através do arquivo .config até a
seção appSettings ser localizada. Quando a chave servername.service for encontrada, seu
valor associado é alterado para incluir os parâmetros que foram passados, redirecionando o
aplicativo para usar o novo XML Web Services.
5. No Solution Explorer, clique duas vezes no arquivo Web.config para abrí-lo.
6. Copie o valor da chave para seu XML Web Services na seção appSettings . A chave
assume a forma servername.service onde servername é o servidor onde o XML Web Services
está localizado, e service é o nome do XML Web Services.
7. Abra o módulo de classe Installer no editor de códigos e substitua o texto
"ServerName.Service" com o valor que você copiou na etapa anterior.
Adicione um projeto de instalação da Web
Projetos de instalação são usados para criar um instalador para o aplicativo. Baseados na
tecnologia do Windows Installer, projetos de instalação incluem recursos como a capacidade para
executar ações personalizadas durante a instalação e para personalizar a interface do usuário de
instalação. Para obter mais informações sobre projetos de instalação, consulte Implantando
aplicativos e componentes.
Para adicionar um projeto de instalação da Web
1. Clique com o botão direito do mouse no nó solução em Solution Explorer e clique em

Add, em seguida clique em New Project.
2. Na caixa de diálogo Add New Project, no painel Project Types, expanda o nó Other
Project Types, e selecione o nó Setup and Deployment Projects.
No painel Templates, selecione Web Setup Project. Na caixa Name, nomeie o projeto
WebAppSetup.
Quando você clicar em OK, o projeto será adicionado a solução e o File System Editor
será aberto.
3. Na janela Properties, selecione Propriedade ProductName e defina-a para o nome do seu
aplicativo da Web.
4. No File System Editor, marque Web Application Folder.
5. No menu Action, aponte para Add, e clique em Project Output.
6. Na caixa de diálogo Add Project Output Group, selecione InstallerClassLibrary da lista
suspensa Project; em seguida, selecione Primary Output.
Quando você clicar em OK, a saída principal da InstallerClassLibrary será adicionada ao
projeto de instalação da Web.
Adicionando uma ação personalizada
Ações personalizadas são usadas para executar código no final de uma instalação para executar
ações que não podem ser tratadas durante a instalação. O código para uma ação personalizada
pode estar contido em um arquivo .dll, .exe, script, ou assembly. Para mais informações sobre
ações personalizadas, consulte Gerenciamento ações na implantação personalizada.

Para adicionar a classe installer como uma ação personalizada
1. No Solution Explorer, selecione o projeto WebAppSetup.

2. No menu View, clique em Editor, e depois em Custom Actions.
O Custom Actions Editor abre.
3. No Custom Actions Editor, selecione o nó Install.
4. No menu Action, escolha Add Custom Action.
5. Clique duas vezes no Web Application Folder, e selecione Primary output from
InstallerClassLibrary (Active).
6. Na janela Properties, verifique se a propriedade InstallerClass está definida como True.
7. Selecione a propriedade CustomActionData e digite o texto a seguir:
/ServerName=[EDITA1] /ServiceName=[EDITA2]
A propriedade CustomActionData fornece os dois parâmetros que são passados para a
ação personalizada, separados por um espaço.
Adicionando uma caixa de diálogo
Caixas de diálogo de interface de usuário são exibidas durante a instalação para coletar
informações do usuário. Para obter mais informações sobre caixas de diálogo de interface de
usuário, consulte Gerenciamento de interface de usuário na implantação.
Para adicionar uma caixa de diálogo de interface de usuário personalizada
1. No Solution Explorer, selecione o projeto a instalação.

2. No menu View, aponte para Editor, e em seguida, clique em User Interface.
3. No User Interface Editor, selecione o nó Start em Install.
4. No menu Action, escolha Add Dialog.
5. Na caixa de diálogo Add Dialog, escolha a caixa de diálogo Textboxes (A) e clique em
OK.
6. No menu Action, escolha Move Up, e repita até o diálogo Textboxes (A) estar localizado
acima do diálogo Installation Address.
7. Na janela Properties, defina as seguintes propriedades:
Propriedade Valor
BannerText Digite o nome do servidor e o nome do serviço
Edit1Label Nome do servidor:
Edit1Value LocalHost
Observação
Isso especifica um servidor padrão. Você pode inserir seu próprio nome de
servidor padrão aqui.

Edit2Label Nome do serviço:
Edit2Value <nome do serviço>
Edit3Visible False
Edit4Visible False
8. Observe que a propriedade Edit1Property está definida como "EDITA1" e a propriedade

Edit2Property está definida como "EDITA2". Isso corresponde aos valores que você inseriu
na propriedade CustomActionData no Custom Actions Editor. Quando o usuário insere
texto nesses controles de edição durante a instalação, os valores são passados
automaticamente por meio da propriedade CustomActionData.
Criando e implantando o aplicativo
A etapa final é criar o projeto de instalação para criar o instalador, e para instalar o aplicativo no
servidor de destino.
Para criar o projeto de instalação
• No menu Build, escolha Build Projectname, onde Projectname é o nome do seu projeto
de instalação.
Para implantar o aplicativo em um servidor Web no seu computador de desenvolvimento
1. No Solution Explorer, selecione o projeto a instalação.

2. No menu Project, clique em Install.
Para implantar o aplicativo em um servidor Web em outro computador
1. No Windows Explorer, navegue até o diretório de projeto e localize o instalador criado. O

caminho padrão será \documents and settings\ yourloginname\My Documents\Visual Studio
Projects\setupprojectname\project configuration\productname.msi O project configuration
padrão é Debug.
2. Copie o arquivo .msi e todos os outros arquivos e subpastas no diretório para o
computador do servidor Web.
3. No computador do servidor Web, clique duas vezes no arquivo Setup.exe para executar o
instalador.
Protegendo Serviços da Web XML Criados Usando ASP.NET

Decidir qual implementação de segurança é melhor para um serviço da Web começa com olhando
para dois princípios de segurança de chave: Autenticação e autorização. Autenticação é o
processo de validar uma identidade com base nas credenciais, como um nome de usuário e
senha, contra uma autoridade. Quando uma identidade tiver sido autenticado, autorização
determina se a identidade está autorizado a acessar um recurso.
Serviços da Web criados com ASP.NET pode escolher as opções de segurança da autenticação e
autorização opções oferecidas pelo ASP.NET ou personalizado de segurança baseada em SOAP-
. ASP.NET funciona em conjunto com Internet Information Services (IIS) para fornecer
autenticação e autorização várias opções. Também é possível para criar opções de autenticação

personalizado, como o uso de cabeçalhos SOAP. Além disso, o ASP.NET oferece a capacidade,
conhecida como representação, para executar uma solicitação usando as credenciais do cliente.
Para obter mais informações sobre como usar a representação, consulte Representação
ASP.NET.
Este tópico resume as opções disponíveis para serviços da Web criados com ASP.NET
autenticação e autorização. Para obter mais informações sobre opções de segurança disponíveis
para aplicativos da Web ASP.NET, consulte Proteger Aplicativos da Web ASP.NET Como Criando
aplicativos ASP.NET seguros: autenticação, autorização e comunicação seguraSegurança de
aplicativos da Web ASP.NET.
Para obter mais informações sobre como acessar recursos remotos de aplicativos-baseado em
ASP.NET, consulte os tópicos " modelo Impersonation / Delegation " e confiáveis modelo
subsistema " " no capítulo 3 de Criando aplicativos ASP.NET Seguros.
Opções de autenticação para serviços XML da Web
Serviços da Web criados com ASP.NET tem várias opções para autenticar clientes, portanto, é a
pergunta grande: qual um for da direita para um serviço da Web específico? Para escolher a
opção Segurança direita, uma das coisas para escolher entre um desenvolvedor tem é o nível de
segurança e desempenho. Para alguns serviços da Web, é essencial que credenciais cliente são
enviados através da rede usando criptografia, portanto, um algoritmo que criptografa as
credenciais do cliente é essencial. Por exemplo, um desenvolvedor gravar um serviço da Web que
processa cartões de crédito provavelmente worries mais sobre as credenciais do cliente seja
roubado que a sobrecarga extra de criptografar os dados de cartão de crédito.
A tabela a seguir é um resumo das opções de autenticação disponíveis para serviços da Web
criado com o ASP.NET. Opções prefixo com o Windows são uma parte das opções de
autenticação Windows disponíveis para serviços da Web criados com ASP.NET.
Resumo das opções de autenticação
Opção de
autenticação Descrição
Windows-Basic Use para identificação não seguros de clientes, como o nome de usuário e
senha são enviados em Base seqüências codificado 64-em texto sem
formatação. Senhas e nomes de usuário são codificado, mas não
criptografados, neste tipo de autenticação. Um usuário determinado, mal-
intencionado equipado com uma ferramenta monitoramento de rede-pode
interceptar nomes de usuário e senhas.
Windows-Basic via Use para identificação dos clientes em cenários de Internet seguros. O nome
SSL de usuário e senha são enviados através da rede usando criptografia Layer
(SSL) soquetes Segurança, em vez de texto sem formatação. Este é
relativamente fácil para configurar e funciona para cenários de Internet. No
entanto, usando SSL diminui o desempenho.
Windows-Digest Use para identificação dos clientes em cenários de Internet seguros.

Desmarque usa hash para transmitir credenciais cliente de uma maneira
criptografado para a senha não são transmitidos em texto. Além disso,
autenticação Digest pode trabalhar através de servidores proxy. No entanto,
ele é suporte em outras plataformas não amplamente.

Windows- Usa NTLM ou Kerberos. Usa uma troca criptográfica com navegador da Web
Integrada do Microsoft Internet Explorer do usuário.
Windows
Windows- Usar para identificação dos clientes na Internet e intranet seguras cenários.
certificados de Requer cada cliente para obter um certificado de um autoridade de
cliente certificação mutuamente confiável. Certificados opcionalmente são mapeados
para contas de usuário, que são usadas pelo IIS para autorizar acesso ao
serviço da Web.
Formulários Não suporte para serviços da Web. Isso é um sistema pelo qual as
solicitações não autenticadas são redirecionadas para um formulário HTML
utilizando o redirecionamento do lado do cliente HTTP. A maioria dos clientes
de serviços da Web não será deseja fornecer credenciais usando uma
interface; você deve resolver isso se você desejar usar a autenticação de
formulários.
SOAP cabeçalhos Útil para cenários de Internet seguros e não seguras. Credenciais de usuário
– personalizados são passados no cabeçalho SOAP da mensagem SOAP. O servidor Web,
independentemente da plataforma que hospeda o serviço da Web, fornece
uma implementação de autenticação personalizado.
Para todas as opções listadas acima, exceto o uso de cabeçalhos SOAP, as configurações de
segurança são especificadas usando uma combinação de arquivos de configuração e o IIS. Para
obter mais informações sobre arquivos de configuração, consulte ASP.NET Configuration. A
opção cabeçalhos SOAP personalizados é detalhado seguinte na seção Autorização como essa
solução envolve a autenticação e autorização.
A autenticação do Windows
O IIS e ASP.NET fornecem suporte para autenticar aplicativos da Web, incluindo serviços da Web,
usando segurança criado na para Windows. Windows fornece três opções para autenticação:
BASIC, Digest e integrada do Windows. Além disso, cada opção pode ser usada com SSL. Como
todos os Windows autenticação opções exceto Basic criptografar os dados em algum formulário, o
nível de criptografia oferecidos pelo SSL adicionais normalmente somente usada em juntamente
com Basic ou certificados de cliente.
Independentemente do que opção autenticação Windows é usada, os procedimentos para

configurar o serviço da Web e cliente serviço Web são semelhantes. Para obter mais informações,
consulte Como configurar um serviço da Web XML para a autenticação do Windows:. Nenhum
código precisa para ser adicionado ao um serviço da Web para usar a autenticação do Windows,
como as opções de autenticação são definidas em um arquivo de configuração e do IIS. Código
para passar o cliente credenciais para o serviço da Web deve ser adicionado a um cliente de
serviços da Web.
Se SSL for escolhido como parte do mecanismo de autenticação usado por um serviço da Web,
SSL precisará ser configurado para o aplicativo da Web que hospeda o serviço da Web ou para o
serviço da Web propriamente dito, usando o IIS. O descrição do serviço e, conseqüentemente,
proxy classes gerado a partir do descrição do serviço refletirá que o serviço da Web usa SSL (se o
descrição do serviço e página Ajuda serviço são acessados usando SSL). Será a URL para o
serviço da Web dentro do descrição do serviço ser prefixados com HTTPS. Para obter mais
informações sobre como configurar a SSL, consulte a documentação do IIS.

Autenticação de certificado de cliente
Certificados de cliente ajudam a fornecer um mecanismo seguro para autenticação, como clientes
são necessários para enviar um documento eletrônico, chamado um certificado de cliente, que
identifica um cliente usando uma conexão SSL para o servidor Web. A conexão SSL criptografa
as credenciais do cliente contido o certificado de cliente como eles são enviados através da rede.
Comunicação entre o cliente e o servidor Web é criptografada usando uma combinação das
chaves de criptografia enviadas pelo cliente e teclas fornecidos pelo servidor Web. Assim que a
comunicação for estabelecida, somente os computadores cliente e servidor poderão se comunicar
uns aos outros usando essa conexão SSL.
Um certificado de cliente pode ser obtido de um autoridade de certificação, que pode ser o
servidor Web próprio ou um intermediário confiável entre o cliente e servidor. Depois que um
certificado tenha sido obtido, e o servidor Web foi configurado para aceitar certificados de cliente,
um cliente pode enviar o certificado de cliente para o servidor Web através de uma conexão SSL,
quando um serviço da Web é chamado. Para obter mais informações sobre certificados de cliente,
consulte a documentação do IIS. Para obter mais informações sobre como configurar autenticação
de Certificado de Cliente para um serviço da Web, consulte Como configurar um serviço da Web
XML para a autenticação do Windows:.
Opções de autorização para serviços XML da Web
O objetivo de autorização é para determinar se uma identidade deve ser concedido o tipo de
acesso a determinado recurso solicitado. Existem duas maneiras fundamentais para autorizar
acesso a um determinado recurso: arquivo autorização e a autorização de URLs. Autorização
arquivo pode ser usado sempre que a autenticação do Windows for utilizado, como as permissões
são definidas no IIS em uma base por arquivo. A autorização de URL pode ser usado com
qualquer dos mecanismos autenticação interna Suporte ao ASP.NET Com a autorização de URLs,
configuração é feito através de um arquivo de configuração, onde os usuários podem ser
seletivamente concedidas ou acesso negado a quaisquer arquivos associados ao ASP.NET,
inclusive arquivos.asmx.
Para obter mais informações sobre como configurar autorização em uma base por arquivos,
consulte a documentação do IIS.
Para obter mais informações sobre como configurar autorização usando um arquivo de
configuração, consulte Autorização ASP.NET.
Autenticação usando cabeçalhos SOAP personalizados
Os mecanismos de autenticação do Windows, incluindo certificados de cliente, contam com o

transporte HTTP, enquanto SOAP é independente de transporte-. Serviços da Web criados com
ASP.NET usam SOAP sobre HTTP,, bem como HTTP-POST e implementações HTTP-GET que
retornam documentos XML SOAP não-. Portanto, um motivo para criar um mecanismo de
autenticação personalizado é para decouple a autenticação a partir do transporte. Isso pode ser
feito, passando as credenciais de autenticação no cabeçalho SOAP.
Cabeçalhos SOAP são uma ótima maneira de passar fora de banda ou informações não
relacionado à semântica de um serviço da Web. Diferentemente o Body elemento de um SOAP
mensagem, que inclui a em e sem parâmetros para a Web operação de serviço que são
processados pelo método Serviço da Web, o Header elemento é opcional e pode assim ser
processada pelo infra-estrutura. Isto é, processados pelo infra-estrutura desenvolvido para
fornecer um mecanismo de autenticação personalizada.
Para obter uma descrição de um método de usando cabeçalhos SOAP para autenticação,
consulte Como executar autenticação personalizada usando cabeçalhos SOAP:.

Um cliente de serviços da Web para usar cabeçalhos SOAP para autenticação, deseja enviar suas
credenciais para o serviço da Web, adicionando o cabeçalho SOAP esperado à solicitação SOAP
e preenchendo-lo com as credenciais do cliente. Para usar autenticação cabeçalho SOAP, um
serviço da Web deve seguir duas coisas: especificar que espera o cabeçalho SOAP que contém
as credenciais de autenticação e autorizar o acesso do cliente para o serviço da Web.

Acesso a Dados (Como fazer em C#)
Os links desta página ajudam nas tarefas de acesso a dados amplamente usadas. Para ver outras
categorias de tarefas comuns abordadas na Ajuda, consulte Como fazer em C#.
COMO: Instalar Bancos de Dados de Exemplo
Muitos tópicos do Visual Studio e exemplos de código requerem a capacidade de se conectar a

um banco de dados, como o banco de dados de exemplo Northwind. Se você estiver executando
o SQL Server e o banco de dados Northwind não estiver disponível, então consulte o SQL Books
Online para obter informações sobre como instalá-lo. Se você não tem uma cópia do SQL Server,
então você pode acessar os bancos de dados de exemplo instalando o SQL Server Express
(SSE), ou uma versão Access do Northwind.
Observação
As caixas de diálogo e comandos de menu que você ver, podem diferir daquelas descritas no Help
dependendo da sua configuração ativa ou edição. Para alterar as configurações, escolha Import
and Export Settings no menu Tools. Para obter mais informações, consulte Visual Studio
Settings.
Para instalar o banco de dados de exemplo Northwind do Microsoft Access

1. No Windows, abra o Internet Explorer.
2. Navegue até a seguinte URL:
http://www.microsoft.com/downloads/details.aspx?familyid=c6661372-8dbe-422b-8676-
c632d66c529c&displaylang=en(Access 2000 Tutorial: Northwind Traders Sample Database)
3. Clique no botão Download.
4. Na caixa File Download, escolha Save This File Now e clique em OK.
5. Depois de descarregar o arquivo, clique duas vezes no arquivo Nwind.exe para instalar o
banco de dados.
Para instalar os bancos de dados de exemplo Northwind e Pubs para o SQL Server
http://www.microsoft.com/downloads/details.aspx?FamilyID=06616212-0356-46a0-8da2-
eebc53a68034&DisplayLang=en (Northwind and Pubs Sample Databases)
banco de dados.
Para instalar os bancos de dados de exemplo Adventure Works para o SQL Server 2000
http://www.microsoft.com/downloads/details.aspx?familyid=487C9C23-2356-436E-94A8-
2BFB66F0ABDC&displaylang=en (Adventure Works Cycles Database 2000)
banco de dados.
Para baixar e instalar o SQL Server Express
2. Navegue até a seguinte URL: http://www.microsoft.com/downloads (Microsoft Download
Center)
3. No campo Keywords, digite SQL Server Express.
4. Clique em Go.
5. Na página de resultados, siga o link para a página de download do SQL Server Express e
siga as instruções.
Segurança
Sempre verifique se há atualizações do produto ao instalar um software adicional.
Passo a passo: Criando um aplicativo de dados simples
Uma dos cenários mais comuns no desenvolvimento de aplicativos é exibir dados de um banco de
dados em um Windows Form. Você pode exibir dados em formulários em aplicativos Windows,
arrastando itens da Janela de fontes de dados em seu formulário. Esta explicação passo a passo
demonstra como criar um aplicativo que exiba dados de duas tabelas relacionadas em um banco
de dados.
Observação
As caixas de diálogo e comandos de menu que você vê podem diferir das descritas na Ajuda
dependendo de suas configurações ativas. Para alterar as configurações, escolha Import and
Export Settings no menu Tools. Para obter mais informações, consulte Visual Studio Settings.
As tarefas ilustradas nesta explicação passo a passo incluem:
• Criando um aplicativo Windows.

• Criando e configurando um dataset em seu aplicativo baseado nas tabelas Customers e
Orders do banco de dados Northwind usando o Assistente para Configuração da Fonte de
Dados
• Adicionando controles para exibir dados da tabela Customers.
• Adicione os controles para exibir os Orders baseado na seleção dos Customer
• Testando o aplicativo, selecione diferentes clientes e verifique se os pedidos corretos são
exibidos para o cliente selecionado.
Pré-requisitos
A fim de concluir esta explicação passo a passo, será necessário:
• Acesso ao banco de dados de exemplo Northwind. Para configurar bancos de dados de

exemplo, consulte COMO: Instalar Bancos de Dados de Exemplo.
Criando o Projeto
A primeira etapa é para criar um projeto Windows Application.

Para criar o projeto
1. No menu File, criar um novo projeto.

2. Selecione Windows Application e nomeie com DataWalkthrough. Para obter mais
informações, consulte Creating Windows-based Applications.
3. Clique em OK.
O projeto DataWalkthrough é criado e adicionado Solution Explorer.
Criando a fonte de dados
Esta etapa cria um dataset com base nas tabelas Customers e Orders do banco de dados de
exemplo Northwind.
Para criar a fonte de dados
1. No menu Data, clique em Show Data Sources.

2. Na janela Data Sources, clique em Add New Data Source para iniciar o assistente Data
Source Configuration.
3. Selecione Database na página Choose a Data Source Type, e clique Next.
4. Na página Choose your Data Connection siga um destes procedimentos:
o Se uma conexão de dados para o banco de dados de exemplo Northwind estiver
disponível na lista suspensa, selecione-a.
Ou-
o Selecione New Connection para iniciar a caixa Add/Modify Connection. Para
obter mais informações, consulte Add/Modify Connection Dialog Box (General).
5. Se seu banco de dados exigir uma senha, selecione a opção para incluir dados
confidenciais, e clique Next.
6. Clique Next na página Save connection string to the Application Configuration file.
7. Expanda o nó Tables na página Choose your Database Objects.
8. Selecione as tabelas Customers e Orders, e clique Finish
O NorthwindDataSet é adicionado ao seu projeto e as tabelas Customers e Orders
aparecem na janela Data Sources.
Criando controles para exibir dados da tabela de Clientes
Para criar os controles para exibir os dados do cliente (registros pai)
1. Na janela Data Sources, selecione a tabela Customers, e clique na seta suspensa.

2. Selecione Details na lista de controle da tabela Customer.
3. Arraste o nó principal Customers da janela Data Sources no Form1.
Os controles com dados vinculados com rótulos descritivos aparecem no formulário,
juntamente com uma faixa da ferramenta. (BindingNavigator) para navegar pelos registros.
O NorthwindDataSet, CustomersTableAdapter, BindingSource, e BindingNavigator
aparecem na bandeja de componentes.
Criando controles para exibir dados da tabela Pedidos
Criando os controles para exibir os pedidos para cada cliente (registros filho)
• Na janela Data Sources, expanda o nó Customers e selecione a última coluna na tabela
Customers, que é um nó expansível Orders sob a coluna Fax, e arraste-o para a parte inferior

do Form1. (Este nó na hierarquia da tabela Customers representa os pedidos relacionados
para um cliente, como contrário para o nó principal Orders, que representa todos os registros
da tabela Orders e não os pedidos para um cliente individual.)
O DataGridView é adicionado ao formulário, e um novo componente BindingSource
(OrdersBindingSource) e um TableAdapter (OrdersTableAdapter) são adicionados à
bandeja de componentes.
Observação
Abra a janela Properties e selecione o componente OrdersBindingSource. Inspecione o

DataSource e as propriedades DataMember para ver como a vinculação de dados está
configurada para exibir os registros relacionados. O DataSource é definida como
CustomersBindingSource (a tabela pai BindingSource), em oposição a tabela Orders. A
propriedade DataMember é definida como FK_Orders_Customers, que é o nome do objeto
DataRelation que relaciona as tabelas uma com a outra.
Testando o aplicativo
Para testar o aplicativo
1. Pressione F5.
2. Selecione diferentes clientes para verificar se os pedidos corretos são exibidos na grade
do formulário.
Próximas etapas
Dependendo dos seus requisitos para o aplicativo, existem várias etapas que você pode desejar
executar após criar um formulário de detalhes mestre. Você pode fazer nesta explicação passo a
passo alguns aprimoramentos, que incluem:
• Editar a consulta que carrega os dados para o aplicativo com os assistentes TableAdapter.
Para obter mais informações, e Como editar TableAdapters:. ver Como: Editar consultas do
TableAdapter,
• Adicionar a validação para verificar se os dados corretos estão sendo inseridos, antes de
enviar as alterações para o banco de dados. Para obter mais informações, consulte Validando
dados.
Visão geral sobre como conectar-se a dados no Visual Studio

O Visual Studio fornece ferramentas para conectar seu aplicativo a dados de várias fontes
diferentes, como bancos de dados, serviços da Web, e objetos. Se você estiver usando
ferramentas de design de dados no Visual Studio, você freqüentemente não precisa criar
explicitamente um objeto de conexão para o seu formulário ou componente. O objeto conexão
normalmente é criado como resultado da conclusão de um dos assistentes de dados ou do arraste
de objetos de dados em seu formulário. Para conectar seu aplicativo a dados de um banco de
dados, serviço da Web, ou objeto, execute o Assistente para Configuração da Fonte de Dados.,
selecionando Add New Data Source no Janela de fontes de dados
O diagrama a seguir mostra o fluxo padrão de operações ao se conectar a dados através da

execução de uma consulta TableAdapter para buscar dados e exibi-los em um formulário de um
aplicativo do Windows.

Em algumas situações, talvez seja conveniente criar um objeto de conexão sem a assistência de
qualquer ferramentas de design de dados. Para informações sobre como criar conexões
programaticamente, consulte Connecting to Data Sources.
Observação
Para obter informações sobre como conectar aplicativos da Web a dados, consulte Acessando
dados com o ASP.NET.
Criando conexões
Ao usar Visual Studio, conexões são configuradas usando o Add/Modify Connection Dialog Box
(General). A caixa de diálogoAdd Connection aparece quando você está editando ou criando
conexões dentro de um dos assistentes de dados ou doServer Explorer / Database Explorer ou
quando você estiver editando propriedades de conexão na janela Properties
Conexões de dados são automaticamente configuradas quando você executa uma das seguintes
ações:
Ação Descrição
Execução do Assistente para Conexões são configuradas quando o caminho do banco de dados
Configuração da Fonte de é escolhido no Data Source Configuration Wizard. Para obter
Dados. mais informações, consulte Como: Conectar-se a Dados em um
Banco de Dados.

Execução do Assistente de Conexões são criadas dentro do TableAdapter Configuration
Configuração para o Wizard. Para obter mais informações, consulte Como: Criar
TableAdapter. TableAdapters.
Execução do Assistente de Conexões são criadas dentro do TableAdapter Query

configuração da consulta Configuration Wizard. Para obter mais informações, consulte
TableAdapter. Como: Criar Consultas TableAdapter:.
Arraste de itens da Janela de Objetos de conexão são criados quando você arrasta itens da
fontes de dados para um janela Data Sources para o Windows Forms Designer ou para o
formulário ou o Component Component Designer. Para obter mais informações, consulte
Designer Exibir dados em formulários em aplicativos do Windows.
Adição de novas conexões Conexões de dados no Server Explorer/Database Explorer

de dados para oServer aparecem na lista de conexões disponíveis dentro dos assistentes
Explorer / Database Explorer. de dados. Para obter mais informações, consulte Como: adicionar
novas conexões de dados no Server Explorer/Database Explorer.
Seqüências de Caracteres de Conexão
Todos os objetos de conexão expoem aproximadamente os mesmos participantes. Entretanto, os

membros específicos disponíveis em um determinado objeto OleDbConnection dependem de qual
fonte de dados ele está conectado a; nem todas as fontes de dados suportam todos os membros
da classe OleDbConnection.
A propriedade Primária associada a um objeto de conexão é a propriedadeConnectionString. Esta

propriedade consiste em uma seqüência de caracteres com pares de informações de atributo /
valor necessários para fazer logon em um servidor de banco de dados e apontam para um banco
de dados específico. Uma propriedade ConnectionStringtípica pode parecer com o seguinte:
Provider=SQLOLEDB.1;Data Source=MySQLServer;Initial Catalog=NORTHWIND;Integrated

Security=SSPI
Essa seqüência de caracteres de conexão particular especifica que a conexão deve usar a
segurança integrada do Windows. Em vez disso uma seqüência de caracteres de conexão pode
incluir um nome de usuário e senha, mas isso não é recomendável, pois esses atributos depois
serão compilados em seu aplicativo representando portanto uma possível violação de segurança.
O armazenamento de detalhes em seqüências de caracteres de conexão (como uma senha)

podem afetar a segurança do seu aplicativo. Utilizar a segurança integrada do Windows é uma
maneira mais segura para controlar o acesso a um banco de dados. Para obter mais informações,
consulte Securing Connection Strings.
Os pares de atributo / valor mais comuns usados pelo OLE DB também são representados
separadamente por uma propriedade individual, como DataSourcee Database. Ao trabalhar com um
objeto de conexão, você pode definir a propriedade ConnectionString como uma única seqüência
de caracteres, ou você pode definir propriedades de conexão individuais. (Se sua fonte de dados
exigir valores seqüência de caracteres de conexão que não são representados por propriedades
individuais, então você deve definir a propriedade ConnectionString.)

Salvando e Recuperando Seqüências de Caracteres de Conexão
Seqüências de caracteres de conexão podem ser armazenados dentro de seu aplicativo

compilado ou no arquivo de configuração do aplicativo. Para obter mais informações, consulte
Como: salvar uma sequência de conexão.
Abrindo e Fechando Conexões
Os dois métodos primários para conexões são Open e Close. O métodoOpen usa as informações
da propriedade ConnectionString para entrar em contato com a fonte de dados e estabelecer uma
conexão aberta. O método Closedesliga a conexão. Fechar conexões é essencial, pois a maioria
das fontes de dados oferecem suporte somente um número limitado de conexões abertas, e
conexões abertas ocupam valiosos recursos do sistema.
Se você estiver trabalhando com Adaptadores de Tabela, DataAdapter s, ou DataCommands, não

é necessário abrir e fechar explicitamente uma conexão. Quando você chamar um método desses
objetos (por exemplo, um método Fill ou Update de um adaptador), o método verifica se a conexão
já está aberta. Caso contrário, o adaptador abre a conexão, executa sua lógica, e fecha a conexão
novamente.
Métodos, como Fill apenas abrem e fecham a conexão automaticamente se ela já não estiver
aberta. Se a conexão estiver aberta, os métodos as usam mas não as fecham. Isso lhe oferece a
flexibilidade de você mesmo abrir e fechar dados de comandos . Você pode fazer isso se você
tiver vários adaptadores que compartilham uma conexão. Neste caso, é ineficiente que cada
adaptador abra e feche a conexão quando você chamar o métodoFill . Em vez disso, você pode
abrir a conexão, chamar o método Fillde cada adaptador, e fechar a conexão quando tiver
terminado.
Pooling em Conexões
Aplicativos freqüentemente têm diferentes usuários executando o mesmo tipo de acesso a banco
de dados. Por exemplo, muitos usuários podem estar consultando um mesmo banco de dados
para obter os mesmos dados. Nesses casos, o desempenho do aplicativo pode ser aprimorado
através da realização de compartilhamento, ou pool, de conexões com a fonte de dados. A
sobrecarga refererente ao fato de cada usuário abrir e fechar uma conexão separada pode, caso
contrário, ter um efeito adverso no desempenho de aplicativos.
Se você estiver usando uma classe OleDbConnection, OdbcConnection, ou OracleConnection,

pooling de conexões são tratados automaticamente pelo provedor, portanto você não precisa para
gerenciá-las você mesmo.
Se você estiver usando a classe SqlConnection , o pooling de conexões é gerenciado

implicitamente mas também fornece opções que permitem que você gerencie o pooling você
mesmo. Para obter mais informações, consulte Using Connection Pooling.
Transações
Objetos de conexão suportam transações com um métodoBeginTransaction que cria um objeto de

transação (por exemplo, um objeto SqlTransaction). O objeto transação sucessivamente suporta
métodos que permitem que você confirme ou reverta as transações.
Transações são gerenciados no código. Para obter mais informações, consulte Performing
Transactions.
O .NET Framework versão 2.0 inclui uma nova estrutura de transação acessível pelo namespace
System.Transactions. Esta estrutura expõe transações de uma forma totalmente integrada com o

.NET Framework, incluindo ADO.NET. Para obter mais informações, consulte Leveraging
System.Transactions.
Informações e Segurança de Conexões
Uma vez que abrir uma conexão envolve obter acesso a um recurso importante— um banco de
dados — existem freqüentemente questões de segurança envolvendo a configuração e o trabalho
com uma conexão.
Como você protege o aplicativo e o seu acesso a fonte de dados depende da arquitetura do seu
sistema. Em um aplicativo baseado na Web, por exemplo, os usuários geralmente obtêm acessos
anônimos ao Serviços de Informações da Internet (IIS) e, portanto, não fornecem credenciais de
segurança. Nesse caso, seu aplicativo mantém a seu próprio informação de logon e a utiliza (em
vez de qualquer informação de usuário específica) para abrir a conexão e acessar o banco de
dados.
Armazenando detalhes de seqüências de caracteres de conexão (como uma senha) podem afetar
a segurança do seu aplicativo. Usando segurança integrada do Windows é uma maneira mais
segura para controlar o acesso a um banco de dados. Para obter mais informações, consulte
Securing Connection Strings.
Na intranet ou em aplicativos de várias camadas, você pode se aproveitar da opção de segurança

integrada fornecida pelo Windows, pelo IIS, e pelo SQL Server. Neste modelo, credenciais de
autenticação de um usuário para a rede local também são usadas para acessar recursos de
banco de dados, e não são usados explicitamente nomes de usuário ou senhas na seqüência de
caracteres de conexão. (Normalmente, as permissões são estabelecidas no computador servidor
do banco de dados por meio de grupos, para que você não precise estabelecer permissões
individuais para cada usuário que pode acessar o banco de dados.) Neste modelo, você não
precisará armazenar, de modo algum, informações de logon para a conexão, e não há etapas
adicionais necessárias para proteger as informações da seqüência de caracteres de conexão.
Para obter mais informações sobre segurança, consulte as seguintes páginas:
• Securing ADO.NET Applications

• More Secure File and Data Access in Windows Forms
Conexões em Tempo de Design no Server Explorer / Database Explorer
O Server Explorer/Database Explorerfornece uma maneira para você para criar conexões em
tempo de design para fontes de dados. Isto lhe permite pesquisar em fontes de dados disponíveis;
visualizar informações sobre as tabelas, colunas, e outros elementos que elas contêm; e editar e
criar elementos do banco de dados.
O seu aplicativo não usa diretamente as conexões disponíveis no Server Explorer/Database

Explorer. Essas conexões são usados pelo Visual Studio para trabalhar com seu banco de dados
no tempo de design. Para obter mais informações, consulte Visual Database Tools.
Por exemplo, no tempo de design você pode usar oServer Explorer/Database Explorer para
criar uma conexão com um banco de dados. Mais tarde, quando estiver criando um formulário,
você pode procurar o banco de dados, selecionar colunas de uma tabela, e arrastá-las para o
DataSet Designer. Isso cria um TableAdapter no seu DataSet. Um novo objeto de conexão
também é criado(que faz parte do TableAdapter recém-criado).

Informações sobre conexões em tempo de design são armazenadas em seu computador local
independentemente de um projeto ou solução específicos. Portanto, uma vez que você tenha
estabelecido uma conexão em tempo de design ao trabalhar em um aplicativo, ela aparece no
Server Explorer/Database Explorer sempre que você trabalhar no Visual Studio (a medida em
que o o servidor para o qual a conexão aponta estiver disponível). Para obter mais informações
sobre como usar oServer Explorer/Database Explorer e criar conexões em tempo de design,
consulte Como: adicionar novas conexões de dados no Server Explorer/Database Explorer.
Passo a passo: Conectando-se a dados em um banco de dados
A conexão de seu aplicativo a dados no Visual Studio é simplificada, usando o Assistente para
Configuração da Fonte de Dados. Depois que você conclui o assistente, os dados estão
disponíveis na Janela de fontes de dados para serem arrastados para seus formulários.
Observação
As caixas de diálogo e comandos de menu que você vir podem diferir daquelas descritas na
Ajuda, dependendo das suas configurações ativas ou da sua edição. Para alterar as
configurações, escolha Import and Export Settings no menu Tools. Para obter mais
informações, consulte Visual Studio Settings.
• A criação um novo projeto Windows Application.

• A criação e configuração de um dataset em seu aplicativo baseadas em objetos de banco
de dados usando o Data Source Configuration Wizard.
Pré-requisitos
Para seguir esta explicação passo a passo, você precisa de:
• Acesso ao banco de dados de exemplo Northwind. Para obter mais informações, consulte
COMO: Instalar Bancos de Dados de Exemplo.
Criando o Projeto
Para criar o novo projeto
1. No menu File, crie um novo projeto.

2. Selecione Windows Application e clique em OK. Para obter mais informações, consulte
Creating Windows-based Applications.
O projeto é criado e adicionado ao Solution Explorer.
Conectando-se ao Banco de Dados Northwind
Você pode se conectar à versão SQL Server do banco de dados Northwind ou à versão Microsot
Access do banco de dados. Cada processo está descrito em seguida nos dois procedimentos a
seguir.
Para criar uma conexão para a versão SQL Server do Northwind

2. Na janela Data Sources, selecione Add New Data Source.

3. Clique em Next na página bem-vindo Data Source Configuration Wizard.
4. Selecione Database na página Choose a Data Source Type.
5. Na página Choose your Data Connection, siga um destes procedimentos:
-ou-
o Selecione New Connection para configurar uma nova conexão de dados. Para
obter mais informações, consulte Como: Criar Conexões com Bancos de Dados do Access,
ou Como: Criar conexões com bancos de dados SQL Server.
confidenciais (include sensitive data), e clique em Next.
7. Clique em Next na página Save connection string to the Application Configuration file.
9. Selecione as tabelas Customers e Orders, e clique em Finish.
Para criar uma conexão para a versão Access do Northwind
1. Na caixa de diálogo Choose Data Source, selecione Microsoft Access Database File, e
clique em OK.
Se a caixa de diálogo Add Connection abrir, e o Data source não for Microsoft Access
Database File, clique em Change para abrir a caixa de diálogo Choose/Change Data
Source. Para obter mais informações, consulte Choose/Change Data Source Dialog Box.
2. Digite o caminho para o arquivo de banco de dados Northwind.mdb, ou clique no botão
Browse para localizar o arquivo de banco de dados Northwind.mdb. Para obter mais
informações, consulte Add/Modify Connection (Microsoft Access).
3. Clique em OK.
7. O NorthwindDataSet é adicionado ao seu projeto e as tabelas Customers e Orders
Adicionando Controles ao Formulário
Você pode criar controles ligados a dados, arrastando itens da janela Data Sources para seu
formulário.
Para criar controles ligados a dados no formulário
• Arraste o nó principal Customers da janela Data Sources para o formulário.

Controles ligados a dados com rótulos descritivos aparecem no formulário, juntamente com
uma faixa de ferramentas (BindingNavigator) para registros de navegação. Um
NorthwindDataSet, CustomersTableAdapter, BindingSource, e BindingNavigator aparecem na
bandeja de componentes.
Executando o aplicativo

Para executar o aplicativo
• Pressione F5.
Form1 é aberto, mostrando os dados da tabela Customers.
Segurança
Armazenar detalhes da seqüência de conexão (como uma senha) podem afetar a segurança do
seu aplicativo. Usar a Autenticação do Windows é uma maneira mais segura de controlar o
acesso a um banco de dados. Para obter mais informações, consulte Securing Connection
Strings.
Próximas etapas
O DataSet que você acabou de criar agora está disponível na janela Data Sources.
Para adicionar funcionalidade a seu aplicativo
• Selecione outros itens na janela Data Sources e arraste-os para um formulário. Para obter
mais informações, consulte Visão Geral da Exibição dados.
• Abra a fonte de dados noDataset Designer para adicionar ou editar os objetos que
formam o dataset.
• Adicione lógica de validação para o evento ColumnChanging ou RowChanging das tabelas
de dados no dataset. Para obter mais informações, consulte Visão geral sobre validação de
dados.
Passo a passo: Conectando-se a dados em um Web Service
Conectar seu aplicativo a dados no Visual Studio fica mais simples, usando o Assistente para
Configuração da Fonte de Dados. Depois que você concluir o assistente, os dados estarão
disponíveis no Janela de fontes de dados para serem arrastados para Windows Forms.
• A criação um novo projeto Windows Application.

• A criação e configuração de um dataset em seu aplicativo com base em objetos retornados
pelo serviço da Web.
Pré-requisitos
Para seguir esta explicação passo a passo, você precisa:
• Acesso ao serviço da Web Google (http://api.google.com/GoogleSearch.wsdl)

Criando o Projeto
Para criar o novo projeto

Criando o Dataset

O dataset é criado através da execução do Data Source Configuration Wizard.
Para criar o dataset

2. Na janela Data Sources, selecione Add New Data Source.
3. Clique em Next na página bem-vindo Data Source Configuration Wizard.
4. Selecione Web Service na página Choose a Data Source Type.
5. Digite http://api.google.com/GoogleSearch.wsdl na caixa URL da caixa de diálogo Add
Web Reference.
6. Clique em Go.
7. Após o serviço da Web ser encontrado, clique em Add Reference para adicionar uma
referência ao seu projeto. Para obter mais informações, consulte Add Web Reference Dialog
Box.
9. A referência da Web é adicionado ao Solution Explorer.
Próximas etapas
O DataSet que você acabou de criar agora está disponível na janela Data Sources.
Observação
Os itens que aparecem na janela Data Sources são dependentes das informações que o serviço
da Web retorna. Alguns serviços da Web podem não fornecer informações suficientes para o Data
Source Configuration Wizard criar objetos ligáveis. Por exemplo, se o serviço da Web retornar
um dataset não digitado, nenhum item aparecerá na janela Data Sources após a conclusão do
assistente. Isso ocorre porque datasets não digitados não fornecem esquema, então o assistente
não tem informações suficientes para criar a fonte de dados.
• Selecione itens na janela Data Sources e arraste-os para um formulário. Para obter mais
informações, consulte Visão Geral da Exibição dados.
Passo a passo: Conectando-se a dados em um banco de dados do Access
A conexão de seu aplicativo do Visual Studio a dados em um banco de dados do Access é

simplificada com o Assistente para Configuração da Fonte de Dados. Depois que você concluir o
assistente, dados ficam disponíveis no Janela de fontes de dados para arrastar para seus
formulários. Para obter mais informações, consulte Visão Geral de Dados Local. Ao conectar-se a
dados em arquivos de dados locais é importante compreender como o sistema do projeto no
Visual Studio gerencia esses arquivos. Para obter mais informações, consulte How to: Manage
Local Data Files in Your Project.
Observação
As caixas de diálogo e comandos de menu que você vê podem diferir dos descritos na Ajuda
(Help), dependendo de suas 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
Visual Studio Settings.
As tarefas ilustradas nesta explicação passo-a-passo incluem:
• Criando um novo projeto Windows Application.

• Criando e configurando um dataset em seu aplicativo baseado nas tabelas Customers e
Orders, no banco de dados Northwind usando o Data Source Configuration Wizard.
Pré-requisitos
Para concluir esta explicação passo-a-passo, você precisa:
• Acesso ao exemplo Northwind (Northwind.mdb), um arquivo Access de banco de dados.

Para obter mais informações, consulte COMO: Instalar Bancos de Dados de Exemplo.
Criando o Projeto
Para criar o novo projeto Windows Application

Criando o Dataset
Você cria o dataset executando o Data Source Configuration Wizard.

2. Na janela Data Sources, clique em Add New Data Source.
4. Na página Choose your Data Connection, selecione New Connection para configurar
uma nova conexão de dados.
Observação
Se o Data source não for Microsoft Access Database File, então selecione Change para abrir a
caixa de diálogo Choose/Change Data Source.
5. Na caixa de diálogo Choose Data Source, selecione Microsoft Access Database File.
6. Digite o caminho para o arquivo de banco de dados Northwind.mdb, ou clique no botão
Browse para localizar o arquivo Northwind.mdb. Para obter informações sobre como
adquirir uma cópia do arquivo Northwind.mdb, consulte COMO: Instalar Bancos de Dados
de Exemplo. Clique em OK.
7. Clique em Next.

Segurança
Armazenar informações confidenciais (como uma senha) pode afetar a segurança do seu
aplicativo. Usar a Windows Authentication (também conhecida como segurança integrada) é uma
maneira mais segura para controlar o acesso a um banco de dados. Para obter mais informações,
consulte Securing Connection Strings.
Próximas etapas
O dataset que você acabou de criar agora está disponível na janela Data Sources.
• Selecione itens na janela Data Sources e arraste-os para seu formulário. Para obter mais
informações, consulte Visão Geral da Exibição dados.
• Abra a fonte de dados no Dataset Designer para adicionar ou editar os objetos que formam
o dataset.
• Adicione lógica de validação para os eventos ColumnChanging ou RowChanging das
tabelas de dados no dataset. Para obter mais informações, consulte Visão geral sobre
validação de dados.
COMO: Criar um DataSet Digitado
Cria-se um DataSet tipado usando o Data Source Configuration Wizard ou o Dataset Designer.
Observação
Para informações sobre como criar DataSets programaticamente, consulte Creating a DataSet.
Criando DataSets tipados com o Data Source Configuration Wizard ou com o DataSet Designer
Para criar um DataSet com o Data Source Configuration Wizard
1. No menu Data, clique Add New Data Source para iniciar o Data Source Configuration
Wizard.
3. Conclua o assistente e um DataSet tipado é adicionado ao seu projeto. Para obter mais
informações, consulte Assistente para Configuração da Fonte de Dados.
Para criar um DataSet com o DataSet Designer

2. Selecione DataSet na caixa de diálogo Add New Item.
3. Digite um nome para o DataSet.
4. Clique em Add.
O DataSet é adicionado ao projeto e abre no Dataset Designer.

5. Arraste itens da guia DataSet da Toolbox no designer. Para obter mais informações,
consulte Como editar um DataSet:.
-ou-
Arraste itens de uma conexão ativa em Server Explorer / Database Explorer para o
Dataset Designer.
Passo a passo: Criando um DataSet com o DataSet Designer
Nesta explicação passo a passo você criará uma DataSet usando o Dataset Designer. Ela levará
você através do processo de criar um novo projeto e adicionar um novo item DataSet a ele. Você
aprenderá como criar tabelas com base em tabelas em um banco de dados sem utilizar um
assistente.
• Criar um novo projeto Windows Application.

• Adicionar um item DataSet vazio para o projeto.
• Criar e configurar uma fonte de dados em seu aplicativo, criando um dataset com o
Dataset Designer.
• Criar uma conexão para o banco de dados Northwind no Server Explorer.
• Criar tabelas com TableAdapters no dataset baseadas em tabelas no banco de dados.
Observação
(Help) dependendo de suas configurações ativas ou edição. Para alterar as configurações,
Pré-requisitos
Para concluir esta explicação passo a passo, você precisa:
• Acesso ao banco de dados de exemplo Northwind (versão do SQL Server ou do Access).

Criando um Novo Projeto Windows Application
Para criar um novo projeto Windows Application

2. Escolha uma linguagem de programação no painel Project Types.
3. Clique em Windows Application no painel Templates.
4. Nomeie o projeto como DatasetDesignerWalkthrough, e clique OK.
O Visual Studio adicionará o projeto ao Solution Explorer e exibirá um novo formulário no
designer.
Adicionando Um Novo Dataset ao Aplicativo
Para adicionar um novo item dataset ao projeto

A caixa de diálogo Add New Item aparece.
2. Na caixa Templates da caixa de diálogo Add New Item, clique em DataSet.
3. Nomeie o dataset como NorthwindDataset, e clique Add.
O Visual Studio adicionará um arquivo chamado NorthwindDataset.xsd ao projeto e irá
abri-lo no Dataset Designer.
Criando uma Conexão de Dados no Server Explorer
Para criar uma conexão para o banco de dados Northwind
1. No menu View, clique em Server Explorer.

2. No Server Explorer, clique no botão Connect to Database.
3. Crie uma conexão com o banco de dados de exemplo Northwind.
Observação
Para esta explicação passo a passo, você pode conectar-se ao Northwind na versão do SQL
Server ou do Access.
4. Para informações sobre como criar uma conexão com o SQL Server, consulte Como: Criar
conexões com bancos de dados SQL Server.
5. Para informações sobre como criar uma conexão com Access, consulte Como: Criar
Conexões com Bancos de Dados do Access.
Criando Tabelas no Dataset
Esta seção explicará como adicionar tabelas ao dataset.
Para criar a tabela Customers
1. Expanda a conexão de dados que você criou no Server Explorer, e em seguida, expanda
o nó Tables.
2. Arraste a tabela Customers do Server Explorer para o Dataset Designer.
Uma tabela de dados Customers e CustomersTableAdapter são adicionadas ao dataset.
Para criar a tabela Orders
• Arraste a tabela Orders do Server Explorer para o Dataset Designer.

Uma tabela de dados Orders, OrdersTableAdapter, e a relação de dados entre as tabelas
Customers e Orders são adicionadas ao dataset.
Para criar a tabela OrderDetails
• Arraste a tabela Order Details do Server Explorer para o Dataset Designer.

Uma tabela de dados Order Details, Order DetailsTableAdapter, e a relação de dados entre
as tabelas Orders e Order Details são adicionadas ao dataset.
Próximas etapas

• O dataset que você acabou de criar agora está disponível na janela Data Sources. Você
pode selecionar itens na janela Data Sources e arrastá-los para um formulário. Para obter
mais informações, consulte Visão Geral da Exibição dados.
• Adicione mais consultas aos TableAdapters. Para obter mais informações, consulte Como:
Criar Consultas TableAdapter:.
• Adicione lógica de validação para os eventos ColumnChanging ou RowChanging das
tabelas de dados no dataset. Para obter mais informações, consulte Visão geral sobre
Passo a passo: Criando uma tabela de dados no DataSet Designer
Esta explicação passo a passo explica como criar uma DataTable (sem um TableAdapter) usando
o Dataset Designer. Para informações sobre como criar tabelas de dados que incluem
TableAdapters, consulte Como: Criar TableAdapters.
• Criar um novo projeto de Windows Application

• Adicionar um novo dataset ao aplicativo
• Adicionar uma nova tabela de dados para o dataset
• Adicionar colunas à tabela de dados
• Definir a chave primária para a tabela
Criando um novo aplicativo Windows
Para criar um novo projeto de Windows Application

4. Nomeie o projeto DataTableWalkthrough, e clique OK.
O Visual Studio adiciona o projeto ao Solution Explorer e exibe o Form1 no designer.
Adicionando um novo dataset ao aplicativo
Para adicionar um novo item dataset para o projeto

A caixa de diálogo Add New Item Dialog Box aparece.
2. Na caixa Templates, selecione DataSet.
3. Clique em Add.
O Visual Studio irá adicionar um arquivo chamado DataSet1.xsd ao projeto e o abrirá no
Dataset Designer.
Adicionando um DataTable novo ao Dataset
Para adicionar uma nova tabela de dados ao dataset
1. Arraste uma DataTable da guia DataSet do Toolbox para o Dataset Designer

Uma tabela denominada DataTable1 é adicionada ao dataset.

Observação
Para criar uma tabela de dados que inclui um TableAdapter, consulte Explicação passo a passo:
Criando um Adaptador de Tabela com Múltiplas Consultas.
2. Clique na barra de título do DataTable1 e renomeie para Music.

Adicionando colunas à tabela de dados
Para adicionar colunas à tabela de dados
1. Clique com o botão direito do mouse na tabela Music. Aponte para Add, e clique Column.
2. Nome da coluna SongID.
3. Na janela Properties, defina a propriedade DataType como System.Int16.
4. Repita este processo e adicione as seguintes colunas:
SongTitle: System.String
Artist: System.String
Genre: System.String
Definindo a chave primária para a tabela
Todas as tabelas de dados devem ter uma chave primária. Uma chave primária identifica
exclusivamente um registro específico em uma tabela de dados.
Para definir a chave primária da tabela de dados
• Clique com o botão direito do mouse na coluna SongID, e clique Set Primary Key.
Um ícone de chave aparece próxima à coluna SongID.
Salvando seu projeto
Para salvar o projeto DataTableWalkthrough
• No menu File, clique em Save All.

Próximas etapas
Agora que você criou a tabela, você pode desejar executar uma das seguintes ações:
Para Consulte
Criar um formulário para entrada Passo-a-passo: Exibindo dados em um formulário em um

de dados aplicativo do Windows.
Adicionar dados à tabela Adding Data to a Table.
Visualizar dados em uma tabela Viewing Data in a Table.
Editar dados Editing Data in a Table

Excluir uma linha de uma tabela Deleting a Row from a Table
Passo a passo: Criando um relacionamento entre tabelas de dados
Esta explicação passo a passo explica como criar duas tabelas de dados sem TableAdapters
usando o Dataset Designer e criando um relacionamento entre elas. Para informações sobre
como criar tabelas de dados que incluem TableAdapters, consulte Como: Criar TableAdapters.
Para obter mais informações sobre TableAdapters, consulte Visão Geral do Adaptador de Tabela.
Esta explicação passo a passo inclui as seguintes tarefas ilustradas:
• Criando um novo aplicativo do Windows

• Adicionando um novo dataset ao aplicativo
• Adicionando duas novas tabelas de dados ao dataset
• Adicionando colunas para as tabelas de dados
• Definindo a chave primária para as tabelas
• Criando um relacionamento entre as tabelas
Observação
(Help) dependendo de suas configurações ativas ou de sua edição. Para alterar suas
configurações, escolha Import and Export Settings no menu Tools. Para obter mais
informações, consulte Visual Studio Settings.
Criando um novo aplicativo do Windows
Para criar um novo projeto do Aplicativo do Windows

2. Selecione uma linguagem de programação no painel Project Types e crie um Windows
Application (Aplicativo do Windows).
3. Nomeie o projeto como RelationshipWalkthrough e depois clique em OK.
O Visual Studio irá adicionar o projeto ao Solution Explorer e exibirá Form1 no Windows
Forms Designer.
Adicionando um novo dataset ao aplicativo
Para adicionar um novo item dataset ao projeto
1. Do menu Project, escolha Add New Item.

A Add New Item Dialog Box aparece.
2. Da área Templates selecione DataSet.
3. Clique em Add.
O Visual Studio irá adicionar um arquivo chamado Dataset1.xsd ao projeto e abri-lo no
Dataset Designer.
Adicionando duas novas tabelas de dados ao dataset

Para adicionar uma nova tabela de dados ao dataset
1. Arraste um DataTable da guia DataSet da Toolbox para o Dataset Designer.

2. Clique na barra de título de DataTable1 e renomei-a como Customers.
3. Arraste um segundo DataTable da guia DataSet da Toolbox para o Dataset Designer.
4. Clique na barra de título de DataTable1 e renomei-a como Orders.
Adicionando colunas à tabela de dados Customers
Para adicionar colunas à tabela Customers
1. Clique com o botão direito do mouse na tabela Customers.

2. Aponte para Add e depois clique em Column.
3. Nomeie a coluna como CustomerID.
4. Na janela Properties, defina a propriedade DataType como Int16.
5. Repita este processo para adicionar as seguintes colunas:
Coluna Propriedade DataType
CompanyName String
Contact String
ContactTitle String
Adicionando colunas à tabela de dados Orders
Para adicionar colunas à tabela Orders
1. Clique com o botão direito do mouse na tabela Orders.

2. Aponte para Add e depois clique em Column.
3. Nomeie a coluna como OrderID.
4. Na janela Properties, defina a propriedade DataType como Int16.
5. Repita este processo para adicionar as seguintes colunas:
Coluna Propriedade DataType
CustomerID Int16
OrderDate DateTime
ShippedDate DateTime
Definindo a chave primária para a tabela Customers

A coluna de identificação exclusiva para a tabela Customers é a coluna CustomerID.
Para definir a chave primária da tabela Customers
1. Clique na tabela Customers para selecioná-la.

2. Clique com o botão direito do mouse na coluna CustomerID e depois clique em Set
Primary Key no menu de atalho.
Definindo a chave primária para a tabela Orders
A coluna de identificação exclusiva para a tabela Orders é a coluna OrderID.
Para definir a chave primária da tabela Orders
1. Clique na tabela Orders para selecioná-la.

2. Clique com o botão direito do mouse na coluna OrderID e depois clique em Set Primary
Key no menu de atalho.
Criando o relacionamento entre as tabelas
O relacionamento é criado entre a coluna comum de cada tabela — neste caso, a coluna
CustomerID.
Para configurar um novo relacionamento entre as tabelas Customers e Orders
1. Arraste um objeto Relation da guia DataSet da Toolbox para a tabela Orders.

A Caixa de diálogo Relation abre.
2. Na caixa Parent Table, selecione Customers.
3. Na caixa Child Table, selecione Orders.
4. Na caixa Columns, designe Key Columns para CustomerID.
5. Na caixa Columns, designe Foreign Key Columns para CustomerID.
6. Clique em OK para criar o relacionamento; uma linha de relação aparece no designer entre
as duas tabelas.
7. No menu Data, escolha Show Relation Labels.
Salvando seu projeto
Para salvar o projeto
• No menu File, clique em Save All.

Próximas etapas
Agora que você criou as tabelas relacionadas, você pode desejar executar uma das seguintes
ações:
Para Consulte
Adicionar dados à tabela Adding Data to a Table

Visualizar dados em uma tabela Viewing Data in a Table
Editar dados Editing Data in a Table
Excluir uma linha de uma tabela Deleting a Row from a Table
Visão Geral do Adaptador de Tabela

Os TableAdapters fornecem a comunicação entre o seu aplicativo e um banco de dados. Mais
especificamente, um TableAdapter se conecta a um banco de dados, executa consultas ou
procedimentos armazenados, e retorna uma nova tabela de dados preenchida com os dados
retornados ou preenche uma DataTable existente com os dados retornados. TableAdapters
também são usados para enviar dados atualizados do seu aplicativo de volta para o banco de
dados.
Usuários de versões anteriores do Visual Studio podem imaginar um TableAdapter como um

DataAdapter com um objeto de conexão interno e a capacidade de conter várias consultas. Cada
consulta adicionada a um TableAdapter é exposta como um método público que é simplesmente
chamado como todos os outros métodos ou funções em um objeto.
Além da funcionalidade padrão de um DataAdapter, TableAdapters fornecem métodos tipados

adicionais que encapsulam consultas que compartilham um esquema comum com a DataTable
tipada associada. Em outras palavras, você pode ter tantas consultas quanto você deseja em um
TableAdapter, desde que elas retornem dados de acordo com o mesmo esquema.
Na versão anterior do Visual Studio, Os Adaptadores de Dados do ADO.NET eram usados para
comunicação entre um aplicativo e um banco de dados. Apesar de os adaptadores de dados
ainda serem componentes principais do .NET Framework Data Providers, TableAdapters são
componentes gerados pelo designer que melhoram a funcionalidade dos DataAdapters.
TableAdapters normalmente contêm métodos Fill e Update para buscar e atualizar dados em um
banco de dados.
TableAdapters são criados com o Dataset Designer no interior de datasets fortemente tipados.
Você pode criar TableAdapters durante a criação de um novo dataset com o Assistente para
Configuração da Fonte de Dados. Você também pode criar TableAdapters em datasets existentes
com o Assistente de Configuração para o TableAdapter ou arrastando objetos de banco de dados
do Server Explorer para o Dataset Designer. Para obter mais informações, consulte Como: Criar
TableAdapters.
Apesar de os TableAdapters serem criados com o Dataset Designer, as classes geradas do

TableAdapter não são classes aninhadas do DataSet. Elas estão localizadas em um namespace
separado específico para cada dataset. Por exemplo, se você tiver um dataset nomeado
NorthwindDataSet, os TableAdapters associados às DataTables no NorthwindDataSet estariam no
namespace NorthwindDataSetTableAdapters. Para acessar um determinado TableAdapter por
código, você deve declarar uma nova instância do TableAdapter. Por exemplo:
C#
NorthwindDataSet northwindDataSet = new NorthwindDataSet();
NorthwindDataSetTableAdapters.CustomersTableAdapter customersTableAdapter = new
NorthwindDataSetTableAdapters.CustomersTableAdapter();
customersTableAdapter.Fill(northwindDataSet.Customers);

Esquema associado a DataTable
Ao criar um TableAdapter, a consulta inicial ou o procedimento armazenado é usado para definir o

esquema da DataTable associada ao TableAdapter. Você executa essa consulta inicial ou
procedimento armazenado chamando o método principal Fill do TableAdapter (que preenche a
DataTable associada ao TableAdapter). Quaisquer alterações feitas à consulta principal do
TableAdapter são refletidas no esquema da tabela de dados associada. Por exemplo, remover
uma coluna da consulta principal remove a coluna da tabela de dados associada. Se quaisquer
consultas adicionais do TableAdapter usarem instruções SQL retornando colunas que não estão
na consulta principal, então o designer tentará sincronizar as alterações de coluna da consulta
principal e quaisquer consultas adicionais. Para obter mais informações, consulte Como editar
TableAdapters:.
Comandos UPDATE do TableAdapter
A funcionalidade de atualização de um TableAdapter depende de quanta informação está

disponível com base na consulta principal fornecida no TableAdapter Wizard. Por exemplo,
TableAdapters que estejam configurados para buscar valores de várias tabelas (JOINs), valores
escalares, ou de resultados de funções agregadas, não são criados inicialmente com a
capacidade de enviar atualizações de volta para o banco de dados subjacente. Entretanto, você
pode configurar os comandos INSERT, UPDATE e DELETE manualmente na janela Properties.
Consultas do TableAdapter
Diferentemente dos adaptadores de dados padrão, os TableAdapters podem conter consultas

múltiplas para preencher suas tabelas de dados associadas. Você pode definir tantas consultas
para um TableAdapter quanto seu aplicativo precisar, desde que cada consulta retorne os dados
de acordo com o mesmo esquema da sua tabela de dados associada. Isso permite o
carregamento de dados que satisfaçam critérios diferentes. Por exemplo, se seu aplicativo

contiver uma tabela de clientes, você pode criar uma consulta que preenche a tabela com cada
cliente cujo nome começa com uma certa letra, e outra consulta que preenche a tabela com todos
os clientes localizados no mesmo estado. Para preencher uma tabela Customers com clientes em
um estado determinado você pode criar uma consulta FillByState que leva um parâmetro para o
valor de estado: SELECT * FROM Customers WHERE State = @State. Você executa a consulta
chamando o método FillByState e passando o valor do parâmetro como este:
CustomerTableAdapter.FillByState("WA"). Para obter mais informações, consulte Como: Criar
Consultas TableAdapter:.
Além das consultas que retornam dados no mesmo esquema da tabela de dados do
TableAdapter, você pode adicionar consultas que retornam valores escalares. Por exemplo, criar
uma consulta que retorna uma contagem de clientes de um CustomersTableAdapter. (SELECT
Count(*) From Customers) é válido, apesar de os dados retornados não estarem de acordo com
esquema da tabela.
Propriedade ClearBeforeFill
O TableAdapter adiciona uma propriedade não disponível na classe base DataAdapter. Por
padrão, sempre que você executar uma consulta para preencher uma tabela de dados do
TableAdapter, os dados serão limpos e somente os resultados da consulta são carregados na
tabela. Defina a propriedade ClearBeforeFill do TableAdapter como false se você deseja adicionar
ou mesclar os dados retornados de uma consulta com os dados existentes na tabela de dados.
Independentemente de você limpar os dados, você precisará explicitamente enviar as
atualizações de volta ao banco de dados, se desejar. Portanto lembre-se de salvar quaisquer
alterações feitas nos dados da tabela antes de executar outra consulta que preencha a tabela.
Para obter mais informações, consulte Como: atualizar dados usando um TableAdapter.
Herança do TableAdapter
Os TableAdapters estendem a funcionalidade dos adaptadores padrão de dados, encapsulando

um DataAdapter configurado. Por padrão, o TableAdapter herda de Component e não pode ser
convertido (casting) para a classe DataAdapter. Converter um TableAdapter para um
DataAdapter resulta em uma InvalidCastException. Para alterar a classe base de um
TableAdapter, você pode digitar uma classe que deriva do Component na propriedade Base
Class do TableAdapter no Dataset Designer.
Métodos e propriedades do TableAdapter
A classe TableAdapter não é parte do .NET Framework, assim você não pode pesquisar ele na
documentação ou no Object Browser. Ele é criado no tempo de design quando você usa um dos
assistentes mencionados acima. O nome atribuído a um TableAdapter quando você o cria é
baseado no nome da tabela com a qual você estiver trabalhando. Por exemplo, ao criar um
TableAdapter baseado em uma tabela de um banco de dados chamada Orders, o TableAdapter
seria nomeado OrdersTableAdapter. O nome de classe do TableAdapter pode ser alterado usando
a propriedade Name no Dataset Designer.
Estes são os métodos e propriedades mais usados de TableAdapters:
Membro Descrição
TableAdapter.Fill Preenche a tabela de dados associada ao TableAdapter com os

resultados do comando SELECT. Para obter mais informações,
consulte Como: preencher uma DataSet com dados.

TableAdapter.Update Envia alterações de volta ao banco de dados. Para obter mais
informações, consulte Como: atualizar dados usando um
TableAdapter.
TableAdapter.GetData Retorna uma nova DataTable preenchida com dados.
TableAdapter.Insert Cria uma nova linha na tabela de dados. Para obter mais
informações, consulte Como adicionar linhas ao um DataTable.
TableAdapter.ClearBeforeFill Determina se uma tabela de dados é esvaziada antes de chamar um

dos métodos Fill.
Método Update do TableAdapter
Os TableAdapters usam comandos de dados para leitura e gravação no banco de dados. A

consulta Fill inicial do TableAdapter é usada como base para criar o esquema da tabela de dados
associada, bem como os comandos InsertCommand, UpdateCommand, e DeleteCommand
associados ao método TableAdapter.Update. Isso significa que chamar um método Update de um
TableAdapter executa as instruções criadas quando o TableAdapter foi originalmente configurado,
e não uma das consultas adicionais adicionadas com o TableAdapter Query Configuration
Wizard.
Quando você usar um TableAdapter, ele efetivamente executa as mesmas operações com os
comandos que você geralmente deseja executar. Por exemplo, quando você chamar o método Fill
do adaptador, o adaptador executa o comando de dados na sua propriedade SelectCommand e usa
uma leitora de dados (por exemplo, SqlDataReader) para carregar o resultado na tabela de dados.
Da mesma forma, quando você chamar o método Update do adaptador, ele executa o comando
apropriado (nas propriedades DeleteCommand, UpdateCommand, e InsertCommand) para cada
mudança na tabela de dados.
Observação
Se não houver informações suficientes na consulta principal, os comandos InsertCommand,

UpdateCommand, e DeleteCommand são criados por padrão quando o TableAdapter é gerado. Se a
consulta principal do TableAdapter é uma declaração SELECT de mais de uma tabela , é possível
que o designer não consiga gerar os comandos InsertCommand, UpdateCommand, e
DeleteCommand. Se esses comandos não são gerados, você poderá receber um erro ao executar
o método TableAdapter.Update.
GenerateDbDirectMethods do TableAdapter
Além dos comandos InsertCommand, UpdateCommand, e DeleteCommand, TableAdapters são

criados com métodos que podem ser executados diretamente no banco de dados. Estes métodos
(TableAdapter.Insert, TableAdapter.Update, e TableAdapter.Delete) podem ser chamados diretamente
para manipular dados no banco de dados.
Se você não deseja criar esses métodos diretos, defina a propriedade

GenerateDbDirectMethods do TableAdapter como false (na janela Properties). Consultas
adicionais do TableAdapter são consultas autônomas — que não geram esses métodos.
Suporte do TableAdapter para tipos Nullable

Os TableAdapters oferecem suporte a tipos anuláveis Nullable(Of T) e T?. Para obter mais
informações sobre tipos nullable no Visual Basic, consulte Value Types that Might Not Have a
Defined Value. Para obter mais informações sobre tipos anuláveis em C#, consulte Usando
Nullable tipos (C# programação guia).
Explicação passo a passo: Criando um Adaptador de Tabela com Múltiplas Consultas
Neste explicação passo a passo, você criará um TableAdapter em um DataSet usando o

Assistente para Configuração da Fonte de Dados. A explicação passo a passo leva você através
do processo de criar uma segunda consulta no TableAdapter usando o Assistente de configuração
da consulta TableAdapter juntamente com o Dataset Designer.
Tarefas ilustradas nesta explicação passo a passo incluem:

• Criando e configurando uma fonte de dados em seu aplicativo, criando um DataSet com o
Data Source Configuration Wizard.
• Abrindo o novo DataSet no Dataset Designer.
• Adicionando consultas ao TableAdapter com o TableAdapter Query Configuration
Wizard.
Pré-requisitos
• Acesso ao banco de dados de exemplos Northwind (versão do SQL Server ou do Access).

A primeira etapa consiste em criar um aplicativo do Windows.
Para criar um novo projeto de Aplicativo do Windows
1. No Visual Studio, no menu File, crie um novo projeto.

4. Nomeie o projeto TableAdapterQueriesWalkthrough, e clique OK.
O Visual Studio adiciona o projeto ao Solution Explorer e exibe um novo formulário no
designer.
Criar uma fonte de dados de banco de dados com um TableAdapter
Essa etapa cria uma fonte de dados usando o Data Source Configuration Wizard baseado na
tabela Customers no banco de dados de exemplos Northwind. Você deve ter acesso ao banco de
dados de exemplos Northwind para criar a conexão. Para informações sobre como configurar
dados de exemplo Northwind, consulte COMO: Instalar Bancos de Dados de Exemplo.

2. Na janela Data Sources, selecione Add New Data Source para iniciar o Data Source
Configuration Wizard.

o Se uma conexão de dados para o banco de dados de exemplo Northwind está
disponível na lista drop-down, selecione-o.
-ou-
o Selecione New Connection para abrir a caixa Add/Modify Connection. Para obter
mais informações, consulte Add/Modify Connection Dialog Box (General).
8. Selecione a tabela Customers, e clique Finish.
A NorthwindDataSet é adicionada ao seu projeto e a tabela Customers aparece na janela
Data Sources.
Abrindo o DataSet no Dataset Designer
Para abrir o DataSet no Dataset Designer
1. Clique com o botão direito do mouse NorthwindDataset na janela Data Sources.

2. No menu de atalho, escolha Edit DataSet with Designer.
O NorthwindDataset abre no Dataset Designer.
Adicionando uma segunda consulta ao CustomersTableAdapter
O assistente criou o DataSet com uma tabela de dados Customers e CustomersTableAdapter.

Essa seção da explicação passo a passo adiciona uma segunda consulta para o
CustomersTableAdapter.
Para adicionar uma consulta para o CustomersTableAdapter
1. Arraste um Query da guia DataSet da tabela Toolbox para a tabela Customers.

O Assistente de configuração da consulta TableAdapter abre.
2. Selecione Use SQL statements, e clique Next.
3. Selecione SELECT which returns rows, e clique Next.
4. Adicione uma cláusula WHERE à consulta para que ela seja lida:
SELECT CustomerID, CompanyName, ContactName, ContactTitle, Address, City, Region,
PostalCode, Country, Phone, Fax FROM Customers WHERE City = @City
Observação
Se você estiver usando a versão Access do Northwind, substitua o parâmetro @City com um
ponto de interrogação. (SELECT CustomerID, CompanyName, ContactName, ContactTitle, Address, City,
Region, PostalCode, Country, Phone, Fax FROM Customers WHERE City = ?)
5. Na página Choose Methods to Generate, nomeie o método Fill a DataTable FillByCity.

Observação
O método Return a DataTable não é usado neste explicação passo a passo, então você possa
desmarcar a caixa de seleção ou deixar o nome padrão.
6. Clique em Next e conclua o assistente.

A consulta FillByCity é adicionada ao CustomersTableAdapter.
Adicionando código para executar a consulta adicional no formulário
Para executar a consulta
1. Selecione Form1 no Solution Explorer, e clique em View Designer.

2. Arraste o nó Customers da janela Data Sources para Form1.
3. Altere para modo de exibição de código, selecionando Code a partir do menu View.
4. Substitua o código no manipulador de eventos Form1_Load pelo seguinte, para executar a
consulta FillByCity.
C#
string cityValue = "Seattle"; customersTableAdapter.FillByCity(northwindDataSet.Customers,
cityValue);
• Pressione F5.
• A grade é preenchida com clientes com um valor City de Seattle.
Próximas etapas
• Adicione um controle TextBox e um controle Button e passar o valor na caixa de texto para
a consulta. (CustomersTableAdapter.FillByCity(NorthwindDataSet.Customers, TextBox1.Text)).
• Adicione validação lógica para o evento ColumnChanging. ou RowChanging das tabelas
de dados no DataSet. Para obter mais informações, consulte Visão geral sobre validação de
dados.
Consulte também
Visão Geral do Preenchimento de DataSets e Consultas de

Dados
O típico mecanismo do Visual Studio para executar consultas Transact-SQL e para preencher
DataSets é o TableAdapter.
Você pode executar instruções SQL ou procedimentos armazenados contra uma fonte de dados
usando TableAdapters ou objetos de comando (por exemplo, SqlCommand). Para carregar dados
nos DataSets criados usando ferramentas de design no Visual Studio, use TableAdapters. Para
carregar dados nos DataSets criados por programação, use adaptadores de dados. Se seu

aplicativo não usar DataSets, use objetos de comando para executar instruções SQL ou
procedimentos armazenados diretamente em um banco de dados.
Para obter mais informações Consulte
Preenchendo um DataSet usando um TableAdapter Como: preencher uma DataSet com dados
TableAdapters Visão Geral do Adaptador de Tabela
Preencher um DataSet com um adaptador de dados Populating a DataSet from a DataAdapter
Preenchendo DataSets
Se você criar um DataSet com uma ferramenta de design de em tempo de execução Visual Studio
(tais como o Dataset Designer ou o Assistente para Configuração da Fonte de Dados), então você
usar um TableAdapter para preenchê-lo. TableAdapters executam procedimentos armazenados
ou instruções SQL.
Se você criar um DataSet sem ferramentas em tempo de design, você deve utilizar adaptadores
de dados para preencher e atualizar os dados. (TableAdapters não são realmente classes no
.NET Framework, então não são adequados para trabalhar com DataSets que tenham sido
criados sem o uso de ferramentas em tempo de execução. Para obter mais informações sobre
carregar dados em DataSets com TableAdapters ou adaptadores de dados, consulte Como:
preencher uma DataSet com dados.
Consultas TableAdapter
Você pode executar consultas TableAdapter para preencher dados em DataSets (Mais
especificamente, para carregar dados para o DataTables que compõem um DataSet). Você pode
criar consultas TableAdapter usando o Assistente de configuração da consulta TableAdapter no
Dataset Designer. Consultas TableAdapter aparecem como métodos nomeados num
TableAdapter e são executados chamando o método TableAdapter. Para obter mais informações
sobre como criar e executar consultas TableAdapter, consulte as seguintes páginas:
• Como criar e executar uma instrução SQL que retorna linhas:

• Como criar e executar uma instrução SQL que retorna um único valor:
• Como: criar e executar uma instrução SQL que não retorna nenhum valor
• Como: Executar um Procedimento Armazenado que Retorna Linhas:
• Como: executar um procedimento armazenado que retorna um único valor
• Como executar um procedimento armazenado que não retorna valor:
Objetos Command
Objetos de comando (command) lhe dão a capacidade de executar instruções SQL e

procedimentos armazenados diretamente em um banco de dados, sem precisar de um DataSet,
TableAdapter, ou DataAdapter. (O termo objeto de comando refere-se ao comando específico
.NET Framework Data Provider que o aplicativo está usando. Por exemplo, se seu aplicativo
estiver usando o .NET Framework Data Provider para SQL Server, o objeto de comando poderia
ser SqlCommand.)

Você configura comandos para consultar dados usando instruções SQL ou procedimentos
armazenados, configurando a propriedade CommandType do comando de dados para um dos
valores na enumeração CommandType. Defina o CommandType. para Text para executar
instruções SQL, ou defina-o para StoredProcedure para executar procedimentos armazenados.
Em seguida, defina a propriedade CommandText como um instrução SQL ou como o nome do
procedimento armazenado. Seguida, você pode executar o comando de dados chamando um dos
métodos de execução (ExecuteReader, ExecuteScalar, ExecuteNonQuery).
Cada um dos .NET Framework Data Providers oferece um objeto comando otimizado para bancos
de dados específicos.
Usando comandos de dados, você pode fazer o seguinte em seu aplicativo:
• Executar comandos Select (selecionar) que retornam um resultado que você pode ler
diretamente, em vez de carregá-lo no DataSet. Para ler os resultados, use uma leitora de
dados (objeto OleDbDataReader, SqlDataReader, OdbcDataReader ou OracleDataReader),
que funciona como um cursor somente para leitura, somente encaminhamento ao qual você
pode vincular controles.. Esta é uma estratégia útil para reduzindo uso de memória e carregar
dados somente para leitura muito rapidamente.
• Executar comandos de definição de banco de dados (DDL) para criar, editar e remover
tabelas, procedimentos armazenados e outras estruturas de banco de dados. (Você deve ter
permissões para executar essas ações, é claro.)
• Executar comandos para obter informações de catálogo do banco de dados.
• Executar comandos SQL dinâmicos para atualizar, inserir ou excluir registros — em vez de
atualizar tabelas DataSet e depois copiar alterações para o banco de dados.
• Executar comandos que retornam um valor escalar (isto é, um valor único), como os
resultados de uma função agregada (SUM, COUNT, AVG, e assim por diante).
• Executar comandos que retornam dados de um banco de dados do SQL Server (versão
7.0 ou posterior) no formato XML. Um uso típico é executar uma consulta e obter novamente
dados em formato XML, aplicar um transformação XSLT a ele (para converter os dados em
HTML), e enviar os resultados para um navegador.
Propriedades de comando contêm todas as informações necessárias para executar um comando

em um banco de dados. Isso inclui:
• Uma conexão O comando referencia uma conexão que ele usa para se comunicar com
o banco de dados.
• O nome ou texto de um comando O comando inclui o texto real de uma intrução SQL
ou o nome de um procedimento armazenado para executar.
• Parâmetros Um comando pode exigir que você passe valores de parâmetro junto com
ele (parâmetros de entrada). O comando também pode retornar valores sob a forma de um
valor de retorno ou valores de parâmetro de saída. Cada comando tem um conjunto de
parâmetros que você pode definir ou ler individualmente para passar ou receber valores. Para
obter mais informações, consulte Como: Definir e Obter Parâmetros para Objetos de
Comando.
Você executa um comando usando um método apropriado para os resultados que você espera
que sejam retornados. Por exemplo, se você espera linhas, você chama o comando do método
ExecuteReader, que retorna registros em uma leitora de dados. Se você estiver executando um
comando UPDATE, INSERT, ou Delete, você chama o método do comando ExecuteNonQuery, que
retorna um valor indicando o número de linhas afetadas. Se você estiver executando uma função
agregada, como retornar a contagem de pedidos para um cliente, você chamar o método
ExecuteScalar.

Vários conjuntos de resultados
Um uso típico de um objeto de comando é retornar uma única tabela de dados (um conjunto de
linhas). Entretanto, comandos podem executar procedimentos que retornem vários conjuntos de
resultados. Isso pode acontecer de maneiras diferentes. Um maneira é que o comando referencie
um procedimento armazenado que retorne vários conjuntos de resultados. Como alternativa, o
comando pode conter duas (ou mais) instruções ou nomes de procedimentos armazenados.
Nesse caso, as instruções ou procedimentos são executados seqüencialmente e retornam vários
conjuntos de resultados com uma única chamada.
Se você especificar várias instruções ou procedimentos para um comando, elas devem todas ser
do mesmo tipo. Por exemplo, você pode executar sucessivas instruções SQL ou sucessivos
procedimentos armazenados. Entretanto, você não pode misturar chamadas de procedimentos
armazenados e instruções SQL no mesmo comando. Para obter mais informações, consulte
Retrieving Data Using a DataReader.
Observação
Para Oracle, o .NET Framework Data Provider for Oracle não oferece suporte a instruções
agrupadas SQL. Entretanto, ele não permite que você use vários parâmetros de saída REF
CURSOR para preencher um DataSet, cada em sua própria tabela de dados. Você deve definir os
parâmetros, marcá-los como parâmetros de saída, e indicar que eles são tipos de dados REF
CURSOR. Observe que você poderá usar o método Update quando o objeto OracleDataAdapter
está preenchido dos parâmetros REF CURSOR em um procedimento armazenado, pois Oracle
não fornece as informações necessárias para determinar quais os nomes da tabela e nomes de
coluna quando a instrução SQL é executada.
Segurança
Quando usando comandos de dados com uma propriedade CommandType definida como Text,
cuidadosamente verifique informações que são enviadas de um cliente antes passando-a para
seu banco de dados. Usuários mal-intencionados podem tentar enviar (inserir) instruções SQL
modificadas ou adicionais em um esforço para obter acesso não autorizado ou danificar o banco
de dados. Antes de você transferir a entrada do usuário a um banco de dados, sempre deverá
verificar se as informações são válidas. Uma prática recomendada consiste em sempre usar
consultas parametrizadas ou procedimentos armazenados quando possível. Para obter mais
informações, consulte Validating User Input.
Passo a passo: Preenchendo um DataSet com dados
Este explicação passo a passo cria um DataSet com uma tabela de dados e a preenche com
dados da tabela Customers no banco de dados de exemplo Northwind. O DataSet é preenchido
com dados chamando o método Fill de um TableAdapter.
• Criar um novo Windows Application.

• Criar e configurar um dataset com o Assistente para Configuração da Fonte de Dados.
• Criar um DataGridView ligado a dados arrastando a partir da janela Data Sources para um
formulário.
Pré-requisitos

Criando um Aplicativo Windows
A primeira etapa é criar um Windows Application.
Para criar o novo projeto do Windows
1. No Visual Studio, a partir do menu File, criar um novo Project.

2. Nomeie o projeto como DatasetWalkthrough.
O projeto DatasetWalkthrough é criado e adicionado ao Solution Explorer.
Criando o NorthwindDataSet
Esta etapa cria um dataset usando o Data Source Configuration Wizard baseado na tabela
Customers no banco de dados de exemplo Northwind. Você deve ter acesso ao banco de dados de
exemplo Northwind para criar a conexão. Para informações sobre como configurar o banco de

2. Na janela Data Sources, clique em Add New Data Source para iniciar o Data Source
3. Selecione Database na página Choose a Data Source Type, e em seguida clique em
Next.
-ou-
o Selecione New Connection para iniciar a caixa de diálogo Add/Modify
Connection. Para obter mais informações, consulte Add/Modify Connection Dialog Box
(General).
confidenciais (sensitive data), e clique em Next.
8. Selecione a tabela Customers, e clique em Finish.
O NorthwindDataSet é adicionado ao seu projeto e a tabela Customers aparece na janela
Data Sources.
Você pode criar controles com dados vinculados, arrastando itens da janela Data Sources para
um formulário no seu aplicativo do Windows.
Para criar um DataGridView acoplado à tabela Customers

• Arraste o nó principal de Customers da janela Data Sources para o Form1.
Um controle DataGridView e uma faixa-ferramenta (BindingNavigator) aparecem no formulário
para navegar pelos registros . Um NorthwindDataSet, CustomersTableAdapter, BindingSource,
e BindingNavigator aparecem na bandeja do componente.
Inspecionando o Código Gerado que Preenche o Dataset com Dados
Arrastando itens da janela Data Sources para um formulário adiciona automaticamente o código
correto para preencher o dataset no manipulador de eventos Form1_Load.
Para carregar dados em um dataset
1. No Solution Explorer, selecione o Form1, e clique no botão View Code.

2. Inspecione o manipulador de eventos Form1_Load. O método Fill do TableAdapter
preenche o dataset com dados.
C#
private void Form1_Load(object sender, EventArgs e) { // TODO: This line of code loads data into the
'northwindDataSet1.Customers' table. // You can move, or remove it, as needed.
this.customersTableAdapter1.Fill(this.northwindDataSet1.Customers); }
3. Opcionalmente, você pode copiar este código para outras partes do seu aplicativo onde
você precisar preencher o dataset.
Executando o Aplicativo
• Pressione F5 para executar o aplicativo.

• O dataset é preenchido com dados e é exibido no DataGridView.
Próximas etapas
Dependendo dos seus requisitos de aplicativo, há várias etapas que convém executar após criar
um formulário vinculado a dados. Alguns aprimoramentos que você pode fazer nesta explicação
passo a passo incluem:
• Adicionar funcionalida de pesquisa ao formulário. Para obter mais informações, consulte

Como: Adicionar uma Consulta Parametrizada a um Formulário em um Aplicativo do Windows.
• Adicionar funcionalidade para enviar atualizações de volta para o banco de dados. Para
obter mais informações, consulte Passo-a-Passo: Salvando Dados para um Banco de Dados
(Tabela Simples).
• Adicionar a tabela Orders ao dataset, selecionando Configure DataSet with Wizard de
dentro da janela Data Sources. Então adicione controles que exibem dados relacionados,
arrastando o nó Orders (aquele abaixo da coluna Fax dentro da tabela Customers) para o
formulário. Para obter mais informações, consulte Como: exibir dados relacionados em um
aplicativo Windows:.
Explicação passo a passo: Lendo dados XML no Dataset
ADO.NET fornece métodos simples para trabalhar com dados XML. Nesta explicação passo a
passo você criará um aplicativo do Windows que irá carregar dados XML em um DataSet. Então o
DataSet será exibido em uma DataGridView. Finalmente, um esquema XML com base no
conteúdo do arquivo XML será exibido em uma caixa de texto.

Este explicação passo a passo consiste das cinco etapas principais:
1. Criando um novo projeto.

2. Criar um arquivo XML a ser lido no DataSet.
3. Criando a interface do usuário.
4. Criando o DataSet, leia o arquivo XML, e o exiba em um controle DataGridView.
5. Adicionando código para exibir o esquema XML baseado no arquivo XML em um controle
TextBox.
Observação
As caixas de diálogo e comandos de menu que você ve podem diferir das descritas na Ajuda
dependendo das suas 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 Visual Studio
Settings.
Criar um novo projeto
Nesta etapa, você criará um projeto Visual Basic, Visual C#, ou Visual J# que irá conter esta
explicação passo a passo.
Para criar o novo projeto Windows

2. Nomeie o projeto ReadingXML.
O projeto ReadingXML é criado e adicionado no Solution Explorer.
Gere o arquivo XML a ser lido para o DataSet
Porque esta explicação passo a passo enfoca leitura de dados XML em um DataSet, o conteúdo
de um arquivo XML é fornecido.
Para criar o arquivo XML que será lido para o DataSet
1. No menu Project, escolha Add New Item.

2. Selecione XML File, nomeie o arquivo authors.xml, e clique em Add.
O arquivo XML carrega no designer e está pronto para edição.
3. Cole o seguinte código no editor abaixo da declaração XML:
<Authors_Table> <authors> <au_id>172-32-1176</au_id> <au_lname>White</au_lname>
<au_fname>Johnson</au_fname> <phone>408 496-7223</phone> <address>10932 Bigge
Rd.</address> <city>Menlo Park</city> <state>CA</state> <zip>94025</zip>
<contract>true</contract> </authors> <authors> <au_id>213-46-8915</au_id>
<au_lname>Green</au_lname> <au_fname>Margie</au_fname> <phone>415 986-
7020</phone> <address>309 63rd St. #411</address> <city>Oakland</city> <state>CA</state>
<zip>94618</zip> <contract>true</contract> </authors> <authors> <au_id>238-95-
7766</au_id> <au_lname>Carson</au_lname> <au_fname>Cheryl</au_fname> <phone>415

548-7723</phone> <address>589 Darwin Ln.</address> <city>Berkeley</city> <state>CA</state>
<zip>94705</zip> <contract>true</contract> </authors> <authors> <au_id>267-41-
2394</au_id> <au_lname>Hunter</au_lname> <au_fname>Anne</au_fname> <phone>408
286-2428</phone> <address>22 Cleveland Av. #14</address> <city>San Jose</city>
<state>CA</state> <zip>95128</zip> <contract>true</contract> </authors> <authors>
<au_id>274-80-9391</au_id> <au_lname>Straight</au_lname> <au_fname>Dean</au_fname>
<phone>415 834-2919</phone> <address>5420 College Av.</address> <city>Oakland</city>
<state>CA</state> <zip>94609</zip> <contract>true</contract> </authors> </Authors_Table>
4. No menu File, aponte para Save authors.xml.

Crie a interface de usuário
A interface do usuário para este aplicativo consistirá do seguinte:
• Um controle DataGridView que irá exibir o conteúdo do arquivo XML como dados.
• Um controle TextBox que exibirá o esquema XML para o arquivo XML.
• Dois controles Button.
o Um botão lê o arquivo XML para o DataSet e exibe-o no controle DataGridView.
o Um segundo botão extrai o esquema do DataSet, e por um StringWriter exibe-o no
controle TextBox.
Para adicionar controles ao formulário
1. Abra Form1 no modo Design.

2. No Toolbox, arraste os seguintes controles no formulário:
o Um controle DataGridView
o Um controle TextBox
o Dois controles Button
3. Defina as seguintes propriedades:
Controle Propriedade Configuração
TextBox1 Multiline true
ScrollBars Vertical
Button1 Name ReadXmlButton
Text Read XML
Button2 Name ShowSchemaButton
Text Show Schema
Crie o DataSet que irá receber os dados XML

No procedimento seguinte, você cria um novo DataSet chamado authors. Para obter mais
informações sobre DataSets, consulte DataSets no Visual Studio Overview.
Para criar um novo DataSet que receberá os dados XML
1. Com o arquivo fonte para Form1 selecionado em Solution Explorer, clique no botão View
Designer na barra de ferramentas Solution Explorer.
2. No Data Tab, Toolbox, arraste um DataSet. para Form1
3. Selecione Untyped dataset no Caixa de Diálogo Add Dataset, e, em seguida clique em
OK.
DataSet1 é adicionado à bandeja do componente.
4. Na janela Properties, defina as propriedades Name e DataSetName para
AuthorsDataSet.
Crie o manipulador de eventos para ler o XML para o DataSet
O botão Read XML lê o arquivo XML para o DataSet e define propriedades sobre o controle
DataGridView que acopla-o ao DataSet.
Para adicionar código ao manipulador de eventos ReadXmlButton_Click
1. No Solution Explorer, selecione Form1 e clique no View Designer botão da barra de

ferramentas Solution Explorer.
2. Clique duas vezes no botão Read XML.
O Code Editor abre no manipulador de eventos ReadXmlButton_Click.
3. Digite o seguinte código para o manipulador de eventos ReadXmlButton_Click:
C#
private void ReadXmlButton_Click(object sender, EventArgs e) { string filePath = "Complete path
where you saved the XML file"; AuthorsDataSet.ReadXml(filePath); dataGridView1.DataSource =
AuthorsDataSet; dataGridView1.DataMember = "authors"; }
4. Com o código do manipulador de eventos ReadXMLButton_Click, altere a entrada filepath =

para o caminho correto.
Crie o manipulador de eventos para exibir o esquema na Textbox
O botão Show Schema cria um objeto StringWriter que é preenchido com o esquema e exibido
no TextBox.
Para adicionar código ao manipulador de eventos ShowSchemaButton_Click
1. No Solution Explorer, selecione Form1 e clique no botão View Designer.

2. Clique duas vezes no botão Show Schema.
O Code Editor abre no manipulador de eventos ShowSchemaButton_Click.
3. Digite o seguinte código para o manipulador de eventos ShowSchemaButton_Click.
C#
private void ShowSchemaButton_Click(object sender, EventArgs e) { System.IO.StringWriter swXML
= new System.IO.StringWriter(); AuthorsDataSet.WriteXmlSchema(swXML); textBox1.Text =
swXML.ToString(); }

Testando
Agora você pode testar o formulário para certificar-se de que ele funciona comforme o esperado.
Para testar o formulário
1. Pressione F5 para executar o aplicativo.

2. Clique no botão Read XML.
O DataGridView exibe o conteúdo do arquivo XML.
3. Clique no botão Show Schema.
A caixa de texto exibe o esquema XML para o arquivo XML.
Próximas etapas
Esta explicação passo a passo mostra as noções básicas de ler um arquivo XML em um DataSet,
bem como criar um esquema com base no conteúdo do arquivo XML. Aqui estão algumas tarefas
• Edite os dados no DataSet e grave-os de volta como XML. Para obter mais informações,
consulte WriteXml.
• Edite os dados no DataSet e grave-os em um banco de dados. Para obter mais
informações, consulte Salvando dados.
Visão Geral da Exibição dados

Você exibe dados para os usuários do seu aplicativo pela vinculação de dados a controles em um
formulário. Você pode criar esses controles com dados vinculados arrastando itens da janela Data
Sources para um formulário no seu aplicativo do Windows.
Há vários componentes e processos que devem ser compreendidos quando for desenvolver
aplicativos do Windows com dados vinculados. Abaixo é um resumo das tarefas, objetos e caixas
de diálogo envolvidos na criação de aplicativos do Windows com dados vinculados. Para obter
mais informações, consulte Windows Forms Data Binding.
Tarefas envolvidas na exibição de dados em um formulário em um aplicativo do Windows
As tarefas a seguir mostram o processo típico que se segue para exibir dados em um formulário
em um aplicativo do Windows.
Tarefa Obter mais informações
Abrir a janela Data Sources Como abrir a janela Fontes de dados:
Adicionar uma fonte de dados no seu Clique em Add New Data Source no Janela de fontes de
projeto dados e complete a Assistente para Configuração da
Fonte de Dados
• Como: Conectar-se a Dados em um Banco de
Dados
• Como se conectar a dados em um objeto:
• Como: se conectar a dados em um serviço da

Web
• Como: Conectar-se a Dados em um Banco de
Dados SQL Server Express
• Como: Conectar a dados em um banco de dados
do Access:
Definir os itens na janela Data Como: Definir o controle a ser criado quando arrastado da
Sources para os controles que você janela Data Sources:
deseja que estejam criados
Arrastar itens da janela Data Sources • Como exibir dados em um controle Windows
para seu formulário Forms DataGridView:
• Como: Exibir Dados em controles individuais
Windows Forms
• Encadernação À dados para controles existente
como:
Formatar a maneira de controles Formatting and Advanced Binding Dialog Box

exibirem dados
Depois de ter criado um formulário que exibe dados, você pode desejar seguir uma das seguintes
tarefas:
Tarefa Para obter mais informações
Editar os dados na Editar dados no seu aplicativo (tenha em mente que alterações nos
fonte de dados dados em controles com dados vinculados são gravadas
subjacentes automaticamente no dataset, mas não são salvas automaticamente no
banco de dados subjacente.)
Validar alterações Validando dados

feitas nos dados
Salvar dados Salvando dados

atualizados de volta no
banco de dados
Fontes de dados
Fontes de dados representam os dados disponíveis para seu aplicativo e são criadas executando
o Assistente para Configuração da Fonte de Dados. Fontes de dados são criadas de bancos de
dados, serviços da Web ou objetos. Para obter mais informações, consulte Visão geral sobre
fontes de dados.
Janela de fontes de dados
Fontes de dados estão disponíveis para o projeto como itens em Janela de fontes de dados e
podem ser arrastadas para seu formulário para criar controles que exibem os dados subjacentes.

Antes de arrastar itens da janela Data Sources, especifique os controles a serem criados pelo
clique na lista suspensa para cada tabela e coluna e selecione o controle desejado. Para obter
mais informações, consulte Como: Definir o controle a ser criado quando arrastado da janela Data
Sources:.
Observação
Você pode alterar a lista de controles disponíveis para itens na janela Data Sources. Para obter
mais informações, consulte Como: Adicionar Controles Personalizados à Janela de Fonte de
Dados.
TableAdapters
TableAdapters são componentes gerados pelo designer criados pelo Visual Studio. Eles são
usados para preencher datasets (ou, mais especificamente, eles são usados para carregar dados
em DataTables que compõem um dataset e para atualizar o banco de dados pelo qual a
DataTable foi preenchida). TableAdapters são análogos a adaptadores de dados fortemente
tipados; eles fornecem comunicação entre seu aplicativo e seus dados. TableAdapters contêm a
conexão e comandos, ou instruções SQL, que são executados no armazenamento de dados
subjacentes. Para obter mais informações, consulte Visão Geral do Adaptador de Tabela.
Consultas de TableAdapter
Diferentemente de adaptadores de dados padrões, TableAdapters têm a capacidade para conter

várias consultas para preencher suas tabelas de dados associadas. Você pode definir tantas
consultas para um TableAdapter quantas seu aplicativo requerer, contanto que cada consulta
retorne dados que estejam de acordo com o mesmo esquema que sua tabela de dados
associada. Para obter mais informações, consulte Como: Criar Consultas TableAdapter:.
Marcas inteligentes de dados
Marcas inteligentes específicas para trabalhar com dados estão disponíveis em vários controles.
Quando certos controles são adicionados a um formulário, um conjunto de ações possíveis
relacionadas a dados estão disponíveis na marca inteligente. Para obter mais informações,
consulte Marcas Inteligentes de Dados.
Componente BindingSource
O componente BindingSource serve a dois propósitos. Primeiro, ele fornece uma camada de
engano ao vincular os controles no seu formulário aos dados. Controles no formulário são
vinculados ao componente BindingSource (em oposição aos sendo vinculados diretamente a
uma fonte de dados).
Além disso, o componente BindingSource pode gerenciar uma coleção de objetos. Adicionar um
tipo ao BindingSource cria uma lista do mesmo tipo.
Para obter mais informações sobre o componente BindingSource, consulte:
• BindingSource Component
• BindingSource Component Overview
• BindingSource Component Architecture
• BindingSource Component Sample

Controle BindingNavigator
Este componente fornece uma interface de usuário para navegar por dados em um aplicativo do
Windows. Para obter mais informações, consulte BindingNavigator Control (Windows Forms).
Controle DataGridView
O controle DataGridView permite que você exiba e edite dados tabulares de muitos tipos
diferentes de fontes de dados. Vinculação de dados ao controle DataGridView é realizada por
meio da propriedade DataSource. Para obter mais informações, consulte DataGridView Control
Overview (Windows Forms).
Passo-a-passo: Exibindo dados em um formulário em um aplicativo do Windows
Um dos cenários mais comuns no desenvolvimento de aplicativos é exibir dados num formulário
em um aplicativo Windows. Você pode exibir dados em um formulário arrastando itens do Janela
de fontes de dados para o formulário. Esta explicação passo a passo cria um formulário simples
que exibe dados de uma única tabela em vários controles individuais. Este exemplo usa a tabela
Customers do banco de dados de exemplo Northwind.

• Criando e configurando um DataSet com o Assistente para Configuração da Fonte de
Dados.
• Selecionando o controle a ser criado no formulário ao arrastar itens a partir da janela Data
Sources. Para obter mais informações, consulte Como: Definir o controle a ser criado quando
arrastado da janela Data Sources:.
• Criando um controle vinculado a dados, arrastando itens da janela Data Sources para seu
formulário.
Pré-requisitos
Criando o aplicativo Windows
A primeira etapa é para criar um projeto Windows Application.
Para criar o novo projeto do Windows Application

2. Nomeie o projeto DisplayingDataonaWindowsForm.
O projeto DisplayingDataonaWindowsForm é criado e adicionado Solution Explorer.
Criando a fonte de dados
Essa etapa cria uma fonte de dados usando o Data Source Configuration Wizard baseado na
tabela Customers no banco de dados de exemplo Northwind. Você deve ter acesso ao banco de

dados de exemplo Northwind para criar a conexão. Para informações sobre como configurar

disponível na lista drop-down, selecione-a.
-ou-
(General).
Data Sources.
Definindo os controles a serem criados
Para este explicação passo a passo os dados estarão em um layout Details onde dados são
exibidos em controles individuais. (A abordagem alternativa é o layout padrão Grid onde os dados
são exibidos em um controle DataGridView.)
Para definir o tipo subjacente para os itens na janela Data Sources
1. Expanda o nó Customers na janela Data Sources.

2. Altere o tipo subjacente da tabela Customers para Details selecionando Details na lista
drop-down no nó Customers. Para obter mais informações, consulte Como: Definir o
controle a ser criado quando arrastado da janela Data Sources:.
3. Altere o tipo suspenso da coluna CustomerID para um rótulo selecionando Label na lista
de controles no nó CustomerID.
Criando o formulário
Crie os controles com dados vinculados, arrastando itens da janela Data Sources para seu
formulário.
Para criar controles vinculado a dados no formulário
• Arraste o nó principal Customers da janela Data Sources para o formulário.

Controles com dados vinculados com rótulos descritivos aparecem no formulário, juntamente
com uma faixa de ferramenta (BindingNavigator) para navegar pelos registros. A

NorthwindDataSet, CustomersTableAdapter, BindingSource, e BindingNavigator aparecem
na bandeja do componente.
• Pressione F5.
• Navegue pelos registros usando o controle BindingNavigator.
Próximas etapas
Dependendo dos seus requisitos de aplicativo, há várias etapas que você pode desejar executar
após criar um Windows Form vinculado a dados (data-bound). Alguns aprimoramentos que você
poderia fazer a essa explicação passo a passo incluem:
• Adicionar funcionalidade de pesquisa ao formulário. Para obter mais informações, consulte

(Tabela Simples).
• Adicionando a tabela Orders para o DataSet, selecionando Configure DataSet with
Wizard de dentro da janela Data Sources. Em seguida, você pode adicionar controles que
exibem dados relacionados, arrastando o nó Orders (aquele abaixo da coluna Fax dentro da
tabela Customers) para o formulário. Para obter mais informações, consulte Como: exibir
dados relacionados em um aplicativo Windows:.
Explicação passo a passo: Exibindo Dados Relacionados em um Formulário em um Aplicativo

Windows
Em muitos cenários de aplicativo, você deseja trabalhar com dados que vem de mais de uma
tabela e, com freqüência, dados de tabelas relacionadas. Isto é, você deseja trabalhar com uma
relação pai-filho. Por exemplo, convém criar um formulário onde selecionar um registro de cliente
exibe os pedidos referentes a esse cliente. Exibir os registros relacionados no formulário é obtido,
definindo a propriedade DataSource do filho BindingSource para a pai BindingSource (não a
tabela filho), e definindo a propriedade DataMember do filho BindingSource para a relação de
dados que liga as tabelas pai e filho juntas.
• Criando um projeto Windows Application.

• Criando e configurando um DataSet em seu aplicativo baseado nas tabelas Customers e
Orders no banco de dados Northwind usando o Assistente para Configuração da Fonte de
Dados.
• Adicionando controles para exibir dados da tabela Customers.
• Adicionar controles para exibir a Orders baseado nos Customer selecionados.
• Teste o aplicativo, selecionando clientes diferentes e verificando que os pedidos corretos
são exibidos para o cliente selecionado.
Pré-requisitos

• Acesso ao banco de dados de exemplo Northwind. Para configurar bancos de dados de
exemplo, consulte COMO: Instalar Bancos de Dados de Exemplo.
Criando o projeto
Para criar o projeto do aplicativo do Windows

2. Nomeie o projeto RelatedDataWalkthrough.
O projeto RelatedDataWalkthrough é criado e adicionado ao Solution Explorer.
Criando o DataSet
Esta etapa cria um DataSet com base nas tabelas Customers e Orders do banco de dados de
exemplo Northwind.

-ou-
8. Selecione as tabelas Customers e Orders, e clique Finish.
Data Sources.
Criando controles para exibir dados da tabela Customers
Para criar controles para exibir os dados do cliente (customer) (registros pai)
1. Na janela Data Sources, selecione a tabela Customers, e clique na seta suspensa.

2. Escolha Details no menu.
3. Arraste o nó principal Customers da janela Data Sources na parte superior do Form1.
Controles com dados vinculados com rótulos descritivos aparecem no formulário,
juntamente com uma faixa de ferramenta. (BindingNavigator) para navegar pelos registros

Um NorthwindDataSet, CustomersTableAdapter, BindingSource, e BindingNavigator
aparecem na bandeja do componente.
Criando controles para exibir dados da tabela Orders
Para criar controles para exibir os pedidos (orders) para cada cliente (registros filho)
• Na janela Data Sources, expanda o nó Customers e selecione a última coluna na tabela

Customers, que é um nó expansível Orders, e arraste-o para a parte inferior do Form1.
Um DataGridView é adicionado ao formulário, e um novo BindingSource.
(OrdersBindingSource) e TableAdapter (OrdersTableAdapter) são adicionados à bandeja de
componentes.
Observação
Abra a Properties Window e selecione o OrdersBindingSource. Inspecione o DataSource e as

propriedades DataMember para ver como a ligação está configurada para exibir registros
relacionados. A DataSource está definida como CustomersBindingSource (a tabela pai do
BindingSource), em vez da tabela Orders. A propriedade DataMember é definida como
FK_Orders_Customers, que é o nome do objeto DataRelation que relaciona as tabelas juntas.

2. Selecione diferentes clientes usando o CustomersBindingNavigator para verificar que os
pedidos corretos são exibidos na DataGridView.

Próximas etapas
após criar um formulário de detalhes mestre. Você pode fazer um aperfeiçoamento nesta
explicação passo a passo, que é:
• Filtrando os registros Customers por adicionar parametrização à tabela Customers. Para

fazer isso, selecione qualquer controle que exibe dados da tabela Customers, clique na marca
inteligente, e escolha Add Query. Conclua a Caixa de Diálogo Construtora de Critérios de
Pesquisa. Para obter mais informações, consulte Como: Adicionar uma Consulta
Parametrizada a um Formulário em um Aplicativo do Windows.
Passo-a-passo: Criando um formulário para pesquisar dados em um aplicativo do Windows
Um cenário de aplicativo comum é exibir dados selecionados em um formulário. Por exemplo,

você pode desejar exibir os pedidos para um cliente específico ou os detalhes de uma ordem
específica. Nesse cenário, um usuário insere informações em um formulário, e em seguida, uma
consulta é executada com a entrada do usuário como parâmetro; ou seja, os dados são
selecionados com base em uma consulta parametrizada. A consulta retorna somente os dados
que satisfizerem aos critérios inseridos pelo usuário. Esta explicação passo a passo mostra como
criar uma consulta que retorne clientes de uma cidade específica, e modifica a interface do
usuário para que os usuários possam inserir um nome de cidade e pressionar um botão para
executar a consulta.
Usar consultas parametrizadas ajuda a tornar seu aplicativo eficiente, permitindo que o banco de
dados faça o trabalho no qual ele é melhor — filtrar registros rapidamente. Se, em contrapartida,
você solicitar um tabela de banco de dados inteira, transferi-la através da rede, e em seguida, usar
lógica do aplicativo para encontrar os registros que você deseja, seu aplicativo pode se tornar
lento ineficiente.
Você pode adicionar consultas parametrizadas a qualquer TableAdapter (e controles para aceitar
valores de parâmetro e executar a consulta) usando o Caixa de Diálogo Construtora de Critérios
de Pesquisa. Abra a caixa de diálogo selecionando o comando Add Query no menu Data (ou em
qualquer marca inteligente TableAdapter).

• Criação e configuração da fonte de dados em seu aplicativo com o Assistente para
Configuração da Fonte de Dados.
• Definição do tipo subjacente dos itens na Janela de fontes de dados. Para obter mais
informações, consulte Como: Definir o controle a ser criado quando arrastado da janela Data
Sources:.
• Criação de controles que exibem dados, arrastando itens a partir da janela Data Sources
em um formulário.
• Adição de controles para exibir os dados no formulário.
• Conclusão do Caixa de Diálogo Construtora de Critérios de Pesquisa.
• Inserção de parâmetros no formulário e execução da consulta parametrizada.
Pré-requisitos

Criando o aplicativo Windows
A primeira etapa é criar um Windows Application. Atribuir um nome para o projeto é opcional
nesta etapa mas nós lhe daremos um nome porque planejamos salvá-lo posteriormente.
Para criar o novo projeto do Aplicativo do Windows

2. Nomeie o projeto como WindowsSearchForm.
O projeto WindowsSearchForm projeto é criado e adicionado ao Solution Explorer.
Criando a Fonte de Dados
Essa etapa cria uma fonte de dados a partir de um banco de dados usando o Data Source
Configuration Wizard. Você deve ter acesso ao banco de dados de exemplo Northwind para criar
a conexão. Para informações sobre como configurar o banco de dados de exemplo Northwind,
consulte COMO: Instalar Bancos de Dados de Exemplo.

3. Selecione Database na página Choose a Data Source Type, e em seguida clique Next.
-ou-
(General).
confidenciais, e em seguida clique Next.
8. Selecione a Tablea Customers, e clique Finish.
Data Sources.
Criando o formulário
Você pode criar os controles vinculados a dados arrastando itens da janela Data Sources para
seu formulário.
Para criar controles vinculado a dados no formulário

2. Arraste o nó Customers da janela Data Sources para seu formulário.
Um DataGridView e uma faixa ferramenta (BindingNavigator) para navegar pelos registros
aparecem no formulário. Um NorthwindDataSet, CustomersTableAdapter, BindingSource, e
BindingNavigator aparecem na bandeja do componente.
Adicionando Parametrização (funcionalidade de pesquisa) à Consulta
Você pode adicionar uma cláusula WHERE à consulta original usando o Caixa de Diálogo
Construtora de Critérios de Pesquisa.
Para criar uma consulta parametrizada e controles para inserir os parâmetros
1. Selecione o controle DataGridView, e escolha Add Query no menu Data.

2. Digite FillByCity na área New query name no Caixa de Diálogo Construtora de Critérios
de Pesquisa.
3. Adicione WHERE City = @City à consulta na área Query Text.
A consulta deve ser semelhante à seguinte:
SELECT CustomerID, CompanyName, ContactName, ContactTitle, Address, City, Region,
PostalCode, Country, Phone, Fax
FROM Customers
WHERE City = @City
Observação
Fontes de dados OleDb e Access usam o ponto de interrogação '?' para denotar parâmetros,
portanto a cláusula WHERE teria esta aparência: WHERE City = ?
4. Clique OK para fechar a caixa de diálogo Search Criteria Builder.

Uma FillByCityToolStrip é adicionado ao formulário.
Executar o aplicativo abre o formulário pronto para receber o parâmetro como entrada.

2. Digite London na caixa de texto City e clique FillByCity.
A grade de dados é preenchida com clientes que atendem aos critérios de parametrização.
Neste exemplo, a grade de dados exibe clientes que têm um valor London na sua coluna
City.
Próximas etapas
após criar um formulário parametrizado. Alguns aprimoramentos que você pode fazer nesta
explicação passo a passo incluem:
• Adição de controles que exibem dados relacionados. Para obter mais informações,
consulte Como: exibir dados relacionados em um aplicativo Windows:.

• Edição do dataset para adicionar ou remover objetos de banco de dados. Para obter mais
informações, consulte Como editar um DataSet:.
Consulte também
Passo a passo: Criando uma tabela de pesquisa
Uma tabela de pesquisa (lookup table) é usada para exibir informações de uma tabela de acordo
com o valor de um campo de chave externo de outra tabela. Por exemplo, considere uma tabela
de pedidos em um banco de dados de vendas. Cada registro na tabela Pedidos inclui um
CódigoDoCliente indicando qual cliente colocou a ordem. O CódigoDoCliente é uma chave
externa apontando para um registro de cliente na tabela Clientes. Convém exibir o nome real dos
clientes, em vez do CódigoDoCliente, quando apresentar uma lista de pedidos (da tabela
Pedidos). Como o nome do cliente está na tabela Clientes, e você está apresentando dados da
tabela Pedidos, você precisa criar uma tabela de pesquisa, que recebe o valor CódigoDoCliente
da tabela Pedidos, e usa esse valor para navegar pelo relacionamento e retornar um valor mais
palpável, o nome do cliente. Esse conceito é conhecido como uma tabela de pesquisa.

• Selecionar o controle a ser criado no formulário ao arrastar itens a partir da janela Data
• Criando controles com dados vinculados, arrastando itens da janela Data Sources em um
formulário.
• Configurando uma tabela de pesquisa soltando uma tabela relacionada em um controle
vinculado por uma relação de chave externa.
Pré-requisitos
Para criar o novo projeto de Windows Application

2. Nomeie o projeto LookupTableWalkthrough.
O projeto LookupTableWalkthrough é criado e adicionado Solution Explorer.
Criando uma nova fonte de dados


- ou -
5. Se o seu banco de dados exigir uma senha, selecione a opção para incluir dados
8. Selecione as tabelas Customers e Orders, e clique Finish.
O NorthwindDataSet é adicionado ao seu projeto e as duas tabelas aparecem na janela
Data Sources .
Criando controles vinculados a dados no formulário
Para criar controles vinculados a dados no formulário

2. Altere o drop type da tabela Orders relacionada para Details selecionando Details na lista
de controles no nó Orders. Para obter mais informações, consulte Como: Definir o controle
a ser criado quando arrastado da janela Data Sources:.
3. Expanda o nó Orders relacionado e altere o drop type da coluna CustomerID para a uma
combo box selecionando ComboBox na lista de controles no nó CustomerID.
4. Arraste o nó Orders relacionado da janela Data Sources para o Form1.
Controles vinculados a dados com suas descrições aparecem no formulário, junto com um
tool strip (BindingNavigator) para navegar pelos registros. Um NorthwindDataSet,
CustomersTableAdapter, BindingSource, e BindingNavigator aparecem na caixa de
componentes.
Criando a tabela de pesquisa
Você estabelece a tabela de pesquisa, definindo propriedades na combo box CustomerID:
Para criar a funcionalidade de tabela de pesquisa no formulário
• Arraste o nó principal Customers da janela Data Sources diretamente para a combo box
CustomerID no Form1.
Observação
A tabela a seguir é somente para referência; as propriedades são definidas automaticamente
durante o arraste do procedimento acima. O designer define as propriedades a seguir conforme
descrito abaixo em " Explicação das configurações ". Dependendo das estruturas da sua tabela,
você talvez precise ajustar as propriedades para a sua tabela de pesquisa funcionar corretamente.
Propriedade Explicação sobre configuração
DataSource O Visual Studio define essa propriedade como o BindingSource criado para
a tabela que você arrastou para o controle (em vez do BindingSource criado
quando o controle foi criado).

Se você precisar fazer um ajuste, então defina essa propriedade como o
BindingSource da tabela com a coluna que você quer mostrar.
(CustomersBindingSource para este passo a passo.)
DisplayMember O Visual Studio define essa propriedade como a primeira coluna após a chave
primária que tem um tipo de dados string para a tabela que você arrastar para
o controle.
Se você precisar fazer um ajuste, defina essa propriedade como o nome da
coluna que você deseja exibir.
ValueMember O Visual Studio define esta propriedade como a primeira coluna participante
da chave primária, ou a primeira coluna na tabela se nenhuma chave estiver
definida.
Se você precisar fazer um ajuste, defina essa propriedade como a chave
primária na tabela com a coluna que você deseja exibir.
SelectedValue O Visual Studio define essa propriedade como a coluna original arrastada da
janela Data Sources.
Se você precisar fazer um ajuste, defina essa propriedade como a coluna de
chave externa na tabela relacionada. (CustomerID na tabela Orders para esse
passo a passo.)
1. Pressione F5.
2. Navegue pelos pedidos e certifique-se de que a combo box CustomerID exibe o
CompanyName da tabela Customers para cada pedido (em vez da coluna CustomerID da
tabela Orders).
Próximas etapas
Dependendo dos requisitos do seu aplicativo, há várias etapas que você pode querer executar
após criar um formulário vinculado a dados. Alguns aprimoramentos que você pode fazer nesse
passo a passo incluem:
• Adicionar funcionalidade de pesquisa ao formulário. Para obter mais informações, consulte

(Tabela Simples).
• Adicionar a tabela Orders para o dataset selecionando Configure DataSet with Wizard de
dentro da janela Data Sources. Em seguida, você pode adicionar controles que exibem dados
relacionados arrastando o nó Orders relacionado (aquele abaixo da coluna Fax dentro da
tabela Customers) para o formulário. Para obter mais informações, consulte Como: exibir
dados relacionados em um aplicativo Windows:.
Passo a passo: Criando um Controle de Usuário que Suporta Ligação de Dados Simples
Ao exibir dados em formulários em aplicativos Windows, você pode escolher controles existentes
da Toolbox ou você pode criar controles personalizados se seu aplicativo requer funcionalidade
que não está disponível nos controles padrão. Este explicação passo a passo mostra como criar
um controle que implementa o DefaultBindingPropertyAttribute. Controles que implementam o
DefaultBindingPropertyAttribute podem conter uma propriedade que pode ser vinculada a
dados. Esses controles são semelhantes aos de um TextBox ou CheckBox

Para obter mais informações sobre criação de controle, consulte Developing Windows Forms
Controls at Design Time.
Ao criar controles para uso em cenários de vinculação de dados, você precisa implementar um
dos seguintes atributos de vinculação de dados:
Uso atributo DataBinding

Implementar o DefaultBindingPropertyAttribute em controles simples, como a TextBox, que
exibe uma única coluna (ou propriedade) de dados. (Esse processo é descrito nesta página de
explicação passo a passo.)
Implementar o ComplexBindingPropertiesAttribute nos controles, como o DataGridView, que exibe
listas (ou tabelas) de dados Para obter mais informações, consulte Passo a passo: Criando um
Controle de Usuário que Suporta Ligação de Dados Complexa.
Implementar o LookupBindingPropertiesAttribute nos controles, como a ComboBox, que exibe
listas (ou tabelas) de dados, mas também precisa apresentar uma única coluna ou propriedade.
Para obter mais informações, consulte Passo a passo: Criando um Controle de Usuário que
Suporta Pesquisa de Ligação de Dados.
Esta explicação passo a passo cria um controle simples que exibe dados de uma única coluna em
uma tabela. Este exemplo usa a coluna Phone da tabela Customers do banco de dados de exemplo
Northwind. O controle de usuário simples irá exibir números de telefone do cliente em um padrão
de formato número telefônico usando uma MaskedTextBox e configurando a máscara para um
número de telefone
Durante esta explicação passo a passo, você aprenderá como:

• Adicionar um novo User Control para o projeto.
• Criar o controle de usuário visualmente .
• Implementar o atributo DefaultBindingProperty.
• Criar um DataSet com o Assistente para Configuração da Fonte de Dados.
• Definir a coluna Phone na janela Data Sources para usar o novo controle.
• Criar um formulário para exibir dados no novo controle.
Pré-requisitos
• Acessar o banco de dados de exemplo Northwind. Para obter mais informações, consulte
Criando um Aplicativo do Windows
A primeira etapa é para criar um Windows Application.

2. Nome do projeto SimpleControlWalkthrough.

O projeto SimpleControlWalkthrough é criado e adicionado ao Solution Explorer.
Adicionar um Controle de Usuário ao Projeto
Esta explicação passo a passo cria um simples controle de dados-ligáveis de um User Control
para adicionar um item User Control ao projeto SimpleControlWalkthrough.
Para adicionar um controle de usuário ao projeto
1. No menu Project, escolha Add User Control.

2. Digite PhoneNumberBox na área Nome e clique em Add.
O controle PhoneNumberBox é adicionado ao Solution Explorer e abre no designer.
Criando o Controle PhoneNumberBox
Esta explicação passo a passo expande na existência de MaskedTextBox para criar o controle
PhoneNumberBox.
Para criar o controle PhoneNumberBox
1. Arraste um MaskedTextBox do Toolbox na superfície do design do controle de usuário.

2. Selecione a marca inteligente no MaskedTextBox apenas arrastando e escolha Set Mask.
3. Selecione Phone number na caixa de diálogo Input Mask e clique em OK para definir a
máscara.
Adicionando o Atributo de Vinculação de Dados Requerido
Para simples controles que suportam DataBinding, implemente o

DefaultBindingPropertyAttribute.
Para implementar o atributo DefaultBindingProperty
1. Alterne o controle PhoneNumberBox para modo de exibição do código. (No menu View,
escolha Code.)
2. Substitua o código no PhoneNumberBox com o seguinte:
C#
using System.Windows.Forms; namespace CS {
[System.ComponentModel.DefaultBindingProperty("PhoneNumber")] public partial class
PhoneNumberBox : UserControl { public string PhoneNumber { get{ return maskedTextBox1.Text; }
set{ maskedTextBox1.Text = value; } } public PhoneNumberBox() { InitializeComponent(); } } }
J#
package JSL; /**@attribute System.ComponentModel.DefaultBindingProperty("Text") */ public class

PhoneNumberBox extends System.Windows.Forms.UserControl { /**@property */ public String
get_Text() { return maskedTextBox1.get_Text(); } /**@property */ public void set_Text(String value)
{ this.maskedTextBox1.set_Text(value); } public PhoneNumberBox() { InitializeComponent(); }
private System.Windows.Forms.MaskedTextBox maskedTextBox1; private
System.ComponentModel.IContainer components; #region Component Designer generated code

protected void Dispose(boolean disposing) { if (disposing) { if (components != null) {
components.Dispose(); } } super.Dispose(disposing); } private void InitializeComponent() {
this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox(); this.SuspendLayout(); // //
maskedTextBox1 //
this.maskedTextBox1.set_CutCopyMaskFormat(System.Windows.Forms.MaskFormat.IncludeLiteral
s); this.maskedTextBox1.set_HidePromptOnLeave(false); this.maskedTextBox1.set_Location(new
System.Drawing.Point(26, 25)); this.maskedTextBox1.set_Mask("(999) 000-0000");
this.maskedTextBox1.set_Name("maskedTextBox1"); this.maskedTextBox1.set_Size(new
System.Drawing.Size(100, 20)); this.maskedTextBox1.set_TabIndex(0);
this.maskedTextBox1.set_TextMaskFormat(System.Windows.Forms.MaskFormat.IncludeLiterals);
// // PhoneNumberBox // this.set_AutoScaleDimensions(new System.Drawing.SizeF(6F, 13F));
this.set_AutoScaleMode(System.Windows.Forms.AutoScaleMode.Font);
this.get_Controls().Add(this.maskedTextBox1); this.set_Name("PhoneNumberBox");
this.ResumeLayout(false); this.PerformLayout(); } #endregion }
3. No menu Build, escolha Build Solution.

Criando Uma Fonte de Dados do Seu Banco de Dados
Esta etapa usa o Data Source Configuration Wizard para criar uma fonte de dados com base na
tabela Customers, no banco de dados de exemplo Northwind. Você deve ter acesso ao banco de

3. Selecione Database na página Choose a Data Source Type e clique Next.
Ou
(General).
confidenciais e clique Next.
8. Selecione a tabela Customers e clique Finish.
Data Sources.
Definindo a Coluna de Telefone Para usar o Controle PhoneNumberBox
Dentro da janela Data Sources você pode definir o controle a ser criado antes de arrastar itens
para seu formulário.

Para definir a coluna telefone para vincular ao controle PhoneNumberBox
1. Abra Form1 no designer.

3. Clique na seta suspensa no nó Customers e escolha Details a partir da lista controle.
4. Clique na seta suspensa na coluna Phone e escolha Customize.
5. Selecione o PhoneNumberBox da lista de Associated Controls na caixa de diálogo Data
UI Customization Options.
6. Clique na seta suspensa na coluna Phone e escolha PhoneNumberBox.
Você pode criar os controles com dados vinculados, arrastando itens da janela Data Sources
para o formulário.
• Arraste o nó Customers principal da janela Data Sources para o formulário e verifique

que o controle PhoneNumberBox é usado para exibir os dados na coluna Phone.
Controles com dados vinculados com rótulos descritivos aparecem no formulário, juntamente
com uma faixa de ferramenta (BindingNavigator) para navegar pelos registros.
NorthwindDataSet, CustomersTableAdapter, BindingSource e BindingNavigator aparecem na
bandeja do componente.
Executando o Aplicativo

Próximas etapas
depois de criar um controle que oferece suporte a vinculação de dados. Algumas etapas próximas
típicas incluem:
• Colocar os controles personalizados em uma biblioteca de controle para você poder

reutilizá-los em outros aplicativos. Para obter mais informações, consulte Windows Control
Library Template.
• Criar controles que suportam o mais complexo cenários de vinculação de dados. Para
obter mais informações, consulte Passo a passo: Criando um Controle de Usuário que Suporta
Ligação de Dados Complexa e Passo a passo: Criando um Controle de Usuário que Suporta
Pesquisa de Ligação de Dados.
Consulte também
Passo a passo: Criando um Controle de Usuário que Suporta Ligação de Dados Complexa
Ao exibir dados em formulários em aplicativos Windows, você pode escolher os controles

existentes do Toolbox, ou você pode criar controles personalizados se seu aplicativo requer
funcionalidade que não estão disponíveis nos controles padrão. Esta explicação passo a passo
mostra como criar um controle que implementa o ComplexBindingPropertiesAttribute. Os controles
que são implementados do ComplexBindingPropertiesAttribute contêm o DataSource e que a

propriedade DataMember pode ser vinculada aos dados. Esses controles são semelhantes aos um
DataGridView ou ListBox.
Para obter mais informações sobre controle de criação, consulte Developing Windows Forms
Ao criar controles para uso em cenários de ligação de dados será preciso implementar um dos
seguintes atributos de vinculação de dados:
Uso do atributo DataBinding
Implementar os simples controles DefaultBindingPropertyAttribute, como TextBox, que exibir uma

única coluna (ou propriedade) de dados. Para obter mais informações, consulte Passo a passo:
Criando um Controle de Usuário que Suporta Ligação de Dados Simples.
Implementar os controle ComplexBindingPropertiesAttribute, como DataGridView, que exibem

listas (ou tabelas) de dados. (Esse processo é descrito nesta página de explicação passo a
passo.)
Implementar os controles LookupBindingPropertiesAttribute, como ComboBox, que exibir listas (ou

tabelas) de dados, mas também precisa apresentar uma única coluna ou propriedade. Para obter
mais informações, consulte Passo a passo: Criando um Controle de Usuário que Suporta
Pesquisa de Ligação de Dados.
Esta explicação passo a passo cria um controle que exibe linhas de dados de uma tabela
complexa. Este exemplo usa a tabela Customers do banco de dados de exemplo Northwind. O
complexo controle de usuário exibirá a tabela Clientes no controle personalizado DataGridView.

• Criar visualmente o controle de usuário.
• Implementar o atributo ComplexBindingProperty.
• Criar um dataset com o Assistente para Configuração da Fonte de Dados.
• Definir a tabela Customers no Janela de fontes de dados para usar os novos controle
complexos.
• Adicionar o novo controle, arrastando o Data Sources Window no Form1.
Pré-requisitos
A primeira etapa para criar um Windows Application.

1. No Visual Studio, a partir do menu File, crie um novo Project.
2. Nomeie o projeto como ComplexControlWalkthrough.
O projeto ComplexControlWalkthrough é criado e adicionado Solution Explorer.
Devido esta explicação passo a passo criar um controle de ligação de dados complexa do User
Control, você deve adicionar um item User Control no projeto
1. No menu Project, escolha Add User Control.

2. Digite ComplexDataGridView na área Name, e clique Add.
O controle ComplexDataGridView é adicionado ao Solution Explorer e abre no designer.
Criar o controle ComplexDataGridView
Adicione a esta etapa um DataGridView para o controle de usuário
Para criar o controle ComplexDataGridView
• Arraste um DataGridView na superfície do design do controle de usuário do Toolbox

Adicionando o atributo de vinculação de dados requerido
Para controles complexos que suportam a vinculação de dados, você pode implementar o
ComplexBindingPropertiesAttribute.
Para implementar o atributo ComplexBindingProperties
1. Alterne o controle ComplexDataGridView para modo de exibição do Código. (No menu

View, selecione Code.)
2. Substituir o código em ComplexDataGridView com o seguinte:
C#
[System.ComponentModel.ComplexBindingProperties("DataSource", "DataMember")] public partial
class ComplexDataGridView : UserControl { public object DataSource { get{ return
dataGridView1.DataSource; } set{ dataGridView1.DataSource = value; } } public string DataMember {
get{ return dataGridView1.DataMember; } set{ dataGridView1.DataMember = value; } } public
ComplexDataGridView() { InitializeComponent(); } } }
J#
package JSL; /**@attribute System.ComponentModel.ComplexBindingProperties("DataSource",

"DataMember") */ public class ComplexDataGridView extends System.Windows.Forms.UserControl {
/**@property */ public Object get_DataSource() { return dataGridView1.get_DataSource(); }
/**@property */ public void set_DataSource(Object value) { dataGridView1.set_DataSource(value); }
/**@property */ public String get_DataMember() { return dataGridView1.get_DataMember(); }
/**@property */ public void set_DataMember(String value) {

dataGridView1.set_DataMember(value); } public ComplexDataGridView() { InitializeComponent(); }
private System.Windows.Forms.DataGridView dataGridView1; private
this.dataGridView1 = new System.Windows.Forms.DataGridView();
((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
this.SuspendLayout(); // // dataGridView1 //
this.dataGridView1.set_ColumnHeadersHeightSizeMode(System.Windows.Forms.DataGridViewColu
mnHeadersHeightSizeMode.AutoSize);
this.dataGridView1.set_ImeMode(System.Windows.Forms.ImeMode.Disable);
this.dataGridView1.set_Location(new System.Drawing.Point(16, 16));
this.dataGridView1.set_Name("dataGridView1"); this.dataGridView1.set_Size(new
System.Drawing.Size(240, 150)); this.dataGridView1.set_TabIndex(0); // // ComplexDataGridView
// this.set_AutoScaleDimensions(new System.Drawing.SizeF(6F, 13F));
this.get_Controls().Add(this.dataGridView1); this.set_Name("ComplexDataGridView");
this.set_Size(new System.Drawing.Size(307, 205));
((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
this.ResumeLayout(false); } #endregion }

Crie uma fonte de dados no seu banco de dados
Esta etapa usa o Data Source Configuration Wizard para criar uma fonte de dados com base na
tabela Customers, no banco de dados de exemplo Northwind. Você deve ter acesso ao banco de

disponível na lista suspensa, a selecione.
Ou-

Data Sources.
Definindo a tabela de Clientes para usar o controle ComplexDataGridView
Dentro da janela Data Sources você pode definir o controle a ser criado, antes de arrastar itens
Para definir a tabela de Clientes como vinculo do controle ComplexDataGridView
1. Abra o Form1 no designer.

3. Clique na seta suspensa no nó Customers e escolha Customize.
4. No ComplexDataGridView selecione da lista de Associated Controls na caixa de diálogo
Data UI Customization Options.
5. Clique na seta suspensa na tabela Customers e escolha ComplexDataGridView a partir da
lista de controle.
Adicionar os controles ao formulário
• Arraste o nó principal Customers da janela Data Sources para o formulário e verifique

que o controle ComplexDataGridView é usado para exibir os dados da tabela.

Próximas etapas
Dependendo dos requisitos de seu aplicativo, há várias etapas que você pode desejar executar
depois de criar um controle que suporta ligação de dados. Algumas próximas etapas típicas
incluem:
• Colocar os controles personalizados em uma biblioteca de controle para você possa

reutilizá-los em outros aplicativos. Para obter mais informações, consulte Windows Control
Library Template.
• Criando controles que suportam cenários de pesquisa. Para obter mais informações,
consulte Passo a passo: Criando um Controle de Usuário que Suporta Pesquisa de Ligação de
Dados.
Consulte também
Passo a passo: Criando um Controle de Usuário que Suporta Pesquisa de Ligação de Dados
Ao exibir dados no Windows Forms, você pode escolher os controles existentes a partir da caixa
de ferramentas, ou você pode criar controles personalizados se seu aplicativo requer uma
funcionalidade não disponível nos controles padrão. Esta explicação passo a passo mostra como
criar um controle que implementa o LookupBindingPropertiesAttribute. Os controles que

implementam o LookupBindingPropertiesAttribute pode conter três propriedades que podem
ser vinculadas a dados. Esses controles são semelhantes aos um ComboBox.
Para obter mais informações sobre a criação de controles, consulte Developing Windows Forms
Ao criar controles para uso em cenários de ligação de dados você precisará implementar um dos
seguintes atributos do databinding:
Uso do atributo DataBinding
Implementar o DefaultBindingPropertyAttribute em controles simples, como o TextBox, que exibi

uma única coluna (ou propriedade) dos dados. Para obter mais informações, consulte Passo a
passo: Criando um Controle de Usuário que Suporta Ligação de Dados Simples.
Implementar os controles ComplexBindingPropertiesAttribute, como o DataGridView, que exibe

listas (ou tabelas) de dados. Para obter mais informações, consulte Passo a passo: Criando um
Controle de Usuário que Suporta Ligação de Dados Complexa.
Implementar os controles no LookupBindingPropertiesAttribute, como o ComboBox, que exibi

listas (ou tabelas) de dados, mas também é necessário para apresentar uma única coluna ou
propriedade (Esse processo é descrito nesta página na explicação passo a passo.)
Esta explicação passo a passo cria um controle de pesquisa que vincula dados de duas tabelas.
Este exemplo usa as tabelas do banco de dados Northwind Customers e Orders. O controle
pesquisa estará acoplado ao campo CustomerID da tabela Orders. Ele usará este valor para
pesquisar o CompanyName na tabela Customers.

• Criar visualmente o controle de usuário.
• Implementar o atributo LookupBindingProperty.
• Criar um dataset com o Assistente para Configuração da Fonte de Dados.
• Definir a coluna CustomerID na tabela Orders na janela Data Sources para usar o novo
controle.
• Criar um formulário para exibir dados no novo controle.
Pré-requisitos
Criando um aplicativo Windows

1. No Visual Studio, a partir do menu File, crie um novo Project.
2. Nome do projeto LookupControlWalkthrough.
O projeto LookupControlWalkthrough é criado e adicionado Solution Explorer.
Esta explicação passo a passo cria um controle de pesquisa User Control, para adicionar um
item User Control ao projeto LookupControlWalkthrough
1. No menu Project, selecione Add User Control.

2. Digite LookupBox na área Name, e clique Add.
O controle LookupBox é adicionado ao Solution Explorer e abre no designer.
Criar o controle LookupBox
Para criar o controle LookupBox
• Arraste um ComboBox do Toolbox para a superfície de design do controle de usuário.

Adicionando o atributo de vinculação de dados requerido
Para os controles de pesquisa que suporta a vinculação de dados, você pode implementar o
LookupBindingPropertiesAttribute.
Para implementar o atributo LookupBindingProperties
1. Alternar o controle LookupBox para modo de exibição do código. (No menu View, escolha
Code).
2. Substitua o código no LookupBox com o seguinte:
C#
[System.ComponentModel.LookupBindingProperties("DataSource", "DisplayMember",
"ValueMember", "LookupMember")] public partial class LookupBox : UserControl { public object
DataSource { get{ return comboBox1.DataSource; } set{ comboBox1.DataSource = value; } } public
string DisplayMember { get{ return comboBox1.DisplayMember; } set{ comboBox1.DisplayMember =
value; } } public string ValueMember { get{ return comboBox1.ValueMember; } set{
comboBox1.ValueMember = value; } } public string LookupMember { get{ return
comboBox1.SelectedValue.ToString(); } set{ comboBox1.SelectedValue = value; } } public
LookupBox() { InitializeComponent(); } } }
J#
package JSL; /**@attribute System.ComponentModel.LookupBindingProperties("DataSource",

"DisplayMember", "ValueMember", "LookupMember") */ public class LookupBox extends
System.Windows.Forms.UserControl { /**@property */ public Object get_DataSource() { return
comboBox1.get_DataSource(); } /**@property */ public void set_DataSource(Object value) {
comboBox1.set_DataSource(value); } /**@property */ public String get_DisplayMember() { return

comboBox1.get_DisplayMember(); } /**@property */ public void set_DisplayMember(String value) {
comboBox1.set_DisplayMember(value); } /**@property */ public String get_ValueMember() { return
comboBox1.get_ValueMember(); } /**@property */ public void set_ValueMember(String value) {
comboBox1.set_ValueMember(value); } /**@property */ public String get_LookupMember() { return
comboBox1.get_SelectedValue().ToString(); } /**@property */ public void
set_LookupMember(String value) { comboBox1.set_SelectedValue(value); } public LookupBox() {
InitializeComponent(); } private System.Windows.Forms.TextBox DisplayMemberBox; private
System.Windows.Forms.TextBox ValueMemberBox; private System.Windows.Forms.TextBox
SelectedValueBox; private System.Windows.Forms.ComboBox comboBox1; private
this.DisplayMemberBox = new System.Windows.Forms.TextBox(); this.ValueMemberBox = new
System.Windows.Forms.TextBox(); this.SelectedValueBox = new System.Windows.Forms.TextBox();
this.comboBox1 = new System.Windows.Forms.ComboBox(); this.SuspendLayout(); // //
DisplayMemberBox // this.DisplayMemberBox.set_Location(new System.Drawing.Point(14, 15));
this.DisplayMemberBox.set_Name("DisplayMemberBox"); this.DisplayMemberBox.set_Size(new
System.Drawing.Size(100, 20)); this.DisplayMemberBox.set_TabIndex(0); // // ValueMemberBox //
this.ValueMemberBox.set_Location(new System.Drawing.Point(14, 42));
this.ValueMemberBox.set_Name("ValueMemberBox"); this.ValueMemberBox.set_Size(new
System.Drawing.Size(100, 20)); this.ValueMemberBox.set_TabIndex(1); // // SelectedValueBox //
this.SelectedValueBox.set_Location(new System.Drawing.Point(14, 69));
this.SelectedValueBox.set_Name("SelectedValueBox"); this.SelectedValueBox.set_Size(new
System.Drawing.Size(100, 20)); this.SelectedValueBox.set_TabIndex(2); // // comboBox1 //
this.comboBox1.set_FormattingEnabled(true); this.comboBox1.set_Location(new
System.Drawing.Point(14, 107)); this.comboBox1.set_Name("comboBox1");
this.comboBox1.set_Size(new System.Drawing.Size(121, 21)); this.comboBox1.set_TabIndex(3); // //
LookupBox // this.set_AutoScaleDimensions(new System.Drawing.SizeF(6F, 13F));
this.get_Controls().Add(this.comboBox1); this.get_Controls().Add(this.SelectedValueBox);
this.get_Controls().Add(this.ValueMemberBox); this.get_Controls().Add(this.DisplayMemberBox);
this.set_Name("LookupBox"); this.ResumeLayout(false); this.PerformLayout(); } #endregion }

Crie uma fonte de dados no seu banco de dados
Essa etapa cria uma fonte de dados usando o Data Source Configuration Wizard baseado nas
tabelas Orders e Customers no banco de dados de exemplo Northwind. Você deve ter acesso ao
banco de dados de exemplo Northwind para criar a conexão. Para informações sobre como
configurar dados de exemplo Northwind, consulte COMO: Instalar Bancos de Dados de Exemplo.


4. Na página Choose your Data Connection e siga um destes procedimentos:
Ou-
(General).
8. Selecione as tabelas Customers e Orders, e clique Finish
aparecem na janela do Data Sources
Defini a coluna CustomerID da tabela Pedidos para usar o controle LookupBox
Dentro da janela Data Sources você pode definir o controle a ser criado antes de arrastar itens
Definir vinculação da coluna CustomerID ao controle LookupBox
1. Abra o Form1 no designer.

3. Expanda o nó Orders (aquele nó Customers abaixo da coluna Fax).
4. Clique na seta suspensa no nó Orders e escolha Details a partir da lista de controle.
5. Clique na seta suspensa na coluna CustomerID (no nó Orders) e escolha Customize.
6. Do LookupBox selecione a lista de Associated Controls na caixa de diálogo Data UI
Customization Options.
7. Clique em OK.
8. Clique na seta suspensa na coluna CustomerID e escolha LookupBox.
Adicione controles ao formulário
para Form1.
Para criar controles de dados vinculados no Windows Form
• Arraste o nó Orders da janela Data Sources para o Windows Form e verifique se o

controle LookupBox está sendo utilizado para exibir os dados na coluna CustomerID.
Vinculando o controle para pesquisar o CompanyName na tabela Customers
Para configurar as vinculações de pesquisa
• Selecione o nó principal Customers na janela Data Sources e arraste-à

CustomerIDLookupBox. No Form1

Configura a ligação de dados para exibir o CompanyName a partir do Customers e enquanto
mantém o valor CustomerID da tabela Orders. Para obter mais informações, consulte Como:
Criar Tabelas de Pesquisa.

• Navegue em alguns registros e verifique se a CompanyName aparece no controle
LookupBox
Consulte também
Ligação de Objeto no Visual Studio

O Visual Studio fornece ferramentas em tempo de design para trabalharem com objetos
personalizados (em oposição a Datasets e serviços da Web) como a fonte de dados em seu
aplicativo.
O único requisito de objetos personalizados para trabalharem com as ferramentas de design de

dados no Visual Studio é que o objeto precisa pelo menos de uma propriedade public. Nenhum
construtor específico ou atributos são necessários a objetos personalizados para trabalharem com
ferramentas tais como a janela Data Sources.
Enquanto houver incontáveis maneiras de implementar a lógica do aplicativo ao trabalhar com

objetos como uma fonte de dados, existirão algumas poucas operações padrões que podem ser
simplificadas usando os novos objetos TableAdapter gerados do Visual Studio. Esta página
explica como implementar esses processos padrões usando TableAdapters; ela não se destina a
ser um guia de criação de seus objetos personalizados. Por exemplo, você irá normalmente
executar as seguintes operações padrões independentemente da implementação específica de
seus objetos, ou lógica do aplicativo:
• Carregando dados em objetos (normalmente de um banco de dados)

• Criar uma coleção tipada de objetos
• Adição de objetos para uma coleção e remoção de objetos de uma coleção
• Exibir os dados de objeto aos usuários em um formulário
• Alteração/edição de dados em um objeto
• Salvar dados a partir objetos de volta ao banco de dados
Observação
Para melhor entender, e fornecer contexto para os exemplos nesta página, é recomendável que
você aperfeiçoe o seguinte: Passo-a-Passo: Conectando a dados em Objetos. Esta explicação
passo a passo cria os objetos discutidos nesta página de ajuda.
Carregando dados em objetos
Para esse exemplo, você carrega dados para os objetos usando TableAdapters. Por padrão,
TableAdapters são criados com dois tipos de métodos que buscam dados de um banco de dados
e preenchem tabelas de dados.

• O método TableAdapter.Fill preenche uma tabela de dados existente com os dados
retornados.
• O método TableAdapter.GetData retorna uma nova tabela dados preenchida com dados.
A maneira mais fácil de carregar os objetos personalizados com dados é chamar o método
TableAdapter.GetData, efetuar um loop através da coleção de linhas na tabela de dados retornados,
e preencher cada objeto com os valores em cada linha. Você pode criar um método GetData que
retorna uma tabela de dados preenchida para qualquer consulta adicionada a um TableAdapter.
Observação
Visual Studio nomeia as consultas TableAdapter Fill e GetData por padrão, mas esses nomes
podem ser alterados para qualquer nome de método válido.
O exemplo a seguir mostra como percorrer as linhas de uma tabela de dados e preencher um
objeto com dados:
Para obter um exemplo de código completo, consulte Passo-a-Passo: Conectando a dados em

Objetos.
C#
private void LoadCustomers() { NorthwindDataSet.CustomersDataTable customerData =
customersTableAdapter1.GetTop5Customers(); foreach (NorthwindDataSet.CustomersRow customerRow in
customerData) { Customer currentCustomer = new Customer(); currentCustomer.CustomerID =
customerRow.CustomerID; currentCustomer.CompanyName = customerRow.CompanyName; if
(customerRow.IsAddressNull() == false) { currentCustomer.Address = customerRow.Address; } if
(customerRow.IsCityNull() == false) { currentCustomer.City = customerRow.City; } if
(customerRow.IsContactNameNull() == false) { currentCustomer.ContactName =
customerRow.ContactName; } if (customerRow.IsContactTitleNull() == false) {
currentCustomer.ContactTitle = customerRow.ContactTitle; } if (customerRow.IsCountryNull() == false) {
currentCustomer.Country = customerRow.Country; } if (customerRow.IsFaxNull() == false) {
currentCustomer.Fax = customerRow.Fax; } if (customerRow.IsPhoneNull() == false) {
currentCustomer.Phone = customerRow.Phone; } if (customerRow.IsPostalCodeNull() == false) {
currentCustomer.PostalCode = customerRow.PostalCode; } if (customerRow.IsRegionNull() == false) {
currentCustomer.Region = customerRow.Region; } LoadOrders(currentCustomer);
customerBindingSource.Add(currentCustomer); } }
Criando uma coleção tipada de objetos
Você pode criar classes de coleção para os objetos ou usar as coleções tipadas que são
automaticamente fornecidas pelo BindingSource Component.
Quando você estiver criando uma classe de coleção personalizada para objetos, é recomendável
que você herde da BindingList. Essa classe genérica fornece funcionalidade para administrar sua
coleção, bem como a capacidade de evocar eventos que enviam notificações para a infra-
estrutura de vinculação de dados no Windows Forms.
A coleção gerada automaticamente no BindingSource usa um BindingList para sua coleção

tipada. Se seu aplicativo não requerer funcionalidade adicional, então você pode manter sua

coleção dentro do BindingSource. Para obter mais informações, consulte a propriedade List da
classe BindingSource.
Observação
Se sua coleção exigir funcionalidade não fornecida pela implementação base do BindingList,
então você deve criar uma coleção personalizada para que você possa adicionar à classe,
conforme o necessário.
O código a seguir mostra como criar a classe de uma coleção fortemente tipada de objetos Order:
C#
/// <summary> /// A collection of Orders /// </summary> public class Orders:
System.ComponentModel.BindingList<Order> { // Add any additional functionality required by your
collection. }
Adicionando objetos a uma coleção
Você adiciona objetos a uma coleção chamando o método Add de sua classe de coleção
personalizada ou do BindingSource.
Para obter um exemplo de como adicionar a uma coleção usando o BindingSource, consulte o
método LoadCustomers em Passo-a-Passo: Conectando a dados em Objetos
Para obter um exemplo de como adicionar objetos a uma coleção personalizada, consulte o
método LoadOrders em Passo-a-Passo: Conectando a dados em Objetos.
Observação
O método Add é fornecido automaticamente para sua coleção personalizada quando você herda
do BindingList.
O código a seguir mostra como adicionar objetos a uma coleção tipada em um BindingSource:
C#
Customer currentCustomer = new Customer(); customerBindingSource.Add(currentCustomer);
O código a seguir mostra como adicionar objetos a uma coleção tipada que herda do BindingList:
Observação
Neste exemplo a coleção Orders é uma propriedade do objeto Customer.
C#
Order currentOrder = new Order(); currentCustomer.Orders.Add(currentOrder);
Removendo objetos de uma coleção

Você remove objetos de uma coleção, chamando o método Remove ou RemoveAt de sua classe de
coleção personalizada ou do BindingSource.
Observação
Os métodos Remove e RemoveAt são fornecidos automaticamente para sua coleção personalizada
quando você herda do BindingList.
O código a seguir mostra como localizar e remover objetos da coleção tipada em um

BindingSource com o método RemoveAt:
C#
int customerIndex = customerBindingSource.Find("CustomerID", "ALFKI");
customerBindingSource.RemoveAt(customerIndex);
Exibindo dados de objeto aos usuários
Para exibir os dados em objetos para usuários, você cria uma fonte de dados objeto usando o
Assistente para Configuração da Fonte de Dados, e arrasta o objeto inteiro ou propriedades
individuais para seu formulário a partir da janela Data Sources.
Para obter mais informações sobre como criar uma fonte de dados objeto, consulte Como se
conectar a dados em um objeto:.
Para obter mais informações sobre como exibir dados a partir de objetos no Windows Forms,
consulte Exibir dados em formulários em aplicativos do Windows.
Modificando os dados nos objetos
Para editar dados em objetos personalizados que são vinculados a dados para controles Windows
Forms, basta editar os dados no controle acoplado (ou diretamente nas propriedades do objeto). A
arquitetura de vinculação de dados irá atualizar os dados no objeto.
Se seu aplicativo requerer o rastreamento de alterações e recuo nas alterações propostas para
seus valores originais, então você deve implementar essa funcionalidade no seu modelo de
objeto. Para exemplos de como tabelas de dados mantêm-se informadas das alterações
propostas, consulte DataRowState, HasChanges, e GetChanges.
Salvando dados em objetos de volta ao banco de dados
Você salva dados de volta para o banco de dados passando os valores de seu objeto para os
métodos DBDirect do TableAdapter.
O Visual Studio cria métodos DBDirect que podem ser executados diretamente no banco de
dados. Esses métodos não requerem objetos DataSet ou DataTable.
Método DBDirect do
TableAdapter Descrição
TableAdapter.Insert
Adiciona novos registros a um banco de dados, permitindo que você
passe valores individuais de coluna como parâmetros do método.

TableAdapter.Update
Atualizações de registros existentes em um banco de dados. O método
Update aceita valores originais e a novos valores de coluna como
parâmetros do método. Os valores originais são usados para localizar o
registro original, e os novos valores são usados para atualizar esse
registro.
O método TableAdapter.Update também é usado para acomodar as
alterações em um dataset de volta ao banco de dados fazendo o
DataSet, DataTable, DataRow, ou matriz de DataRows como parâmetros
do método.
TableAdapter.Delete
Exclui registros existentes do banco de dados com base nos valores
originais da coluna que foram passados como parâmetros do método.
Para salvar dados de uma coleção de objetos, percorra a coleção de objetos (por exemplo,
usando um loop for-next) e envie os valores de cada objeto para o banco de dados usando
métodos DBDirect do TableAdapter.
O exemplo a seguir mostra como usar o método TableAdapter.Insert do DBDirect para adicionar um
novo cliente diretamente ao banco de dados:
C#
private void AddNewCustomers(Customer currentCustomer) { customersTableAdapter.Insert(
currentCustomer.CustomerID, currentCustomer.CompanyName, currentCustomer.ContactName,
currentCustomer.ContactTitle, currentCustomer.Address, currentCustomer.City, currentCustomer.Region,
currentCustomer.PostalCode, currentCustomer.Country, currentCustomer.Phone, currentCustomer.Fax); }
Visão Geral da Edição de dados em DataSets

Editar os dados em um DataSet. é o processo de manipular os dados reais nos objetos individuais
DataTable que compõem um DataSet Você editar os dados nas tabelas de dados much ao editar
o dados em uma tabela em qualquer banco de dados — o processo pode incluir inserir, atualizar e
excluindo registros na tabela.
Além de alterar para os dados reais, você também pode consultar um DataTable. Para retornar
linhas específicas de dados, por exemplo, indivíduo linhas, versões específicas de (original e
proposta), linhas somente que foram alterados, linhas e linhas com erros
Tarefas tabela dados comuns
A tabela a seguir fornece links para as tarefas comuns associados ao editar e consultar dados de
um DataSet:
Tarefa Descrição
Inserir novos registros em Criar uma nova DataRow e adicioná-la à coleção de linhas da tabela.
uma tabela de dados. For more information, see Como adicionar linhas ao um DataTable.
Atualizar registros Atribua um valor diretamente para a coluna específica de uma linha
existentes em uma tabela de dados. For more information, see Como editar linhas de uma
de dados. DataTable:.
Excluir registros existentes Chame o Delete método da linha de dados que deseja remover da

de uma tabela de dados. tabela. For more information, see Como: Excluir linhas em uma
DataTable.
Localize os registros Chame o GetChanges método de uma tabela de dados. For more
alterados em uma tabela information, see Como: Recuperar Linhas Alteradas.
de dados.
Acesso versões diferentes Acesso as colunas individuais de uma linha de dados por passagem
de uma linha em uma em você DataRowVersion deseja exibir. For more information, see
tabela de dados. Como: Obter Versões Específicas de um DataRow.
Localize linhas com erros Verificar a HasErrors propriedade de uma tabela de dados. For more
em uma tabela de dados. information, see Como: Localizar linhas com erros:.
Visão geral sobre validação de dados

Validação de dados é o processo que confirma que os valores são inseridos em objetos de dados
de acordo com as restrições do esquema de um DataSet, bem como as regras estabelecidas pelo
seu aplicativo. Validar dados antes de enviar atualizações para o banco de dados subjacente é
uma boa prática que reduz erros bem como o número potencial de chamadas entre um aplicativo
e o banco de dados. Você pode confirmar se os dados que estão sendo gravados para um
DataSet são válidos, criando verificações de validação para o próprio DataSet. O DataSet pode
verificar se os dados não importando como a atualização estiver sendo executada — se
diretamente pelos controles de um formulário, de um componente, ou de alguma outra maneira.
Porque o DataSet faz parte do seu aplicativo, ele é um local lógico para criar validações
específicas do aplicativo (diferente de criar as mesma verificações na camada final do banco de
dados).
Observação
A localidade sugerida para adicionar validação para o aplicativo é no arquivo da classe parcial do
DataSet. No Visual Basic ou Visual C# abra o DataSet Designer e clique duas vezes na coluna
ou tabela que você deseja criar a validação. Esta ação cria automaticamente um manipulador de
eventos ColumnChanging. ou RowChanging. Para obter mais informações, consulte Como:
Validar Dados Durante Alterações de Linha ou Como: validar dados durante alterações em coluna,
Validando dados
Validação em um DataSet pode ser realizada:
• Criando sua própria validação específica do aplicativo que pode verificar dados durante
alterações em valores em uma coluna de dados individual. Para obter mais informações,
consulte Como: validar dados durante alterações em coluna.
• Criando sua própria validação específica do aplicativo que pode verificar dados durante
alterações em valores enquanto um linha de dados inteira está sendo alterada. Para obter mais
informações, consulte Como: Validar Dados Durante Alterações de Linha.
• Ao criar chaves, restrições exclusivas, e assim por diante como parte da definição do
esquema real do DataSet. Para obter mais informações sobre incorporar validação na
definição de esquema, consulte Como definir uma coluna de dados como a chave primária: e
Como restringir uma coluna de dados contêm valores exclusivos para:.
• Definindo as propriedades do objeto DataColumn como MaxLength, AllowDBNull e Unique

Há vários eventos que são gerados pelo objeto DataTable quando uma alteração está ocorrendo
em um registro:
• Os eventos ColumnChanging e ColumnChanged são gerados durante e após cada

alteração em uma coluna individual. O evento ColumnChanging é útil quando você deseja
validar alterações em colunas específicas. Informações sobre a alteração proposta são
passadas como um argumento para o evento. Para obter mais informações, consulte Como:
validar dados durante alterações em coluna.
• Os eventos RowChanging e RowChanged são gerados durante e após qualquer alteração
em uma linha. O evento RowChanging é mais geral, porque ele simplesmente indica que uma
alteração está ocorrendo em algum lugar na linha; você não souber qual coluna foi alterada.
Para obter mais informações, consulte Como: Validar Dados Durante Alterações de Linha.
Por padrão, cada alteração em uma coluna gera quatro eventos: Primeiro o evento
ColumnChanging e ColumnChanged para a coluna específica sendo alterada, e depois os
eventos RowChanging e RowChanged se várias alterações forem sendo feitas para a linha, os
eventos serão gerados para cada alteração.
Observação
O método da linha de dados BeginEdit desliga os eventos RowChanging e RowChanged após

cada alteração de colunas individuais. Nesse caso, o evento não é gerado até que o método
EndEdit tenha sido chamado, quando os eventos RowChanging. e RowChanged eventos são
gerados apenas uma vez Para obter mais informações, consulte Como: desativar restrições ao
preencher um DataSet.
O evento que você escolher depende de quão granulada seja a validação que você deseja. Se ele
for importante que você atualize um erro imediatamente quando uma coluna for alterada, criando
validação usando o evento ColumnChanging. Caso contrário, use o evento RowChanging que
pode resultar em captura de vários erros ao mesmo tempo. Além disso, se seus dados são
estruturados de tal forma que o valor de uma coluna é validada com base no conteúdo de outra
coluna, então você deve executar a validação durante o evento RowChanging.
Quando registros são atualizados, o objeto DataTable gera eventos que você pode responder
para as alterações que estão ocorrendo e depois que as alterações forem feitas.
Se seu aplicativo estiver usando um DataSet tipado, você pode criar manipuladores de eventos
altamente tipados. Isso adicionará quatro eventos tipados que você pode criar manipuladores;
dataTableNameRowChanging, dataTableNameRowChanged, dataTableNameRowDeleting e
dataTableNameRowDeleted. Esses manipuladores de eventos tipados passam um argumento que
inclui o nome das colunas da tabela que tornam mais fácil para código gravar e ler.
Eventos de atualização de dados
Evento Descrição
ColumnChanging O valor em uma coluna está sendo alterado. O evento passa a linha e coluna
para você, juntamente com o novo valor proposto.
ColumnChanged O valor em uma coluna foi alterado. O evento passa a linha e coluna para
você, juntamente com o valor proposto.
RowChanging Alterações feitas em um objeto DataRow estão prestes a serem confirmadas
de volta para o DataSet. Se você não tiver chamado o método BeginEdit, o

evento RowChanging é gerado para cada alteração em uma coluna
imediatamente após o evento ColumnChanging que foi gerado. Se você não
chamou BeginEdit antes de fazer alterações, o evento RowChanging é
gerado somente quando você chamar o método EndEdit.
O evento passa a linha para você e um valor indicando o tipo de ação (alterar,
inserir, e assim por diante) que está sendo executada.
RowChanged Uma linha foi alterada. O evento passa a linha para você e um valor indicando
o tipo de ação (alterar, inserir, e assim por diante) que está sendo executada.
RowDeleting Uma linha está sendo excluída. O evento passa a linha para você e um valor
indicando o tipo de ação (Excluir) que está sendo executada.
RowDeleted Uma linha foi excluída. O evento passa a linha para você e um valor
indicando o tipo de ação (Excluir) que está sendo executada.
Os eventos ColumnChanging, RowChanging e RowDeleting são gerados durante o processo

de atualização Você pode utilizar esses eventos para validar dados ou executar outros tipos de
processamento. Porque as atualizações estão em processo durante esses eventos, é possível
cancelar a atualização, através de uma exceção, que impede a alteração que está sendo
completada.
Os eventos ColumnChanged, RowChanged e RowDeleted são eventos de notificação que são

gerados quando uma atualização foi concluída com êxito. Esses eventos são úteis quando você
desejar fazer outra ação com base em uma atualização bem sucedida.
Consulte também
Tarefas
Passo a passo: Adicionando validação a um DataSet
Esta explicação passo a passo demonstra como validar dados quando alterações são feitas aos
dados em um dataset. Onde você deve executar as verificações de validação em seus dados é
dependente dos requisitos do seu aplicativo; para esta explicação passo a passo nós validamos
dados durante as alterações dos valores nas colunas individuais. Esta explicação passo a passo
usa o evento ColumnChanging para verificar se um valor aceitável está sendo inserido no registro.
Se o valor não for válido, um controle ErrorProvider é exibido para o usuário.
O exemplo também mostra como usar o Dataset Designer para criar uma classe parcial para o
dataset. (A classe parcial é onde os usuários podem adicionar código para estender a
funcionalidade do dataset gerado pelo Visual Studio. Ela não é substituída se o dataset for
regenerado.)
Observação
As caixas de diálogo e comandos de menu que você vir podem diferir dos descritos na Ajuda
dependendo das suas configurações ativas ou da sua edição. Para alterar as configurações,
• A criação de um novo projeto Windows Application.

• A criação e configuração de um dataset com o Assistente para Configuração da Fonte de
Dados.

• A seleção do controle a ser criado no formulário ao arrastar itens a partir da janela Data
• A criação de um controle ligado a dados, arrastando itens da Janela de fontes de dados
• A criação de uma classe parcial para estender a funcionalidade do dataset.
• A criação de um manipulador de eventos para o evento ColumnChanging da tabela
OrderDetails.
• A adição de validação para confirmar se a coluna Quantity contém valores maiores que 0.
• A exibição de um ErrorProvider Component (Windows Forms) para informar aos usuários
que um controle ligado a dados contém valores inválidos.
Pré-requisitos
Para seguir esta explicação passo a passo, você precisa de:
Criar um Novo Windows Application
Para criar o novo projeto Windows Application

2. Nomeie o projeto como ValidationWalkthrough.
O projeto ValidationWalkthrough é criado e adicionado ao Solution Explorer.
Criando uma Nova Fonte de Dados a partir de seu Banco de Dados

3. Selecione Database na página Choose a Data Source Type, e clique em Next.
disponível na lista suspensa, selecione-o.
-ou-
(General).
confidenciais (include sensitive data), e clique em Next.
8. Selecione a tabela Order Details, e clique em Finish.

O NorthwindDataSet é adicionado ao seu projeto e a tabela OrderDetails aparece na
janela Data Sources.
Criando Controles ligados a Dados
Para criar controles ligados a dados no formulário
1. Na janela Data Sources, selecione a tabela Order Details.

2. Escolha Details na lista de controles da tabela.
3. Arraste o nó Order Details da janela Data Sources para Form1.
Controles ligados a dados com rótulos descritivos aparecem no formulário, juntamente com
uma faixa de ferramentas (BindingNavigator) para registros de navegação. Controles
ligados a dados com rótulos descritivos aparecem no formulário, juntamente com uma faixa
de ferramentas (BindingNavigator) para registros de navegação. Um NorthwindDataSet,
Order_DetailsTableAdapter, BindingSource, e BindingNavigator aparecem na bandeja de
componentes.
Adicionando um Controle ErrorProvider ao Formulário
Para configurar um controle ErrorProvider
1. Arraste um ErrorProvider da Toolbox para o Form1.

2. Na janela Properties, defina a propriedade DataSource do ErrorProvider como
Order_DetailsBindingSource.
Observação
Não defina a propriedade DataMember.
Criando o Manipulador de Eventos ColumnChanging
Para criar os manipuladores de eventos de validação
1. Abra o NorthwindDataSet no Dataset Designer. clicando duas vezes no arquivo

NorthwindDataSet.xsd no Solution Explorer
2. Clique duas vezes na coluna Quantity da tabela OrderDetails para criar o manipulador de
eventos OrderDetailsDataTable_ColumnChanging. (Em C# somente classe parcial da tabela de
dados será criada.)
Observação
Um clique duplo no nome da tabela (Order Details na barra de título.) cria um manipulador de
eventos para o evento RowChanging.
3. Adicione código para verificar se e.ProposedValue contem valores maiores que 0. Se o valor
proposto for 0 ou menos, marque a coluna para indicar que ela contém um erro.
Cole o código a seguir no manipulador de eventos de alteração da coluna (column-
changing) sob o comentário Add user code here :
C#
if ((short)e.ProposedValue <= 0) { e.Row.SetColumnError("Quantity", "Quantity must be greater
than 0"); } else { e.Row.SetColumnError("Quantity", ""); }
Testando o Aplicativo

2. Altere o valor na caixa de texto Quantity para 0.
3. Pressione TAB para mover o foco para fora da caixa de texto.
O ícone do provedor de erros (error provider) aparecerá.
4. Posicione o ponteiro do mouse sobre o provedor de erros para ver a mensagem.
Próximas etapas
após adicionar validação. Alguns aprimoramentos que você pode fazer a esta explicação passo a
passo incluem:
(Tabela Simples).
• Editar o dataset para adicionar ou remover objetos de banco de dados. Para obter mais
informações, consulte Como editar um DataSet:.
Visão Geral do Salvar dados

Como um dataset é efetivamente um cache — uma cópia em memória — dos dados, o processo
de gravar informações para a fonte de dados original é separado do processo de modificar os
dados no dataset. Você pode enviar dados atualizados no datasets de volta para o banco de
dados chamando um dos métodos Update de um TableAdapter ou chamando um dos métodos
DBDirect do TableAdapter.
Para obter mais informações sobre o envio das alterações em um dataset de volta para o banco
de dados, consulte Como: atualizar dados usando um TableAdapter e Como salvar alterações
DataSet em um banco de dados:.
Para informações sobre como modificar dados no dataset, consulte Editar dados no seu aplicativo.
Atualizações de Dois Estágios
Atualizar uma fonte de dados por meio de um dataset é um processo de duas etapas. A primeira
etapa é atualizar o dataset com novas informações — novos registros, registros alterados ou
registros excluídos. Se seu aplicativo está relacionado somente com o dataset — por exemplo,
após atualizar o dataset, você o envia para outro aplicativo que irá executar mais processamento
do dataset — então você está terminando a atualização.
Observação
No Windows Forms, a arquitetura de vinculação de dados cuida do envio de alterações dos

controles com dados vinculados ao dataset e você não precisa claramente atualizar o dataset com
seu próprio código. Para obter mais informações, consulte Windows Forms Data Binding.
Se você estiver atualizando uma fonte de dados (como um banco de dados), a segunda etapa é
enviar as alterações do dataset para fonte de dados original. Isto é, o processo de atualização o
dataset também não grava as alterações a uma fonte de dados base; você deve executar essa
segunda etapa explicitamente. Você normalmente faz isso chamando o método Update do mesmo
TableAdapter (ou adaptador de dados) que você usou para preencher o dataset, embora também

possa usar adaptadores diferentes, por exemplo, para mover dados de uma fonte de dados para
outra ou para atualizar várias fontes de dados.
Processo de atualização de dois estágios e a função do DataRowVersion em uma

atualização bem sucedida
Estruturalmente, um dataset torna dados disponíveis como conjuntos de coleções. Datasets

contêm coleções de tabelas. Tabelas contêm coleções de linhas. Tabelas são expostas como uma
coleção do objeto DataSet e registros estão disponíveis na coleção Rows de objetos DataTable.
Fazer alterações dos dados em um dataset por simples manipulação dessas coleções usando
métodos de coleção de base é possível, mas se você pretende atualizar uma fonte de dados
subjacente você deve usar os métodos especificamente projetados para modificação de dataset.
Por exemplo, para remover um registro de uma tabela de dados, você poderia chamar o Método
RemoveAt da coleção Rows da tabela, que fisicamente exclui o registro do dataset. Se você
estiver usando o dataset somente como um armazenamento estruturado para dados e não estiver
preocupado em transmitir mudança de informações para um outro aplicativo, manipular coleções
dessa maneira é um modo aceitável de atualização um dataset.
Entretanto, se você pretende enviar alterações para uma fonte de dados ou outro aplicativo, você
precisará manter informações de alterações (isto é, metadados) sobre cada atualização.
Posteriormente, quando você enviar alterações para a fonte de dados ou aplicativo, o processo
terá as informações necessárias para localizar e atualizar os registros adequados. Por exemplo,
se você excluir um registro no dataset, informações sobre o registro excluído devem ser mantidas
no dataset. Dessa forma, quando o DeleteCommand do TableAdapter é chamado, há informações
suficientes para localizar o registro original em uma fonte de dados para que este possa ser
excluído. Para obter mais informações, consulte " Mantendo Informações Sobre Alterações "
abaixo.
Mesclando DataSets

Você pode atualizar o conteúdo de um dataset mesclando — isto é, copiando o conteúdo de um
dataset (chamado de dataset origem) para o dataset chamado (referido como o dataset destino).
Quando você mescla datasets, novos registros na fonte do dataset são adicionados para o
dataset destino. Além disso, colunas extras do dataset fonte são adicionadas ao dataset destino.
Mesclar datasets é particularmente útil quando você tiver um dataset local e obter um segundo
dataset de outro aplicativo ou de um componente como um XML Web Services. Também é útil
quando você precisa integrar dados de vários datasets.
Quando datasets são mesclados, também é possível passar um argumento booleano opcional
(preserveChanges) que informa ao método Merge se deseja manter modificações existentes no
dataset destino. Como datasets mantêm várias versões de registros, é importante ter em mente
que mais de uma versão dos registros está sendo mesclada. A tabela a seguir ilustra um registro
em dois datasets que serão mesclados:
DataRowVersion DataSet destino DataSet origem

Original James Wilson James C. Wilson
Atual Jim Wilson James C. Wilson
Chamar o método Merge na tabela acima com preserveChanges=false

targetDataset.Merge(sourceDataset) resulta no seguinte:

Original James C. Wilson James C. Wilson
Atual James C. Wilson James C. Wilson
Chamar o método Merge com preserveChanges = true targetDataset.Merge(sourceDataset, true) resulta

no seguinte:

Original James C. Wilson James C. Wilson
Atual Jim Wilson James C. Wilson
Cuidado
No cenário preserveChanges = true, se o método RejectChanges for chamado em um registro no
dataset destino, então ele reverterá para os dados originais do dataset origem. Isso significa que
se você tentar atualizar a fonte de dados original com o dataset destino, ele pode não ser capaz
de localizar a linha original para atualizar. Entretanto, você pode impedir uma violação simultânea
preenchendo outro dataset com os registros atualizados a partir da fonte de dados e, então,
executar uma mesclagem impedindo uma violação simultânea. (Uma violação simultânea ocorre
quando outro usuário modifica um registro na fonte de dados após o dataset ter sido preenchido).
Para obter mais informações, consulte Controle de concorrência no ADO.NET.
Restrições de Atualização
Para fazer alterações em um linha de dados existente, você adiciona ou atualiza dados nas
colunas individuais. Se o dataset contiver restrições (como chaves externas ou restrições não-
anuláveis), é possível que você atualize um registro — após você ter terminado de atualizar uma
coluna, mas antes que você obtenha a próxima — o registro pode temporariamente estar em um
estado de erro.

Para evitar violações de restrição você pode temporariamente suspender restrições de
atualização. Isso serve para duas finalidades:
• Ela impede que um erro seja jogado quando você atualiza uma coluna antes de obter a
outra coluna.
• Ele suspende determinados eventos de atualização de serem elevados (eventos que são
freqüentemente usados para validação).
Após a conclusão de uma atualização, você pode reativar a restrição de verificação, que também
reativa eventos de atualização e os aumenta.
Observação
No Windows Forms, a arquitetura de vinculação de dados incorporados ao DataGrid suspende a
restrição de verificação até que o foco mova para fora de uma linha e você não precisa chamar
explicitamente os métodos BeginEdit, EndEdit ou CancelEdit.
Restrições são automaticamente desativadas quando o método Merge é chamado em um

dataset. Quando a mesclagem estiver concluída, se houver qualquer restrição sobre o dataset que
não possa ser ativado, então uma ConstraintException será lançada. Nesta situação, a
propriedade EnforceConstraints é definida para false e todas as violações de restrição devem ser
resolvidas antes de redefinir a propriedade EnforceConstraints para true.
Após a conclusão de uma atualização, você pode reativar a restrição de verificação, que também
reativa eventos de atualização e os aumenta.
Para obter mais informações sobre suspensão de eventos, consulte Como: desativar restrições ao
preencher um DataSet.
Erros de Atualização de DataSet
Quando você atualiza um registro em um dataset, há a possibilidade de um erro. Por exemplo,

você pode inadvertidamente gravar dados em uma coluna que é do tipo de dados errado ou muito
longo ou que tenha algum outro problema de integridade. Além disso, você pode ter verificações
de validação específicas do aplicativo que podem elevar a erros personalizados durante qualquer
estágio de um evento de atualização. Para obter mais informações, consulte Visão geral sobre
Manter Informações Sobre Alterações
As informações sobre as alterações em um dataset são mantidas de duas maneiras: por sinalizar
a linha que indica se ele foi alterado (RowState) e por manter várias cópias de um registro
(DataRowVersion). Usando essas informações, processos podem determinar o que foi alterado no
dataset e podem enviar atualizações apropriadas para a fonte de dados.
Propriedade RowState
A propriedade RowState de um objeto DataRow é um valor que fornece informações sobre o

status de uma linha específica de dados.
A tabela a seguir detalha os possíveis valores da enumeração DataRowState:
Descrição
Valor de

DataRowState
Added A linha foi adicionada como um item a um DataRowCollection. (Uma linha

nesse estado não tem uma versão original correspondente desde que não
existia no momento que o último método AcceptChanges foi chamado).
Deleted A linha foi excluída usando o Delete de um objeto DataRow.
Detached A linha tinha sido criada mas não faz parte de qualquer DataRowCollection.
Um objeto DataRow está neste estado imediatamente após ele ter sido criado
e antes de ser adicionado a uma coleção ou se ele tiver sido removido de uma
coleção.
Modified Um valor de coluna na linha foi alterado de alguma maneira.
Unchanged A linha não foi alterada desde que AcceptChanges foi chamado pela última
vez.
Enumeração DataRowVersion
Datasets mantém várias versões de registros. A enumeração DataRowVersion de um objeto

DataRow é um valor que pode ser usado para retornar uma versão específica de um objeto
DataRow.
A tabela a seguir detalha os possíveis valores da enumeração DataRowVersion:
Valor de
DataRowVersion Descrição
Current A versão atual de um registro contém todas as modificações executadas no

registro desde a última vez que AcceptChanges foi chamado. Se a linha foi
excluída não há versão atual.
Default O valor padrão de um registro, conforme definido pelo esquema do dataset

ou fonte de dados.
Original A versão original de um registro é uma cópia do registro como ele nas
últimas alterações foram confirmadas no dataset. Em termos práticos, isso é
normalmente a versão de um registro como lida de uma fonte de dados.
Proposed A versão de um registro que está disponível temporariamente, enquanto

você está no meio de uma atualização — ou seja, entre o momento você
chamou o método BeginEdit e o método EndEdit. Você normalmente
acessa a versão de um registro em um manipulador para um evento como
RowChanging. Chamar o método CancelEdit inverte as alterações e exclui a
versão da linha de dados proposta.

As versões originais e atuais são úteis quando informações de atualização são transmitidas para
uma fonte de dados. Normalmente, quando uma atualização é enviada para a fonte de dados, as
novas informações para o banco de dados estão na versão atual de um registro. Informações da
versão original são usadas para localizar o registro para atualizar. Por exemplo, no caso onde a
chave primária de um registro for alterada, você deve ter uma maneira de localizar o registro
adequado em uma fonte de dados, para atualizar as alterações. Se nenhuma versão original
existisse, o registro provavelmente seria anexado à fonte de dados, resultando não apenas em um
registro extra indesejado, mas em um registro que está impreciso e desatualizado. As duas
versões também são usados no controle de simultaneidade; você pode comparar a versão original
contra um registro na fonte de dados para determinar se o registro foi alterado desde que foi
carregado no dataset. Para obter mais informações, consulte Controle de concorrência no
ADO.NET.
A versão proposta é útil quando você precisa realizar validação antes de realmente confirmar as
alterações para o dataset.
Mesmo se registros tiverem sido alterados, não há sempre versões originais ou atuais de linha.
Quando você insere uma nova linha na tabela, não há nenhuma versão original, somente a versão
atual. Da mesma forma, se você excluir uma linha, chamando o método Delete da tabela, há uma
versão original, mas nenhuma versão atual.
Você pode testar para ver se uma versão específica de um registro existe consultando a
propriedade HasVersion de uma linha de dados. Você pode acessar tanto a versão de um
registro, passando um valor de enumeração DataRowVersion como um argumento opcional
quando você solicitar o valor de uma coluna.
Obter Registros Alterados
É comum que você não atualize cada registro em um dataset. Por exemplo, um usuário pode
estar funcionando com um controle Windows Forms DataGridView que exibe vários registros.
Entretanto, o usuário pode atualizar apenas alguns registros, excluir um, e inserir um novo nome.
Datasets e tabelas de dados fornecem um método (GetChanges) para retornar somente as linhas
que foram modificadas
Você pode criar subconjuntos de registros alterados usando o método GetChanges de uma tabela
de dados (GetChanges) ou do DataSet próprio (GetChanges). Se você chamar o método para a
tabela de dados, ela retornará uma cópia da tabela com apenas os registros alterados. Da mesma
forma, se você chamar o método no dataset, você terá um novo dataset com apenas registros
alterados. GetChanges por si só retornará todos os registros alterados. Em contraste, passando o
desejado DataRowState como um parâmetro para o método GetChanges, você pode especificar o
subconjunto de registros alterados que você deseja: registros recém-adicionados, registros
marcados para exclusão, registros separados, ou registros modificados.
Obter um subconjunto de registros alterados é especialmente útil quando você deseja enviar
registros para outro componente para processamento. Em vez de enviar o dataset inteiro, você
pode reduzir a sobrecarga de se comunicar com o outro componente por meio somente os
registros que o componente precisa. Para obter mais informações, consulte Como: Recuperar
Linhas Alteradas.
Confirmar Alterações no DataSet
Como as alterações são feitas no dataset, a propriedade RowState de linhas alteradas está
definida. As versões originais e atuais de registros são estabelecidas e mantidas e
disponibilizadas para você pela propriedade RowVersion. Os metadados armazenados nessas
propriedades representam as alterações que são necessárias para enviar as atualizações
adequadas para a fonte de dados.

Se as alterações refletem o estado atual da fonte de dados, você não mais precisa manter essas
informações. Normalmente, existem duas vezes quando o dataset e sua fonte estão em
sincronização:
• Imediatamente após você ter carregado informações para o dataset, como quando você lê
dados da fonte.
• Após enviar alterações do dataset para a fonte de dados (mas não antes, porque você
pode perder as informações necessárias para enviar alterações para o banco de dados).
Você pode confirmar as alterações pendentes para o dataset chamando o método

AcceptChanges. Normalmente, AcceptChanges deve ser chamado nos próximos momentos em
seu aplicativo.
• Depois que você carregou o dataset. Se você carregar um dataset chamando o método Fill
do TableAdapter, então o adaptador confirma automaticamente as alterações para você.
Entretanto, se você carregar um dataset, mesclando outro dataset para ele, então você terá
que confirmar as alterações manualmente.
Observação
Você pode impedir que o adaptador confirme automaticamente as alterações ao chamar o método
Fill, definindo a propriedade AcceptChangesDuringFill do adaptador para false. Se ele estiver
definido para false, então o RowState de cada linha inserida durante o preenchimento é definido
como Added
• Após você ter enviado alterações do dataset para outro processo, como um XML Web
Service.
Cuidado
Confirmar a alteração dessa maneira apaga qualquer mudança da informação. Não confirmar
alterações até depois que você tiver efetuado quaisquer operações no qual seu aplicativo
depende em saber quais alterações foram feitas no dataset.
Esse método realiza o seguinte:
• Grava a versão de um registro Current em sua versão Original, substituindo a versão

original.
• Remove qualquer linha cuja propriedade RowState é definida como Deleted.
• Define a propriedade de um registro RowState para Unchanged.
O método AcceptChanges está disponível em três níveis. Você pode chamá-lo em um objeto
DataRow, que confirma as alterações para apenas aquela linha. Você também pode chamá-lo em
um objeto DataTable para confirmar todas as linhas em uma tabela ou no objeto DataSet para
confirmar todas as alterações pendentes em todos os registros de todas as tabelas do dataset.
A tabela a seguir descreve quais alterações são confirmadas com base em qual objeto o método é
chamado.
Método Resultado

DataRow.AcceptChanges Alterações são confirmadas somente sobre a linha
específica
DataTable.AcceptChanges Alterações são confirmadas em todas as linhas na tabela

específica
DataSet.AcceptChanges Alterações são confirmadas em todas as linhas em todas

as tabelas do dataset
Observação
Se você carregar um dataset chamando o método Fill do TableAdapter, você não tem que
explicitamente aceitar alterações; por padrão o método Fill chama o método AcceptChanges quando
ele tiver terminado de preencher a tabela de dados.
Um método relacionado, RejectChanges, desfaz o efeito das alterações por copiar a versão de volta
Original para a versão Current dos registros e configurar o RowState de cada registro de volta a
Unchanged.
Validação de Dados
A fim de verificar que os dados em seu aplicativo atendem aos requisitos dos processos que é
passado, você freqüentemente precisa adicionar validação. Isso pode envolver verificação que
uma entrada do usuário em um formulário está correta, validação de dados enviados para seu
aplicativo por outro aplicativo ou mesmo verificar que informações calculadas no seu componente
se enquadra nas restrições de sua fonte de dados e aplicativos requeridos.
Você pode validar dados de várias maneiras:
• Na camada comercial, adicionando o código a seu aplicativo para validar dados. O dataset
é um local que você pode fazer isso. O dataset fornece algumas das vantagens de validação
back-end — como a capacidade para validar alterações como valores de coluna e linha
alteradas. Para obter mais informações, consulte Visão geral sobre validação de dados.
• Na camada de apresentação, adicionando validação a formulários. Para obter mais
informações, consulte User Input Validation in Windows Forms (Windows Forms).
• No back-end de dados, enviando dados para a fonte de dados — por exemplo, o banco de
dados — e permitindo que ele aceite ou rejeite os dados. Se você estiver trabalhando com um
banco de dados que tem recursos sofisticados para validação de dados e fornecimento de
informações de erro, isso pode ser uma abordagem prática porque você pode validar os dados
não importando de onde ele vem. Entretanto, ele pode não acomodar requisitos específicos de
aplicativo de validação. Além disso, tendo a fonte de dados validada, dados podem resultar em
várias viagens à fonte de dados, dependendo de como seu aplicativo facilita em resolver erros
de validação elevados pelo back-end.
Ao usar comandos de dados com uma propriedade CommandType definida como Text,
cuidadosamente verifique informações que são enviadas de um cliente antes de passá-la para
seu banco de dados. Usuários mal intencionados podem tentar para enviar (inserir) instruções
SQL modificadas ou adicionais em um esforço para obter acesso não autorizado ou danificar o

banco de dados. Antes de você transferir a entrada do usuário a um banco de dados, você deve
verificar se as informações são válidas; é a melhor prática para sempre usar consultas
parametrizadas ou procedimentos armazenados quando possível. Para obter mais informações,
consulte Visão Geral Sobre Scripts Maliciosos.
Após terem sido feitas alterações em um dataset, você pode transmitir as alterações em uma
fonte de dados. Mais comumente, faça isso chamando o método Update de um TableAdapter (ou
adaptador de dados). O método loops a cada registro em uma tabela de dados, determina que
tipo de atualização é necessária (atualizar, inserir ou excluir), se houver, e, então, executa o
comando apropriado.
Como Uma Atualização é Transmitida à Fonte de Dados
Como uma ilustração da como atualizações são feitas, suponha que o seu aplicativo utilize um
dataset contendo uma única tabela de dados. O aplicativo busca duas linhas do banco de dados.
Após a recuperação, a tabela de dados na memória tem esta aparência:
(RowState) CustomerID Name Status (Unchanged) c200 Robert Lyon Good (Unchanged) c400 Nancy
Buchanan Pending
Seu aplicativo altera o status de Nancy Buchanan para " Preferred ". Como resultado desta
alteração, o valor da propriedade RowState para aquela linha altera de Unchanged para
Modified. O valor da propriedade RowState para a primeira linha permanece Unchanged. A
tabela de dados agora tem esta aparência:
(RowState) CustomerID Name Status (Unchanged) c200 Robert Lyon Good (Modified) c400 Nancy
Buchanan Preferred
Seu aplicativo agora chama o método Update para transmitir o dataset para o banco de dados. O
método inspeciona cada linha por vez. Para a primeira linha, o método não transmite Instrução
SQL para o banco de dados, porque essa linha não foi alterada desde que foi originalmente
procurada no banco de dados.
Para a segunda linha, no entanto, o método Update automaticamente chama o comando de dados
adequado e o transmite para o banco de dados. A sintaxe específica da instrução SQL depende
do dialeto do SQL suportado para o armazenamento de dados subjacente. Mas os seguintes
traços gerais de instrução do SQL transmitidos são os que valem a pena observar:
• A instrução SQL transmitida é uma declaração UPDATE. O adaptador sabe usar uma
propriedade UPDATE, porque o valor da propriedade RowState é Modified.
• A instrução SQL transmitida inclui uma cláusula WHERE indicando que o destino da
declaração UPDATE é a linha cujo CustomerID = 'c400'. Esta parte da declaração SELECT
distingue a linha de destino de todas as outras porque CustomerID é a chave primária da tabela
de destino. As informações para a cláusula WHERE são derivadas da versão original do
registro (DataRowVersion.Original), no caso de os valores necessitarem identificar a linha que foi
alterada.
• A instrução SQL transmitida inclui a cláusula SET, para definir os novos valores das
colunas modificadas.
Observação
Se a propriedade UpdateCommand do TableAdapter tiver sido definida com o nome de um

procedimento armazenado, o adaptador não constrói uma instrução SQL. Em vez disso, ele
chama o procedimento armazenado com os parâmetros apropriados passados.
Passando Parâmetros
Valores de registros a serem atualizados no banco de dados são passados usando parâmetros.
Quando o método Update do TableAdapter executa uma declaração UPDATE, ele precisa
preencher os valores de parâmetro. Ele obtém esses valores da coleção Parameters para o
comando de dados apropriados — neste caso, o objeto UpdateCommand na TableAdapter.
Se você tiver usado ferramentas do Visual Studio para gerar um adaptador de dados, o objeto
UpdateCommand conterá um conjunto de parâmetros que corresponde a cada espaço reservado
do parâmetro na declaração.
A propriedade SqlParameter.SourceColumn de cada parâmetro aponta para uma coluna na tabela

de dados. Por exemplo, a propriedade SourceColumn para os parâmetros au_id e Original_au_id
estiverem definidos como qualquer coluna na tabela de dados contém o autor do ID. Quando o
adaptador do método Update executa, ele lê o autor coluna ID do registro sendo atualizado e
preenche os valores na declaração
Em uma declaração UPDATE, você precisa especificar os dois novos valores (aqueles que serão
gravados para o registro), bem como os antigos valores (para que o registro a ser atualizado
possa estar localizado no banco de dados). Há, portanto, dois parâmetros para cada valor: um
para a cláusula SET e um ícone diferente para a cláusula WHERE. Os dois parâmetros lêem
dados do registro sendo atualizado, mas eles obtêm versões diferentes do valor da coluna com
base no parâmetro da propriedade SqlParameter.SourceVersion. O parâmetro para a cláusula
SET obtém a versão atual e o parâmetro para a cláusula WHERE obtém a versão original.
Observação
Você também pode definir valores na coleção Parameters no código, que normalmente você deseja
fazer em um manipulador de eventos para o adaptador de dados do evento RowChanging. Para
obter mais informações, consulte Parâmetros de comandos Adapter Data-.
Atualizando Tabelas Relacionadas
Se o dataset contiver várias tabelas, você precisa atualizá-las individualmente chamando o

método Update de cada adaptador de dados separadamente. Se as tabelas têm uma relação pai-
filho, é provável que você terá que enviar atualizações para o banco de dados em uma ordem
específica. Um cenário comum é que você adicionou pai e o filho relacionado gravados para um
dataset — por exemplo, um novo registro do cliente e um ou mais registros relacionados. Se o
próprio banco de dados está impondo regras de integridade relacional, ele aumentará erros se
você enviar o novo registro filho para o banco de dados antes que o registro pai tiver sido criado.
Inversamente, se você excluir registros relacionados no dataset, geralmente você terá para que
atualizações na ordem inversa: tabela filho primeiro, depois tabela pai. Caso contrário, é provável
que o banco de dados que gere um erro porque as regras de integridade referencial impedirão
você de excluir um registro pai enquanto ainda existem registros filho relacionados.
Uma regra geral para enviar atualizações para tabelControle de concorrência no

ADO.NET

Controle concorrente é o processo usado para identificar e resolver atualizações dos dados que
são feitas por vários usuários simultaneamente. Os tópicos a seguir explicam métodos comuns
para controle concorrente, bem como recursos ADO.NET específicos para manipular erros
concorrentes.
as relacionadas é a seguir nesta ordem:
1. Tabela filho: excluir registros.

2. Tabela pai: inserir, atualizar e excluir registros.
3. Tabela filho: inserir e atualizar registros.
4. Para obter mais informações, consulte Passo-a-Passo: salvando dados a um banco de
dados (várias tabelas).
Controle de Concorrência
Como datasets são desconectados da fonte de dados, não mantenha bloqueios em registros na
fonte de dados. Portanto, se você deseja atualizar o banco de dados, e se ele for importante para
seu aplicativo para manter controle de simultaneidade, você deve reconciliar registros no dataset
com aqueles no banco de dados. Por exemplo, você pode localizar registros no banco de dados
que foram alterados desde o último preenchimento do dataset. Nesse caso, você deve executar
aplicação-apropriada lógica para especificar o que acontece com o registro de banco de dados ou
com o registro alterado que você tem em sua dataset. Para obter mais informações, consulte
Controle de concorrência no ADO.NET.
Introdução ao CONCURRENCY dados em ADO.NET

Quando usuários múltiplos tentar para modificar dados ao mesmo tempo, controles precisará ser
estabelecida para impedir modificações de um usuário de afetar negativamente modificações de
usuários simultâneos. O sistema de manipular o que acontece nessa situação é chamado controle
de simultaneidade.
Tipos de controle CONCURRENCY
Em geral, há três maneiras comuns para gerenciar simultaneidade em um banco de dados:
• Controle de simultaneidade pessimista uma linha é indisponível aos usuários a partir da

hora do registro são vasculhados até que ele seja atualizada no banco de dados.
• Controle concorrência otimista Linha é indisponível para outros usuários somente
enquanto os dados está realmente sendo atualizados. A atualização examina a linha no banco
de dados e determina se qualquer alteração tiver sido feita. Tentativa de atualizar um registro
que já tenha sido alterado resulta em uma violação de concorrência.
• " última no WINS " Linha é indisponível para outros usuários somente enquanto os dados
está realmente sendo atualizados. No entanto, nenhum esforço é feita para comparar
atualizações contra o registro original; o registro é simplesmente gravado out, potencialmente
sobrescrever qualquer alteração feita por outros usuários desde você atualizou os registros
pela última vez.
CONCURRENCY pessimista
Simultaneidade pessimista é normalmente usado para dois motivos. Primeiro, em algumas

situações, não é alta contenção dos mesmos registros. O custo de colocando bloqueios sobre os
dados é menor que o custo de reverter alterações quando ocorrerem conflitos simultaneidade.

Simultaneidade pessimista também é útil para situações onde ela seja detrimental para o Registro
para alterar durante o curso de uma transação. Um bom exemplo é um aplicativo de estoque.
Considere um representante empresa verificação estoque de um cliente potencial. Normalmente
você deseja bloquear o registro até que um pedido seja gerada, que deseja sinalizar o item com
um status de ordenada e removê-lo do estoque disponível Geralmente. Se nenhuma ordem é
gerado, o bloqueio seria ser liberado para que outros usuários verificando estoque começar uma
contagem do estoque disponível precisas.
No entanto, controle de simultaneidade pessimista é possível em uma arquitetura desconectado.

As conexões são abrir somente longo o suficiente para ler os dados ou para atualizá-lo, portanto
bloqueios não pode ser sustained por longos períodos. Além disso, um aplicativo que contém até
bloqueios por longos períodos é não escalonáveis.
Observação
Se sua fonte de dados subjacente suportar transações, você pode simular simultaneidade
pessimista por atualizar dados em uma transação. For more information, see Features Provided
by System.Transactions.
CONCURRENCY otimista
Em concorrência otimista, bloqueios são conjunto e mantidos somente enquanto o banco de

dados está sendo acessado. Os bloqueios impede os outros usuários de tentativa de atualizar
registros no mesmo instantâneas. Os dados estão sempre disponíveis exceto para o momento em
que uma atualização for local Taking exata. For more information, see Using Optimistic
Concurrency.
Quando uma atualização é tentada, a versão original de uma linha alterada é comparado contra a
linha existente no banco de dados. Se as duas forem diferentes, a atualização falhará com um
erro de simultaneidade. Ele é backup a você nesse ponto para reconciliar as linhas dois, usando
lógica corporativa que você criar.
Última no WINS
Com " última no WINS, " é feita nenhuma verificação dos dados originais e a atualização
simplesmente é gravada no banco de dados. Ele é compreendido que o cenário a seguir podem
ocorrer:
• O usuário A fetches um registro a partir do banco de dados.

• O usuário B fetches o mesmo registro a partir do banco de dados, modifica-la, e grava o
registro atualizado novamente para o banco de dados.
• O usuário A modifica o registro ' antigo ' e grava-lo novamente para o banco de dados.
No cenário acima, as alterações feitas Usuário B nunca foram vistas pelo usuário a. Certifique-se
que esta situação é aceitável se você quiser usar a abordagem " última no WINS " do controle de
simultaneidade.
Controle de simultaneidade em ADO.NET e Visual Studio
ADO.NET e Visual Studio usar concorrência otimista, porque a arquitetura de dados for baseada
em dados desconectado. Portanto, você precisará adicionar lógica corporativa para resolver
problemas com simultaneidade otimista.

Se você optar por usar concorrência otimista, existem duas maneiras geral para determinar se
ocorreram alterações: a abordagem versão (números de versão True ou carimbos de data e hora)
e a abordagem valores-economia-todos os.
A abordagem número versão
Na abordagem número versão, o registro a ser atualizado deve ter uma coluna que contém um
carimbo de data e hora ou número de versão. O carimbo de data e hora ou um número de versão
é salva no cliente quando o registro é leitura. Esse valor depois é feita parte da atualização.
Uma maneira para manipular simultaneidade é para atualizar somente se Valor na cláusula
WHERE corresponde ao valor no Registro. A representação SQL dessa abordagem é:
UPDATE Table1 SET Column1 = @newvalue1, Column2 = @newvalue2 WHERE DateTimeStamp =

@origDateTimeStamp
Como alternativa, a comparação pode ser feita usando o número de versão:
UPDATE Table1 SET Column1 = @newvalue1, Column2 = @newvalue2 WHERE RowVersion =

@origRowVersionValue
Se o carimbos de data e hora ou os números versão coincidirem, o registro no armazenamento de

dados não foi alterado e com segurança podem ser atualizados com os novos valores do DataSet.
Um erro será retornado se elas não coincidem. Você pode escrever código para implementar essa
forma de simultaneidade verificação no Visual Studio. Você também terá para gravar código para
responder a qualquer conflitos de atualização. Para manter o carimbo de data e hora ou número
de versão precisa, você precisará configurar um disparador na tabela para atualizá-lo quando
ocorre uma alteração em uma linha.
A abordagem valores-Saving-tudo
Uma alternativa para usando um número ou versão carimbo de data e hora será para obter cópias
de todos os campos quando o registro é leitura. O DataSet objeto no ADO.NET mantém duas
versões de cada registro modificado: uma versão original (que foi ler a partir da fonte de dados)
originalmente e uma versão modificada, que representa as atualizações de usuário. Ao tentar para
gravar o Registro de volta para a fonte de dados, os valores originais na linha de dados são
comparados com o registro na fonte de dados. Se eles coincidirem, significa registro de banco de
dados que não foi alterado desde que ela foi lida. Nesse caso, os valores alterados a partir do
DataSet com êxito são gravados para o banco de dados.
Cada comando adaptador de dados tem uma coleção parâmetros para cada um dos seus
comandos quatro (DELETE, INSERT, SELECT, e UPDATE). Cada comando tem parâmetros para
tanto os valores originais,, bem como os valores atual (ou modificado).
Observação
Somente a adição de novos registros (o comando INSERT) requer os valores atuais pois nenhum
registro original existe e remover registros (o comando delete) somente requer os valores
originais, para localizar o registro para excluir.

O exemplo a seguir mostra o texto de comando para um comando DataSet que atualiza uma
tabela comum Customers. O comando foi especificado para SQL Dinâmico e simultaneidade
otimista.
UPDATE Customers SET CustomerID = @currCustomerID, CompanyName = @currCompanyName,

ContactName = @currContactName, ContactTitle = currContactTitle, Address = @currAddress, City =
@currCity, PostalCode = @currPostalCode, Phone = @currPhone, Fax = @currFax WHERE (CustomerID =
@origCustomerID) AND (Address = @origAddress OR @origAddress IS NULL AND Address IS NULL) AND
(City = @origCity OR @origCity IS NULL AND City IS NULL) AND (CompanyName = @origCompanyName
OR @origCompanyName IS NULL AND CompanyName IS NULL) AND (ContactName =
@origContactName OR @origContactName IS NULL AND ContactName IS NULL) AND (ContactTitle =
@origContactTitle OR @origContactTitle IS NULL AND ContactTitle IS NULL) AND (Fax = @origFax OR
@origFax IS NULL AND Fax IS NULL) AND (Phone = @origPhone OR @origPhone IS NULL AND Phone IS
NULL) AND (PostalCode = @origPostalCode OR @origPostalCode IS NULL AND PostalCode IS NULL);
SELECT CustomerID, CompanyName, ContactName, ContactTitle, Address, City, PostalCode, Phone, Fax
FROM Customers WHERE (CustomerID = @currCustomerID)
Observe que os parâmetros instrução SET nove representam os valores atuais que vai ser
gravados para o banco de dados, enquanto a nove WHERE parâmetros instrução representam o
original valores que são usados para localizar o registro original.
Os parâmetros nove primeiros na instrução SET correspondem aos parâmetros nove primeiros na
coleção parâmetros. Esses parâmetros seria ter sua SourceVersion propriedade definida para
Current.
Os parâmetros próxima nove na instrução WHERE são usadas para simultaneidade otimista.
Esses espaços reservados seria correspondem com os parâmetros próxima nove na coleção
parâmetros, e cada um desses parâmetros deve ter sua SourceVersion propriedade definida como
Original.
A instrução SELECT é usado para atualizar o DataSet após a atualização ter ocorrido. Ele é
gerado quando você definir a Refresh the DataSet opção na caixa Advanced SQL Generations
Options de diálogo.
Observação
A instrução SQL acima usa parâmetros nomeados, enquanto OleDbDataAdapter comandos usar
pontos de interrogação (?) como espaços reservados parâmetro.
Por padrão Visual Studio cria esses parâmetros para você se você selecionar a Optimistic
Concurrency opção na DataAdapter Configuration Wizard. Ele é backup a você para adicionar
um código para manipular os erros com base em seus próprios requisitos de negócios. Fornece
um DBConcurrencyException objeto que retorna a linha que viola as regras de simultaneidade
ADO.NET. For more information, see Como: identificador erros concorrentes.
Como: identificador erros concorrentes
Você pode capturar o objeto DBConcurrencyException para ajudar a resolver problemas de

aparecimento de violações concorrentes. O objeto DBConcurrencyException retorna o linha de
dados que causou o erro. Para obter mais informações, consulte Membros
DBConcurrencyException.

As tentativas do exemplo a seguir, atualiza uma fonte de dados com o conteúdo do
NorthwindDataSet em um bloco try/catch, se um erro for gerado uma mensagem de erro é exibida
junto com a primeira coluna da linha de dados afetada.
Observação
O código abaixo é uma ilustração de uma estratégia para tratar um erro de atualização do banco
de dados. O código pressupõe várias coisas; uma conexão existente para um banco de dados, a
existência de um dataset, bem como a suposição que o comando de execução da atualização
será gerado numa violação de concorrência. Para obter mais informações e um exemplo
completo, consulte Passo a passo: Manipulando uma exceção de concorrência.
Para resolver uma violação de concorrência

1. Execute o comando para atualizar o banco de dados de dentro de um bloco try/catch.
2. Se uma exceção é gerada, inspecione a declaração catch da propriedade Row para
determinar o que causou a violação.
3. Adicione código para resolver o erro com base nas regras de negócio do aplicativo.
O código a seguir usa o CustomersTableAdapter e o NorthwindDataSet, como exemplos do
adaptador e do dataset em seu aplicativo.
C#
try { customersTableAdapter.Update(northwindDataSet); } catch (DBConcurrencyException ex) {
string customErrorMessage; customErrorMessage = "Concurrency violation\n"; customErrorMessage
+= ex.Row[0].ToString(); // Add business logic code to resolve the concurrency violation... }
Passo a passo: Manipulando uma exceção de concorrência
As exceções concorrentes (DBConcurrencyException) são geradas quando dois usuários tentam

alterar os mesmos dados em um banco de dados ao mesmo tempo. Nesta explicação passo a
passo você irá criar um aplicativo do Windows que ilustra a captura da linha que causou o erro
DBConcurrencyException e uma estratégia para você efetuar o tratamento.
Esta explicação passo a passo leva você através do seguinte processo:
1. Criar um novo projeto Windows Application.

2. Crie um novo dataset baseado na tabela Northwind Customers.
3. Criar um formulário com um DataGridView para exibir os dados.
4. Preencher um dataset com dados da tabela Customers do banco de dados Northwind.
5. Após preencher o dataset, use o Visual Database Tools no Visual Studio para acessar a
tabela de dados Customers e alterar diretamente um registro.
6. Então no formulário, altere o mesmo registro com um valor diferente, atualize o dataset, e
tente gravar as alterações no banco de dados, que resulta na geração de um erro
concorrente.
7. Capture o erro, e exiba as diferentes versões do registro, permitindo ao usuário determinar
se deseja continuar e atualizar o banco de dados, ou cancelar a atualização.
Pré-requisitos

• Acesso ao banco de dados de exemplo Northwind com permissão para executar
atualizações. Para obter mais informações, consulte COMO: Instalar Bancos de Dados de
Exemplo.
Observação
dependendo de suas configurações ativas. Para alterar as configurações, escolha Import and
Export Settings no menu Tools. Para obter mais informações, consulte Visual Studio Settings.
Criar um novo projeto
Você começará com a explicação passo a passo de como criar um novo aplicativo do Windows.
Para criar um novo projeto de um aplicativo do Windows
1. No menu File, criar um novo projeto.

2. Selecione uma linguagem de programação no painel Project Types.
3. Selecione Windows Application no painel Templates.
4. Nomeie o projeto como ConcurrencyWalkthrough, e clique OK.
O Visual Studio adiciona o projeto na Solution Explorer e exibe um novo formulário no
Designer.
Criando o dataset Northwind
Nesta seção você criará um dataset chamado NorthwindDataSet.
Para criar o NorthwindDataSet
1. No menu Data, escolha Add New Data source.

O Assistente para Configuração da Fonte de Dados é aberto.
3. Selecione uma conexão para o banco de dados de exemplo Northwind a partir da lista de
conexões disponíveis, ou clique em New Connection Se a conexão não estiver disponível
na lista de conexões.
Observação
Se você estiver se conectando a um arquivo de banco de dados local, selecione No quando

perguntado se você deseja adicionar o arquivo no seu projeto.
4. Clique Next na página Save connection string to the application configuration file.
5. Expanda o nó Tables e selecione a tabela Customers. O nome padrão para o dataset deve
ser NorthwindDataSet.
6. Clique Finish para adicionar o dataset para o projeto.
Criar um controle acoplado Data-DataGridView
Nesta seção você criará um DataGridView arrastando o Customers item da janela Data Sources
para seu Windows Form

Para criar um controle DataGridView que está acoplado à tabela Clientes
1. No menu Data, escolha Show Data Sources para abrir o Data Sources Window.
2. Expanda o nó NorthwindDataSet a partir da janela Data Sources e selecione a tabela
Customers.
3. Clique na seta para baixo no nó da tabela e selecione DataGridView na lista suspensa.
4. Arraste a tabela para uma área vazia do seu formulário.
Um controle DataGridView denominado CustomersDataGridView e um BindingNavigator
nomeado CustomersBindingNavigator são adicionados ao formulário vinculado, que por sua
vez o BindingSource é vinculado à tabela Customers no NorthwindDataSet.. NorthwindDataSet
Ponto de Verificação
Agora você pode testar o formulário para certificar-se que ele funciona como esperado até este
ponto.
1. Pressione F5 para executar o aplicativo

O formulário aparece com um controle DataGridView que é preenchido com dados da
tabela Customers.
2. No menu Debug, escolha Stop Debugging.
Manipular erros concorrentes
Como você manipula os erros depende como as regras específicas do negócio governam o
aplicativo. Para esta explicação passo a passo, após a geração de uma violação de concorrência,
a estratégia de manipulação do erro concorrência a seguir será usada como uma ilustração:
O aplicativo apresentará ao usuário três versões do registro:
• O registro atual no banco de dados.

• O registro original carregado para o dataset.
• As alterações propostas no dataset.
O usuário é então capaz de substituir o banco de dados com a versão proposta ou cancelar a
atualização e atualizar o dataset com os novos valores do banco de dados.
Para ativar o tratamento de erros concorrência
1. Criar um manipulador de erro personalizado.

2. Exibir as opções para o usuário.
3. Processar a resposta do usuário.
4. Reenviar a atualização, ou redefinir os dados no dataset.
Adicionar o código para tratar a exceção concorrente
Quando você tentar executar uma atualização e uma exceção é gerada, você geralmente deseja
fazer algo com as informações fornecidas pela exceção gerada.

Nesta seção você irá adicionar código que tentará atualizar o banco de dados, e tratar qualquer
DBConcurrencyException gerado, bem como qualquer outra exceção.
Observação
Os métodos CreateMessage e ProcessDialogResults serão adicionadas posteriormente nesta

Para adicionar o tratamento de erro para o erro de concorrência

1. Adicione o seguinte código abaixo o método Form1_Load:
C#
private void UpdateDatabase() { try {
this.customersTableAdapter.Update(this.northwindDataSet.Customers); MessageBox.Show("Update
successful"); } catch (DBConcurrencyException dbcx) { DialogResult response =
MessageBox.Show(CreateMessage((NorthwindDataSet.CustomersRow) (dbcx.Row)), "Concurrency
Exception", MessageBoxButtons.YesNo); ProcessDialogResult(response); } catch (Exception ex) {
MessageBox.Show("An error was thrown while attempting to update the database."); } }
2. Substitua o método CustomersBindingNavigatorSaveItem_Click para chamar o método

UpdateDatabase para que se pareça com o seguinte:
C#
private void customersBindingNavigatorSaveItem_Click(object sender, EventArgs e) {
UpdateDatabase(); }
Exibir as opções para o usuário
O código apenas que você escreveu chama o procedimento CreateMessage para exibir informações
de erro para o usuário. Para esta explicação passo a passo, você usará uma caixa de mensagem
para exibir as diferentes versões do Registro para o usuário e permitir que o usuário escolha se
deseja substituir o registro com as alterações ou cancelar a edição. Depois que o usuário
seleciona uma opção (clicar um botão) na caixa de mensagem, a resposta é passado para o
método ProcessDialogResult.
Para criar a mensagem a ser exibida para o usuário
• Crie a mensagem, adicionando o seguinte código para o Code Editor. Digite este código
abaixo para o método UpdateDatabase.
C#
private string CreateMessage(NorthwindDataSet.CustomersRow cr) { return "Database: " +
GetRowData(GetCurrentRowInDB(cr), DataRowVersion.Default) + "\n" + "Original: " + GetRowData(cr,
DataRowVersion.Original) + "\n" + "Proposed: " + GetRowData(cr, DataRowVersion.Current) + "\n" +
"Do you still want to update the database with the proposed value?"; } //---------------------------------------
----------------------------------- // This method loads a temporary table with current records from the
database // and returns the current values from the row that caused the exception. //------------------------
-------------------------------------------------- private NorthwindDataSet.CustomersDataTable
tempCustomersDataTable = new NorthwindDataSet.CustomersDataTable(); private
NorthwindDataSet.CustomersRow GetCurrentRowInDB(NorthwindDataSet.CustomersRow
RowWithError) { this.customersTableAdapter.Fill(tempCustomersDataTable);

NorthwindDataSet.CustomersRow currentRowInDb =
tempCustomersDataTable.FindByCustomerID(RowWithError.CustomerID); return currentRowInDb; }
//-------------------------------------------------------------------------- // This method takes a CustomersRow
and RowVersion // and returns a string of column values to display to the user. //----------------------------
---------------------------------------------- private string GetRowData(NorthwindDataSet.CustomersRow
custRow, DataRowVersion RowVersion) { string rowData = ""; for (int i = 0; i <
custRow.ItemArray.Length ; i++ ) { rowData = rowData + custRow.Item(i, RowVersion).ToString() + " ";
} return rowData; }
Processando resposta do usuário
Você também precisará codificar para processar a resposta do usuário à caixa de mensagem. As
opções são tanto sobrescrever o registro atual no banco de dados com a alteração proposta ou
abandonar as alterações locais e atualizar a tabela de dados com o registro corrente no banco de
dados. Se o usuário escolher Sim, o método Merge é chamado com o argumento
preserveChanges definido como true. Isso fará com que a tentativa de atualização ser bem
sucedida, porque agora a versão original do registro coincide com o registro no banco de dados.
Para processar a entrada de usuário na caixa de mensagem
• Adicione o seguinte código abaixo ao código adicionado na seção anterior.

C#
// This method takes the DialogResult selected by the user and updates the database // with the new
values or cancels the update and resets the Customers table // (in the dataset) with the values currently in
the database. private void ProcessDialogResult(DialogResult response) { switch (response) { case
DialogResult.Yes: UpdateDatabase(); break; case DialogResult.No:
northwindDataSet.Merge(tempCustomersDataTable); MessageBox.Show("Update cancelled"); break; } }
Teste
Agora você pode testar o formulário para certificar-se ele funciona como esperado. Para simular
uma violação de concorrência você precisa alterar os dados no banco de dados após preenchê no
NorthwindDataSet.

2. Após o formulário aparecer, deixe-lo funcionando e alterne para a IDE do Visual Studio.
3. No menu View, escolha Server Explorer.
4. No Server Explorer, expanda a conexão que seu aplicativo está usando e expanda o nó
Tables.
5. Clique com o botão direito do mouse na tabela Customers e selecione Show Table Data.
6. No primeiro registro (ALFKI) mude o ContactName) para Maria Anders2.
Observação
Navegue até uma linha diferente para confirmar a alteração.
7. Alterne para o ConcurrencyWalkthrough que esteja executando o formulário

8. No primeiro registro no formulário (ALFKI), altere o ContactName para Maria Anders1.
9. Clique no botão Save.
O erro de concorrência é gerado, e a caixa de mensagem aparece.
10. Clicar em No cancela a atualização e atualiza o dataset com os valores correntes no banco
de dados, enquanto clicar em Yes grava o valor proposto para o banco de dados.
Consulte também
Passo a passo: Salvando dados com os métodos DBDirect do Adaptador de Tabela
Esta explicação passo a passo fornece instruções detalhadas para executar instruções SQL
diretamente em um banco de dados usando os métodos DBDirect de um TableAdapter . Métodos
DBDirect de um TableAdapter fornecem um fino nível de controle sobre as atualizações de banco
de dados. Com eles podem executar especificamente instruções SQL ou procedimentos
armazenados por chamando individual dos métodos Insert, Update, e Delete conforme necessário
por seu aplicativo (em oposição a sobrecarga do método Update que executa as instruções
UPDATE, INSERT, e DELETE tudo em uma chamada).

• Selecione o controle a ser criado no formulário ao arrastar itens a partir da janela Data
• Criar um formulário vinculado a dados, arrastando itens da janela Data Sources para o
formulário.
• Adicionar métodos para acessar o banco de dados e executar inserções, atualizações e
exclusões diretamente no banco de dados.
Pré-requisitos
A primeira etapa é para criar um Windows Application.

2. Nome do projeto TableAdapterDbDirectMethodsWalkthrough.
O projeto TableAdapterDbDirectMethodsWalkthrough é criado e adicionado ao Solution
Explorer.
Criar uma fonte de dados do seu banco de dados

Os passos usados no Data Source Configuration Wizard para criar uma fonte de dados com
base na tabela Region, no banco de dados de exemplo Northwind. Você deve ter acesso ao banco
de dados de exemplo Northwind para criar a conexão. Para informações sobre como configurar

Ou-
8. Selecione a tabela Region, e clique Finish.
O NorthwindDataSet é adicionado ao seu projeto e a tabela Region aparece na janela Data
Sources.
Adicionar controles ao formulário para exibir os dados
Criar os controles com dados vinculados, arrastando itens da janela Data Sources para seu
formulário.
Para criar dados ligados a controles no Windows Form
• Arraste o nó principal Region da janela Data Sources para o formulário.

Um controle DataGridView e uma faixa de ferramenta. (BindingNavigator) para navegar pelos
registros aparecem no formulário. O NorthwindDataSet, RegionTableAdapter, BindingSource, e
BindingNavigator aparecem na bandeja do componente.
Para adicionar botões que chamaram os métodos individuais DbDirect TableAdapter
1. Arraste três controles Button do Toolbox par o Form1 (abaixo do RegionDataGridView).

2. Defina as seguintes propriedades Name e Text em cada botão.
Nome Texto
InsertButton Inserir
UpdateButton Atualização
DeleteButton Excluir

Para adicionar o código para inserir novos registros no banco de dados
1. Clique duas vezes em InsertButton para criar um manipulador de eventos para o evento
Click e abrir o seu formulário no Editor de Código.
2. Substituir o InsertButton_Click manipulador de eventos com o seguinte código:
C#
private void InsertButton_Click(object sender, EventArgs e) { Int32 newRegionID = 5; String
newRegionDescription = "NorthEastern"; try { regionTableAdapter1.Insert(newRegionID,
newRegionDescription); } catch (Exception ex) { MessageBox.Show("Insert Failed"); }
RefreshDataset(); } private void RefreshDataset() {
this.regionTableAdapter1.Fill(this.northwindDataSet1.Region); }
Para adicionar o código para atualizar registros no banco de dados
1. Clique duas vezes em UpdateButton para criar um manipulador de eventos para o evento
Click e abrir o formulário no Editor de Código.
2. Substituir o manipulador de eventos UpdateButton_Click com o seguinte código:
C#
private void UpdateButton_Click(object sender, EventArgs e) { Int32 newRegionID = 5; try {
regionTableAdapter1.Update(newRegionID, "Updated Region Description", 5, "NorthEastern"); }
catch (Exception ex) { MessageBox.Show("Update Failed"); } RefreshDataset(); }
Para adicionar o código para excluir registros do banco de dados
1. Clique duas vezes em DeleteButton para criar um manipulador de eventos para o evento
Click e abrir o formulário no Editor de Código.
2. Substitua o manipulador de eventos DeleteButton_Click com o seguinte código:
C#
private void DeleteButton_Click(object sender, EventArgs e) { try { regionTableAdapter1.Delete(5,
"Updated Region Description"); } catch (Exception ex) { MessageBox.Show("Delete Failed"); }
RefreshDataset(); }

• Clique no botão Insert e verifique se o novo registro aparece na grade.
• Clique no botão Update e verifique se o registro é atualizado na grade.
• Clique no botão Delete e verifique se o registro foi removido da grade.
Próximas etapas
Dependendo dos seus requisitos do aplicativo, existem várias etapas podem ser executadas após
criar um formulário vinculado a dados. Você pode fazer nesta explicação passo a passo alguns
aprimoramentos que incluem:

• Adicionando a funcionalidade pesquisa ao formulário. Para obter mais informações,
consulte Como: Adicionar uma Consulta Parametrizada a um Formulário em um Aplicativo do
Windows.
• Adicionar tabelas adicionais ao dataset, selecionando o Configure DataSet with Wizard
dentro da janela Data Sources. Você pode adicionar controles que exibem dados
relacionados, arrastando os nós relacionados para o formulário. Para obter mais informações,
consulte Como: exibir dados relacionados em um aplicativo Windows:.
Consulte também
Elementos de Dados de Interface de Usuário

Esta seção contém informações sobre todos os caixas de diálogo e assistentes que você usa ao
criar acesso a dados no seu aplicativo Visual Basic ou Visual C#.
Observação
dependendo de suas configurações ativas ou de edição. Para alterar as configurações, escolha
Import and Export Settings no menu Tools. Para obter mais informações, consulte Visual Studio
Settings.
Nesta seção
Marcas Inteligentes de Dados
Fornece informações sobre alguns comandos de marca inteligente que estão disponíveis
para dados.
Caixa de Diálogo Add Dataset
Coloca um dataset tipado existente ou um novo dataset sem tipo (uma instância da classe
System.Data.Dataset) em um formulário ou componente.
Caixa de Diálogo Advanced SQL Generation Options
Permite a você controlar como instruções SQL ou procedimentos armazenados são

criados para um adaptador de dados, especificando opções para atualizações,
simultaneidade otimista, e atualização do dataset.
Escolha uma caixa de diálogo Instância fonte de dados
Permite a você selecionar o dataset desejado em uma lista de datasets em seu projeto.
Caixa de diálogo Choose a Data Source to Merge With
Permite a você selecionar qual fonte de dados para mesclar quando várias fontes de
dados estão disponíveis.
Escolha Caixa de diálogo Chave
Permite a você selecionar uma tecla quando uma coluna participa de uma restrição multi-
chave.

Editores de Coleção
Fornece links para tópicos sobre editores de coleção diferentes que permitem a você criar
e editar membros individuais de uma coleção.
Conexões ausente
Informa quando um dataset contém uma referência para uma seqüência de conexão que
não está nas configurações do aplicativo.
Caixa de Diálogo Data Adapter Configuration Error
Exibe um ou mais erros que ocorreram enquanto o Visual Studio tentava criar uma
instância de um adaptador de dados e definir suas propriedades.
Data Adapter Configuration Wizard
Configura comandos SQL ou procedimentos armazenados que um adaptador de dados

usa para ler dados de um banco de dados para um dataset e para gravar no banco de
dados de volta. O tópico descreve como executar o assistente e o que fazer após a
conclusão do assistente.
Caixa de Diálogo Data Adapter Preview
Permite a você ver será como os dados preencherão um dataset através de um adaptador
de dados, o que é útil para testar se o adaptador está retornando os dados que você
espera, que mapeamentos de tabela funcionam corretamente, e o efeito de parâmetros de
diferentes valores.
Caixa de Diálogo Data Source Login
Permite a você solicitar acesso a uma fonte de dados (normalmente um banco de dados)
para o qual você ainda não tenha sido autenticado.
Guia, caixa de ferramentas DataSet
Exibe os objetos você pode adicionar a um dataset tipado.
Você deseja incluir a senha na caixa de diálogo a seqüência de conexão
Permite que você tenha controle se uma senha está incorporada na seqüência de
conexão.
Caixa de diálogo Edit Key
Permite a você definir e editar chaves.
Caixa de Diálogo Foreign Key Constraint
Permite a você colocar uma restrição de chave externa em uma ou mais colunas em uma
tabela dataset que está relacionada a outra tabela.
Caixa de Diálogo Generate Dataset

Permite a você gerar um novo dataset tipado a partir informações fornecidas por um ou
mais adaptadores dados e adicionar tabelas a um dataset existente.
Várias Caixas de Diálogo BindingSources
Permite a você selecionar qual BindingSource a ser usado quando mais de um

BindingSource está disponível.
Caixa de diálogo Preview Data
Permite a você revisar os dados retornados por consultas no seu projeto.
Caixa de Diálogo Preview SQL Script
Aparece como parte do Data Adapter Configuration Wizard para permitir que você possa
ver o script SQL que o assistente utilizará para criar procedimentos armazenados para ler
e gravar dados.
Caixa de Diálogo Relation
Permite a você criar um relacionamento (um objeto DataRelation) que mantém informação
sobre registros pai-filho em duas tabelas de dados em um dataset.
Caixa de Diálogo Construtora de Critérios de Pesquisa
Permite a você criar uma consulta parametrizada em um Windows Form vinculado a

dados, e adicionar automaticamente os controles necessários para executar a consulta.
Caixa de Diálogo Table Mappings
Permite a você especificar quais colunas em uma tabela do banco de dados ou outra fonte
de dados são equivalentes às colunas em uma tabela dataset.
Caixa de Diálogo Unique Constraint
Permite a você colocar uma restrição exclusiva em uma ou mais colunas em uma tabela
em um dataset sem tipo.
XML Designer
Fornece um conjunto de ferramentas visuais para trabalhar com Esquemas XML, Datasets
ADO.NET, e documentos XML.
Acessando Dados
Fornece links para tópicos que descrevem como acessar dados em seus aplicativos Visual
Basic e Visual C#.
Referência(Ferramentas de Banco de Dados Visual)
Fornece links para tópicos de referência sobre como trabalhar com Ferramentas de Banco
de Dados Visual.

Adaptadores de Dados do ADO.NET
Os tópicos a seguir fornecem informações sobre objetos adaptadores de dados ADO.NET e como
trabalhar com eles. Adaptadores são usados para trocar dados entre uma fonte de dados e um
DataSet.
Observação
Na versão anterior do Visual Studio Adaptadores de dados eram usados para comunicação entre
um aplicativo e um banco de dados. Embora adaptadores de dados sejam ainda um componente
principal do .NET Framework Data Providers, TableAdapters são componentes gerados pelo
designer que simplificam o processo de mover dados entre o seu aplicativo e um banco de dados.
Para obter mais informações sobre como trabalhar com TableAdapters, consulte Visão Geral do
Adaptador de Tabela.
Nesta seção
Introdução aos adaptadores de dados
Fornece uma visão geral do que são adaptadores de dados, para que são usados, e como
eles são estruturados.
Parâmetros de comandos Adapter Data-
Descreve a estrutura e uso de parâmetros que adaptadores passam em tempo de

execução para instruções SQL ou procedimentos armazenados.
Mapeamento de tabela em adaptadores de dados
Descreve as opções para obter informações sobre como mapear nomes de coluna entre
uma tabela de origem e uma tabela DataSet.
Criando adaptadores de dados
Lista maneiras diferentes de criar adaptadores de dados no Visual Studio.
Como configurar parâmetros para adaptadores de dados:
Explica como criar e definir propriedades de parâmetros que serão passados em tempo de
execução para comandos do adaptador de dados.
Como mapear colunas origem Data-para colunas Tabela DataSet data-:
Fornece instruções sobre como estabelecer e modificar o mapeamento entre os nomes de

coluna das tabelas de origem e as tabelas DataSet.
Como: Visualizar Resultados de um Data-Adapter
Fornece instruções para testar como um adaptador de dados preencherá um DataSet.
Criando aplicativos de dados com Visual Studio

Fornece uma introdução geral dos conceitos de acesso a dados no Visual Studio.
DataSets no Visual Studio Overview
Fornece informações básicas sobre a estrutura e o uso de DataSets.
Populating a DataSet from a DataAdapter
Apresenta uma série de tópicos de código exemplo específico para preencher DataSets
com adaptadores de dados.
Visão Geral do Adaptador de Tabela
Explica o que são TableAdapters e ferramentas disponíveis para criá-los.
Como: Criar TableAdapters
Fornece as etapas para criar um novo TableAdapter.
Como: Editar consultas do TableAdapter
Fornece as etapas para adicionar uma consulta a um TableAdapter existente.
Consulte também
Conceitos
Projetos SQL Server

Você pode usar linguagens .NET Framework em conjunto com a linguagem de programação
Transact-SQL para criar objetos de banco de dados tais como procedimentos armazenados e
disparadores, e para recuperar e atualizar dados para banco de dados Microsoft SQL Server
2005. O desenvolvimento de objetos de banco de dados .NET Framework para SQL Server
usando código gerenciado tem muitas vantagens quando comparado com Transact-SQL. Para
obter mais informações, consulte Vantagens de usar código gerenciado para criar objetos de
bancos de dados.
Para criar um objeto de banco de dados, você deve criar um projeto SQL Server, adicionar os
itens necessários ao projeto e adicionar código a esses itens. Em seguida, você deve compilar o
projeto em um assembly e implantá-lo no SQL Server.
Observação
O recurso de integração Common Language Runtime (CLR) fica desativado por padrão no
Microsoft SQL Server e deve ser ativado para usar itens de projeto SQL Server. Para ativar a
integração CLR, use a opção clr enabled do procedimento armazenado sp_configure. Para mais
informações, consulte Enabling CLR Integration.
Crie um novo projeto SQL Server clicando no menu File, selecionando Project e depois
selecionando SQL Server Project na New Project Dialog Box. Para obter mais informações,
consulte Como: criar um projeto SQL Server.

Após criar o novo projeto SQL Server, a Add Database Reference Dialog Box é exibida. Use esta
caixa de diálogo para adicionar uma referência do banco de dados, ou conexão, para o projeto.
Você pode selecionar um referência do banco de dados que está disponível no momento no
Server Explorer/Database Explorer ou definir uma nova conexão. Somente uma referência do
banco de dados pode ser adicionada ao projeto.
Propriedades do projeto
Você pode alterar o Assembly name, que é o nome do arquivo de saída que contém o manifesto
do assembly. Se você alterar o nome do assembly, o nome do objeto do banco de dados no
banco de dados do SQL Server também é alterado.
Adicionando itens ao projeto
Novos projetos SQL Server contêm somente referências e informações de assembly. Para criar
objetos de banco de dados, você deve primeiro adicionar itens ao projeto e depois adicionar
código aos itens. Para obter mais informações, consulte Modelos de Item para Projetos do SQL
Server.
A tabela a seguir lista itens específicos para projetos SQL Server que você pode adicionar.
Item Mais informações
Procedimento armazenado Como: criar e executar um procedimento armazenado SQL Server

CLR
Disparador Como: Criar e Executar um Disparador SQL Server CLR
Função definida pelo Como criar e executar um SQL CLR Server função definida pelo
usuário usuário:
Tipo definido pelo usuário Como criar e executar um SQL CLR Server função definida pelo
usuário:
Agregado Como criar e executar uma agregação ao CLR do SQL Server:
Compilando, implantando e depurando
Quando você compila seu projeto, ele é compilado em um assembly que pode ser implantado em
um banco de dados que está referenciado no projeto e depurado.
Dica
Como uma alternativa a compilar, implantar e depurar em três etapas separadas, você pode usar
o comando Start (F5) ou o comando Start Without Debugging (CTRL+F5) para compilar o
assembly, implantá-lo no banco de dados e depurar o objeto de banco de dados.
Antes de você poder depurar o objeto de banco de dados, você deve adicionar código Transact-
SQL ao item Test.sql. O script no item Test.sql é essencial para a depuração porque ele executa
as ações no banco de dados que são necessárias para iniciar e testar seu objeto de banco de
dados. Quando ele é adicionado ao seu projeto, o item Test.sql contém esboço de código para
um script que executa a ação necessária no banco de dados. Se seu projeto SQL Server contém
mais de um objeto de banco de dados, o script do item Test.sql deve executar cada um dos
objetos de banco de dados.
Esse requisito de script de depuração é diferente de, por exemplo, um projeto do Windows Forms,
que cria e executa um programa executável independente; objetos de banco de dados são
executados apenas em resposta a ações ou chamadas no banco de dados. Por exemplo, um
disparador pode ser ativado quando uma nova linha é inserida em uma tabela. Portanto, o script
de Test.sql deve inserir uma nova linha em uma tabela para ativar o disparador. Os resultados do
disparador serão exibidos na Output Window no Visual Studio, para que você possa determinar
se o disparador está funcionando corretamente.
Em seguida, adicione código ao item que você adicionou no seu projeto SQL Server e ao item
Test.sql. Você pode encontrar código de exemplo para cada objeto de banco de dados em
tópicos sobre o item de banco de dados disponível. Consulte a tabela anterior.
Compilando um projeto SQL Server
Quando você compila seu projeto, ele é compilado em um assembly. Se você estiver usando
Visual Basic, use o seguinte procedimento:
Para compilar um projeto SQL Server em Visual Basic

2. No menu Build, escolha Build<ProjectName>.
Se você estiver usando Visual C# ou Visual J#, use o seguinte procedimento:
Para criar um projeto SQL Server em Visual C# ou Visual J#
1. No Solution Explorer, selecione a solução.

Implantando o assembly em um banco de dados
Ao implantar o assembly no banco de dados que é referenciado no projeto, a conexão ao banco

de dados é feita e depois o assembly é copiado para o banco de dados, onde ele é registrado e
atributos são definidos. Devido ao fato de o assembly ser implantado em um banco de dados
específico em um servidor, se você cria uma nova referência de banco de dados para um banco
de dados diferente no mesmo servidor, o assembly deve ser implantado no segundo banco de
dados antes que ele possa ser usado.
Se você estiver usando Visual Basic, use o seguinte procedimento.
Para implantar um assembly do SQL Server Class Library em Visual Basic

2. No menu Build, escolha Deploy<ProjectName>.
Se você estiver usando Visual C# ou Visual J#, use o seguinte procedimento.
Para implantar um assembly do SQL Server Class Library em Visual C# ou Visual J#

2. No menu Build, escolha Deploy Solution.
Depurando o objeto de banco de dados
Quando você depura um objeto de banco de dados, o assembly é compilado, implantado no

banco de dados e depurado. Quando você depura um objeto de banco de dados que foi
compilado e implantado anteriormente, o assembly é compilado novamente apenas se o projeto
tiver sido alterado desde a última vez em que ele foi compilado. O assembly é sempre excluído do
banco de dados e copiado novamente.
Para depurar o objeto de banco de dados

2. No menu Debug, escolha Start.
3. Na janela Output, na lista Show output from, escolha Database Output para visualizar
os resultados.
Consulte também
Tarefas
Passo a passo: Criando um procedimento armazenado no código gerenciado
Procedimentos armazenados para bancos de dados SQL Server 2005 agora podem ser escritos
em código gerenciado usando as linguagens do .NET Framework como Visual Basic e C#.
Procedimentos armazenados escritos em código gerenciado são chamados procedimentos
armazenados CLR.
Você pode criar procedimentos armazenados SQL adicionando itens Stored Procedure a
projetos SQL Server. Após a implantação bem sucedida para um SQL Server, procedimentos
armazenados criados no código gerenciado são chamados e executados como qualquer outro
procedimento armazenado.

• Criando um procedimento armazenado no código gerenciado.
• Implantando o procedimento armazenado em um banco de dados SQL Server 2005.
• Criando um script para testar o procedimento armazenado no banco de dados.
• Consultando dados no banco de dados para confirmar que o procedimento armazenado
executa corretamente.
Pré-requisitos
• Uma conexão com o banco de dados de exemplo AdventureWorks executando em SQL

Server 2005. Para obter mais informações, consulte COMO: Instalar Bancos de Dados de
Exemplo
Criando o projeto
Para criar o novo projeto de SQL Server

2. Selecione SQL Server Project, nomeie o projeto SQLCLRStoredProcedure e clique em
OK. Para obter mais informações, consulte Como: criar um projeto SQL Server.
Conectando-se a um banco de dados SQL Server 2005
Esta explicação passo a passo requer uma conexão para o banco de dados de exemplo
AdventureWorks executando em SQL Server 2005. Se uma conexão com o banco de dados de
exemplo AdventureWorks estiver disponível no Server Explorer, então ele será listado na Add
Database Reference Dialog Box.
Observação
O recurso de integração do common language runtime (CLR) fica desativado por padrão no
Microsoft SQL Server e deve ser ativado para usar itens de projeto de SQL Server. Para ativar
integração CLR, use a opção clr enabled do procedimento armazenado sp_configure. Para mais
informações, consulte Enabling CLR Integration.
Para se conectar ao banco de dados de exemplo AdventureWorks
• Conecte-se ao banco de dados de exemplo AdventureWorks incluído com o SQL Server

2005 completando a caixa de diálogo Add Connection. Para obter mais informações, consulte
Add/Modify Connection (Microsoft SQL Server).
- ou -
• Selecione uma conexão existente com o banco de dados de exemplo AdventureWorks na
caixa de diálogo Add Database Reference. Para obter mais informações, consulte Add
Database Reference Dialog Box.
Criando o procedimento armazenado SQL Server
Após criar o projeto de SQL Server, adicione um procedimento armazenado a ele.
Para criar o procedimento armazenado SQL Server
1. No menu Project, escolha Add New Item.

2. Selecione Stored Procedure em Add New Item Dialog Box.
3. Digite InsertCurrency como o Name para o novo procedimento armazenado.
4. Clique em Add.
5. Substitua o código no Code Editor com o seguinte:
Implantando, Executando, e Depurando o procedimento armazenado
Após você criar um novo procedimento armazenado, ele pode ser criado, implantado no SQL
Server, e depurado, pressionando F5. Primeiro, no arquivo Test.sql encontrado na pasta
TestScripts do seu projeto, adicione código para executar e testar seu procedimento
armazenado. Para obter mais informações sobre como criar scripts de teste, consulte Como:
Editar o script Test.sql para executar objetos SQL.
Para obter mais informações sobre depuração de SQL, consulte Depuração objetos de banco de
dados SQL.
Para distribuir, e executar o procedimento armazenado InsertCurrency

1. No Solution Explorer, expanda a pasta TestScripts e clique duas vezes no arquivo
Test.sql.
2. Substitua o código no arquivo Test.sql com o seguinte código:
EXEC InsertCurrency 'AAA', 'Currency Test' SELECT * from Sales.Currency where CurrencyCode =
'AAA'
3. Pressione F5 para criar, implantar e depurar o procedimento armazenado. Para

informações sobre como implantar sem depuração, consulte Como implantar SQL itens
Project Server em um SQL Server:.
Veja os resultados na janela Output e selecione Show output from: Database Output.

Criando Classes (Como Fazer em C#)
Esta página possui links para Ajuda sobre tarefas do Class Designer usadas amplamente em C#.
Para ver outras categorias de tarefas populares abordadas na ajuda, consulte Como Fazer em C#.
Os seguintes sites requerem uma conexão com a Internet.
Centro de Desenvolvimento do Visual Studio 2005
Contém vários artigos e recursos em desenvolvimento de aplicativos usando o Visual

Studio 2005. Este site é atualizado regularmente com novo conteúdo.
Centro de Desenvolvimento do Visual C#
Contém vários artigos e recursos em desenvolvimento de aplicativos C#. Este site é

atualizado regularmente com novo conteúdo.
Centro de Desenvolvimento do Microsoft .NET Framework
Contém vários artigos e recursos em desenvolvimento e aplicativos .NET Framework de

depuração. Este site é atualizado regularmente com novo conteúdo.
Centro de Desenvolvimento de Padrões Microsoft e Práticas
Recomendações específicas de cenários ilustrando como criar, desenvolver, distribuir e

operar arquitetonicamente aplicativos para a plataforma Microsoft .NET.
COMO: Criar Tipos em Diagramas de Classe

Em Class Designer, você pode criar tipos no diagrama de classe arrastando-os na caixa de
ferramentas Class Designer. Caixa de ferramentas Class Designer contém os seguintes tipos:
• Class
• Enumeração
• Interface
• Classe abstrata
• Estrutura
• Delegado
• Module (Visual Basic somente)
Para exibir tipos existentes em um projeto, consulte COMO: Exibir tipos existentes.
Para criar um tipo em um diagrama de classe

1. A partir do projeto no Solution Explorer, abra um arquivo diagrama de classe (.CD).
Dica
Se o projeto não contém um arquivo diagrama de classe, você deve adicionar um. Para obter mais

informações, consulte COMO: Adicionar diagramas de classes a projetos.
2. Abrir Caixa de ferramentas Class Designer clicando na Toolbox guia.
Dica
Para manter a caixa de ferramentas aberta enquanto você trabalha no Class Designer, clique no
Auto Hide botão (de pino de envio) na caixa de ferramentas.
3. Na caixa de ferramentas Class Designer, arraste uma forma tipo para o diagrama de
classe.
Caixa New <Type> de diálogo aparecerá para que você pode especificar o nome do tipo, o
nome do arquivo para salvar o código para o tipo, e o nível de acesso para o tipo. Identifica
<Type> o tipo que você está criando, tais como Class ou Enumeration.
4. Na caixa New <Type> de diálogo, execute uma das opções a seguir:
o Para aceitar os valores padrão, clique em OK.
o Para especificar valores diferentes, digite o nome e nome de arquivo para o tipo,
escolha o nível de acesso para o tipo na caixa Access de listagem, e clique em OK.
Dica
Para selecionar um arquivo existente, clique no ellipsis. (…) botão ao lado da File name Caixa
5. A forma que representa o tipo aparece no diagrama na posição onde você arrastado-lo. Se
você especificou um novo nome de arquivo Visual Studio cria um arquivo código fonte com
o nome do tipo no nó de projeto em Solution Explorer. Se você escolher um arquivo
existente, Visual Studio adiciona o código para o novo tipo ao arquivo especificado.
Criando e Configurando Membros de Tipos

Depois que tiver criado um tipo em um diagrama de classe, você pode adicionar seus membros e
configurá-los. Faça isso usando a Class Details janela, que por padrão aparece na parte inferior
da janela do Visual Studio quando você abre um diagrama de classe. As seções a seguir
descrevem como trabalhar com membros tipo.
Criar membros tipo

Depois que tiver criado um tipo em um diagrama de classe, você pode adicionar membros a ela e
configurá-los Para obter informações sobre como adicionar membros, consulte COMO: Criar um
membro. Para obter informações sobre como modificar membros (configuração), consulte COMO:
Modificar membros de tipo.
Cada tipo que pode ser representado em um diagrama de classe pode conter tipos específicos de
membros. A tabela a seguir descreve os tipos podem conter os membros:
Type (Tipo) Ele pode conter membros
Class Método, Propriedade (para C# e Visual Basic), campo, evento (para C# e Visual
Basic), (método) construtor, destruidor (método), constante

Enum Membro
Struct Método, campo de propriedade (para C# e Visual Basic), evento (para C# e Visual
Basic), (método) construtor, constante
Interface método, evento (para C# e Visual Basic), propriedade

Método, Campo (para J#)
Delegado Parâmetro
Observação
O único tipo para o qual você pode especificar parâmetros é delegado. Você pode especificar
parâmetros para métodos, que por sua vez pode ser adicionado aos tipos para classe, estrutura, e
interface; para obter mais informações consulte COMO: Adicionar um parâmetro a um método.
COMO: Modificar membros de tipo

Class Designer permite-lhe modificar os membros de tipos exibidos no diagrama. Você pode
modificar os membros de qualquer tipo exibido em um diagrama de classe que é Não READ-
ONLY (consulte Exibição de informações somente leitura). Você Modificar membros tipo usando
edição in-loco na superfície de design, grade propriedade, a janela Detalhes classe, que por
padrão aparece no canto inferior da janela do Visual Studio quando você abrir um diagrama de
classe.
Observação
Para obter informações sobre como criar membros tipo, consulte Criar membros tipo.
Para modificar um membro tipo

1. Selecione o tipo no Class Designer.
2. Se a janela Detalhes classe não for exibida, exiba-o. (Consulte COMO: Abrir a janela Class
Details.)
3. Edite os valores nos campos da grade da janela Detalhes classe. Após cada edição,
pressione enter, ou caso contrário mover foco fora do campo editado, tais como
pressionando TAB. Suas edições refletem imediatamente no código.
Observe que se você desejar modificar o nome de um membro, somente poderá fazer tão in
loco no diagrama.. tão in loco no diagrama
COMO: Adicionar um parâmetro a um método

Você pode adicionar um parâmetro para um método utilizando a janela Detalhes classe.
Observação

Para adicionar um parâmetro a um delegado, consulte COMO: Criar um membro.
Observação
Embora um destruidor seja um método, ele não pode ter parâmetros.
Para adicionar um parâmetro para um método

1. Na superfície do diagrama, clique no tipo contendo o método ao qual você deseja adicionar
um parâmetro.
O tipo obtém foco e exibirá seu conteúdo na janela Detalhes classe.
2. Na janela Detalhes classe, expanda a linha do método ao qual você deseja adicionar um
parâmetro.
Uma linha de parâmetro recuado aparece, contendo apenas um par de parênteses e as
palavras <add parameter>.
3. Clique em <add parameter>, digite o nome do novo parâmetro, e pressione ENTER.
O novo parâmetro é adicionado ao código do método é o método e. Ele exibe na janela
Detalhes classe e a janela Propriedades.
4. Como opção, especificar outros detalhes sobre o parâmetro, como seu tipo.
COMO: Abrir a janela Class Details

Detalhes de classe é uma janela você pode usar para configurar os membros de um tipo. Por
padrão, a janela Detalhes classe aparece automaticamente quando você abre um novo diagrama
de classe (consulte COMO: Adicionar diagramas de classes a projetos). Você também pode abrir
a janela Detalhes classe explicitamente, das maneiras a seguir.
Para abrir a janela Detalhes classe

1. Clique com o botão direito do mouse a superfície de um diagrama de classe para exibir um
menu de contexto.
2. No menu de contexto, clique em Class Details Window.
ou –-
• Aponte para Other Windows no menu Exibir e clique em Class Details.

Consulte também
Atalhos de teclado para a janela Detalhes de classe

Você pode usar o teclado, bem como o mouse para executar ações de navegação na janela
Detalhes classe
Usar o mouse
Usar o mouse, você pode alterar a aparência da janela do detalhes classe e os dados ele exibe,
em maneiras a seguir:

• Clicar em qualquer célula editável permite que você editar o conteúdo da célula. Suas
alterações são refletidas em todos os locais que dados são armazenados ou exibido, incluindo
na janela Propriedades do e no código fonte.
• Clicar em qualquer célula de uma linha faz a janela Propriedades para exibir as
propriedades para o elemento representados por aquela linha.
• Para alterar a largura de uma coluna, arraste o limite no lado direito do cabeçalho da
coluna até que a coluna esteja da largura desejada.
• Você pode expandir ou recolher compartimento ou nós propriedade clicando no sinal de
mais ou menos símbolo à esquerda da linha.
• A janela Detalhes de classe oferece vários botões para criar novos membros da classe
atual e para navegar entre os membros dos compartimentos na grade da janela Detalhes
classe. Para obter mais informações, consulte botões janela Detalhes classe.
Usando o teclado
Observação
Os acoplamentos de teclas a seguir foram escolhidos para especificamente para imitar a
experiência de digitar código.
Use estas teclas para navegar a janela Detalhes classe:
Chave Resultado
(vírgula) Se o cursor estiver em uma linha de parâmetro, digitar uma vírgula Move o
cursor para o campo Nome do parâmetro próximo. If the cursor is in the last
parameter row of a method, it moves the cursor to the <add parameter> field,
which you can use to create a new parameter.
Literalmente se o cursor está em outro lugar na janela Detalhes classe, digitar
uma vírgula adicionará uma vírgula no campo atual.
(ponto-e- Mova o cursor para o campo Nome da próxima linha na grade da janela
vírgula) Detalhes classe Membro.
Ou
Parêntese de
fechamento ())
Tab Move o cursor para o campo próximo, primeiro mover da esquerda para direita e
então superior para baixo. Se o cursor está movendo de um campo em que
você digitou texto, janela Detalhes classe processa esse texto e o armazena se
ele não produz um erro.
If the cursor is on an empty field such as <add parameter>, Tab moves it to the
first field of the next row.
< espaço > Move o cursor para o campo próximo, primeiro mover da esquerda para direita e
então superior para baixo. If the cursor is on an empty field such as <add
parameter>, it moves to the first field of the next row. Note that <space>
typed immediately after a comma is ignored.
Se o cursor for no campo Resumo, digitar um espaço adicionará um caractere
de espaço.
Se o cursor está na coluna de uma linha determinada, ocultar digitar um espaço
alternará o valor na caixa de seleção Ocultar.
CTRL + TAB Alterna para outra janela do documento. Por exemplo, alterne da janela
Detalhes classe para um arquivo de código aberto.
ESC (ESCAPE) Se você tiver começado digitar texto em um campo, pressionando ESC atua

como uma chave de desfazer, revertendo o conteúdo do campo para o valor
anterior. Se a janela Detalhes classe tem foco geral, mas nenhuma célula
específica tiver foco, pressionar ESC move o foco fora da janela Detalhes
classe.
Seta superiores Essas chaves mova o cursor de linha para outra verticalmente na grade da
e inferiores seta janela Detalhes classe.
Seta à Se o cursor for na coluna Nome, pressionar a seta esquerda recolhe o nó atual
esquerda na hierarquia (se ele estiver aberto).
Seta à direita Quando o cursor está na coluna Nome, pressionando na SETA PARA DIREITA
expande o nó atual na hierarquia (se ele estiver recolhido).
Observações úteis sobre a janela Class Details

Observe as seguintes dicas para usar a janela Detalhes classe.
Células editáveis e não-editáveis
Todas as células na janela Detalhes classe são editáveis com algumas exceções:
• O tipo inteiro é somente leitura, quando, por exemplo, ele reside em um conjunto de
referência (consulte Exibição de informações somente leitura.) Quando você seleciona a forma
no Class Designer, a janela Detalhes classe exibe seus detalhes em um estado somente
leitura.
• Para indexadores, o nome é somente leitura e o restante (tipo, modificador, Resumo) é
editável.
• Todos os generics ter parâmetros somente leitura na janela Detalhes classe. Para alterar
um parâmetro genérico, edite o código fonte.
• O nome do parâmetro do tipo que é definido em um tipo genérico é somente leitura.
• Quando código Um do tipo é interrompido (não analisável), janela Detalhes classe exibe
conteúdo do tipo como somente leitura.
O código janela Detalhes classe e fonte
• Você pode exibir código fonte clicando com o botão direito do mouse uma forma na janela
Detalhes classe (ou o Class Designer) e, em seguida, clicando em Exibir código. O arquivo de
código de fonte abre e rola para o elemento selecionado.
• Imediatamente Alterar código fonte será refletida na exibição de informações de assinatura
no Class Designer e a janela Detalhes classe. Se a janela Detalhes classe é fechada ao tempo,
as novas informações estará visíveis na próxima vez que abri-lo.
• Quando código Um do tipo é interrompido (não analisável), janela Detalhes classe exibe
conteúdo do tipo como somente leitura.
Funcionalidade da Área de transferência na janela Detalhes classe
Você pode copiar ou recortar campos ou linhas na janela Detalhes classe e colá-los em outro tipo.
Você pode diminuir uma linha somente se ele for não somente para leitura. Quando você cola a
linha, janela Detalhes classe atribui um novo nome (derivado do nome da linha copiada) para
evitar um conflito.

Exibição de informações somente leitura
Class Designer e a janela Detalhes classe pode exibir o tipos (e membros de tipos) para o
seguinte:
• Um projeto que contém um diagrama de classe

• Um projeto referenciado a partir de um projeto que contém um diagrama de classe
• Um conjunto de módulos (assembly) referenciado a partir de um projeto que contém um
diagrama de classe
Nos dois últimos casos, a entidade de referência (um tipo ou membro) é somente para leitura no
diagrama de classe que representa.
Um projeto inteiro ou partes dele, tais como arquivos individuais, podem ser somente leitura. Os
casos mais comuns em que um projeto ou um de seus arquivos é somente leitura são quando ele
está sob controle Código fonte-(e possível check-out), ele existe em um conjunto externo, ou
quando o sistema operacional considera os arquivos para ser somente leitura.
Controle Code origem-
Como um diagrama de classe é salvo como um arquivo em um projeto, você precisa fazer check-
out do projeto para salvar as alterações feitas na Class Designer ou na janela Detalhes classe.
Se você não faça check-out do projeto, você pode ainda salvar um diagrama de classe que
descreve o projeto, mas não como parte do projeto.
Projetos somente leitura
O projeto pode ser somente leitura por uma razão diferente de controle código fonte-. Fechar o
projeto exibe uma caixa de diálogo perguntando se deve substituir o arquivo de projeto, descartar
alterações (não salvar) ou cancelar a operação de fechamento. Se você optar por substituir,
arquivos de projeto são sobrescritos e feita somente leitura. O novo arquivo diagrama de classe
for adicionado.
Tipos somente leitura
Se você tentarem salvar um projeto contendo um tipo cujo arquivo código-fonte é somente para
leitura, caixa Save of Read-Only File de diálogo aparece, que oferece opções para salvar o
arquivo com um novo nome ou novo local, ou para substituir o arquivo somente leitura. Se você
substituir o arquivo, a nova cópia é mais somente leitura.
Se um arquivo de código contém um erro de sintaxe, formas Exibir código no arquivo serão
somente leitura-temporariamente até ser corrigido o erro de sintaxe. Formas de nesse estado
exibir texto vermelho e um ícone vermelho que exibe uma dica de ferramenta ler " O arquivo
código fonte contém um erro de análise ".
Um tipo referenciado (como um tipo .NET Framework), que existe em outro nó de projeto ou em
um nó conjunto referenced-, é indicado na superfície de design Class Designer como somente
leitura. Um tipo local, que existe no projeto você tenha aberto, é leitura-gravação, e sua forma
sobre o Class Designer superfície do design é indicada as such.
Indexadores são de leitura-gravação em código e janela Detalhes classe, mas o indexador nome é
somente leitura.

Elementos da janela Class Details
A janela Detalhes classe é útil para exibindo detalhes membro das formas selecionadas no
diagrama, e fornece uma experiência de edição para criar e modificar membros tipo. A janela
Detalhes classe consiste de uma combinação de um controle de árvore e uma grade. O controle
de árvore permite que você expandir e recolher compartimentos membro para ver mais detalhes
ou menos. Área da grade armazena dados em linhas e colunas.
A grade exibe uma hierarquia de dois níveis de linhas. Linhas no nível superior Exibir membros.
Linhas no nível inferior exibir parâmetros, sob os métodos às quais eles pertencem.
As seções em In This Section descrevem aspectos das linhas exibidas pela janela Detalhes
classe.
Linhas membro
Todos os membros descritos na janela Detalhes classe representam os membros do tipo
selecionado no diagrama de classe. Existem quatro tipos de membros: métodos, propriedades,
campos, e eventos. Linhas membro fornecem Nível baixo edição de membros tipo.
Todas as linhas membro aparecem em títulos que agrupam os membros por tipo. Por exemplo,
todas as propriedades aparecer sob o título Properties, que, como um nó na grade, pode ser
expandida ou recolhida.
Cada linha membro exibe os seguintes elementos:
• Member Icon
Cada tipo de membro é representado por seu próprio ícone. Apontando o mouse para o ícone
membro exibe o membro é assinatura. Clicando no ícone membro ou em espaço em branco
para a esquerda do ícone membro seleciona a linha.
• Member Name
A Name coluna em uma linha membro exibe o nome do membro. Este nome também é exibido
na propriedade Name na janela Propriedades. Você pode usar essa célula para alterar o nome
de qualquer membro com permissões somente leitura.
Apontando o mouse para o nome do membro exibe o nome do membro se a Name coluna é
muito estreita para mostrar o nome completo.
• Member Type
A Member Type célula usa IntelliSense (exceto em J#), que permite que você escolha em uma
lista de todos os tipos disponíveis no projeto atual ou projetos referenciados.
• Member Modifier
Nesta coluna, você pode alterar o Modificador de visibilidade de um membro a um Public
(public. (private (internal, Private), Friend ou Default (protected (protected internal),
Protected Friend,) Protected))
• <add member>
A última linha na janela Detalhes classe contém o texto <add member> na célula Name.
Clicando nesta célula permite que você criar um novo membro. Para obter mais informações,
consulte: COMO: Criar um membro.
• Member properties in the Properties window

A janela Detalhes classe exibe um subconjunto das propriedades membro que são exibidos na
janela Propriedades. Alterar uma propriedade em um local atualiza o valor da propriedade
globalmente, incluindo a exibição de seu valor em outro local.
• Summary
A Summary célula expõe um resumo das informações sobre o membro. Clicando na elipse na
célula Summary permite que você se exibir ou editar informações sobre o Summary, Return
Type., e Remarks para o membro
• Hide
Quando a caixa de seleção Ocultar é marcada, o membro não é exibido no tipo.
Linhas de parâmetro
Parâmetros de um membro são agrupados juntos nas linhas imediatamente sob o membro ao
qual eles se aplicam. Linhas parâmetro conter os seguintes itens:
• Parameter Icon
Três tipos de ícones aparecem à esquerda de linhas de parâmetro:
o An opening parenthesis '(' indicates the first parameter of a member.
o Um parêntese de fechamento ') '. indica a linha após o último parâmetro do membro
Esta linha contém as palavras <add parameter>.
o Um separador de parâmetro (. ', ') aparece à esquerda de cada parâmetro após a
primeira que uma vírgula,
• Parameter Name
A Name coluna em uma linha de parâmetro exibe o nome do parâmetro. Este nome também é
exibido na propriedade Name na janela Propriedades. Você pode usar essa célula para alterar
o nome de qualquer parâmetro com permissões somente leitura.
Apontando para o nome do parâmetro exibe o nome do parâmetro se a Name coluna é muito
estreita para mostrar o nome completo.
• Parameter Type
A Parameter Type célula usa IntelliSense, que permite que você escolha em uma lista de
todos os tipos disponíveis no projeto atual ou projetos referenciados.
• Parameter Modifier
A Modifier célula em uma linha de parâmetro aceita e exibe o novo modificador do parâmetro.
Para usar a caixa de listagem drop-down para selecionar In, In/Out, insira um novo modificador
de parâmetro, e Out.
• <add parameter>
A última linha de parâmetro de um membro contém o texto <add parameter> na célula Name.
Permite que você criar um novo parâmetro clicando nesta célula. Para obter mais informações,
consulte COMO: Adicionar um parâmetro a um método.
• Parameter properties in the Properties window
A janela Propriedades exibe as mesmas propriedades de parâmetro exibidas na janela
Detalhes classe: Modifier., Name e Type Alterar uma propriedade em um local atualiza o valor
da propriedade globalmente, incluindo a exibição de seu valor em outro local.
COMO: Herdar de um Tipo Genérico

Você pode usar Class Designer para criar um tipo herdeira de um tipo genérico.

Observação
Usando Class Designer, você pode visualizar existentes tipos genéricos, mas você pode criar
novos tipos genéricos. Você também não pode modificar parâmetros tipo em existentes tipos
genéricos.
Para herdar de um tipo genérico

1. Na Toolbox, selecione a Inheritance linha.
2. Na diagrama de classe, desenhe uma linha de herança do tipo derivado para o tipo base.
(Neste procedimento, o tipo base é um tipo genérico.)
Uma linha de herança do tipo derivado apontando para o tipo base será exibida na
superfície do design. A Linha de Herança obtém foco e sua exibição propriedades na janela
Propriedades.
A Type Arguments propriedade na janela Properties exibe valores padrão para a linha de
herança. Alterar o valor da propriedade Type Arguments para coincidir com os tipos
desejados para o tipo derivado.
COMO: Definir herança entre tipos

Em Class Designer, você pode definir uma relação de herança entre dois tipos em um diagrama
de classe.
Para definir herança entre dois tipos

1. A partir do projeto no Solution Explorer, abra o arquivo diagrama de classe (.CD).
2. Na caixa de ferramentas Class Designer, clique na Inheritance ferramenta.
3. Mova o ponteiro para o diagrama de classe.
O ponteiro se transformar em um cursor de herança.
4. No diagrama de classe, arraste uma linha a partir da forma que representa o tipo derivado
para a forma que representa o tipo base.
Dica
O cursor de herança mudar para um cursor conectado quando você pode criar uma relação de
herança. O cursor de herança mudar para um cursor soltar não-quando você não pode criar uma
relação de herança.
5. Uma linha de herança com uma seta apontando para o tipo base do tipo derivado aparece
entre as duas formas no diagrama. A forma a tipo do tipo derivado também exibe o nome do
tipo base.
6. Observe que se a classe pai é uma classe abstrata e contém pelo menos um membro
abstract, esses participantes será automaticamente implementadas em classes abstratas
não-inheriting. Para obter mais informações, consulte COMO: Implementar uma classe
abstrata.
COMO: Definir associações entre tipos

Linhas de associação em Class Designer mostrar como classes em um diagrama estão
relacionadas. Uma linha de associação representa uma classe que é o tipo de uma propriedade

ou campo de outra classe no projeto. Linhas de associação geralmente são usadas para ilustrar
os relacionamentos entre classes no seu projeto mais importantes.
Enquanto você poderia exibir todos os campos e propriedades como associações, faz mais
sentido para mostrar somente os membros importantes como associações, dependendo do que
você pretende enfatizar no diagrama. (Você pode mostrar membros menos importantes membros
como normais ou ocultá-las totalmente.)
Observação
Class Designer oferece suporte somente associações unidirecionais.
Para definir um linha de associação no diagrama de classe

1. Na caixa de ferramentas, selecione o Association item.
2. Desenhar uma linha entre as duas formas você deseja vincular com uma associação.
Uma nova propriedade é criada na primeira classe. Essa propriedade exibe como um linha
de associação (não como uma propriedade em um compartimento na forma) com um nome
padrão. Seu tipo é a forma para o qual a linha de associação aponta.
Para alterar o nome de uma associação
• Na superfície do diagrama, clique no rótulo do linha de associação e editá-lo.
- ou -
1. Clique na forma que contém a propriedade que é mostrada como uma associação.
A forma obtém foco e seus membros exibir na janela Detalhes classe e na janela
Propriedades.
2. Na janela Detalhes classe ou a janela Propriedades, edite o campo Nome para essa
propriedade e pressione ENTER.
O nome será atualizado na janela Class Details, na linha de associação, na janela
Propriedades, e no código.
COMO: Excluir formas de tipos e código associado de

diagramas classe
Você pode excluir uma forma e seu código associado usando o Class Designer. Este
procedimento descreve como excluir ambos simultaneamente.
Para excluir uma forma Tipo e seu código subjacente

1. Clique com o botão direito do mouse na forma na superfície do design.
2. Selecione Delete from Code a partir do menu de contexto.
A forma é removida do diagrama e seu código subjacente é excluído do projeto, incluindo
qualquer comentário e atributos ao redor do tipo e quaisquer dados unmodeled dentro do
tipo, como comentários regulares, espaço em branco, e corpos método.

COMO: Aplicar atributos personalizados a tipos ou membros
de tipo
Você pode aplicar um atributo personalizado para um tipo ou a um membro de um tipo. Para obter
mais informações sobre atributos, consulte Atributos (guia de programação C#), Atributos
referência alfabética. ou Atributos no Visual Basic
Para aplicar um atributo personalizado a um tipo

1. Clique em um diagrama de classe o tipo na forma.
2. Na janela Propriedades, próximo à propriedade Custom Attributes para o tipo, clique no
botão de reticências (…). A Attribute Editor caixa de diálogo é exibida.
3. No Editor atributo, digite um ou mais atributos personalizados. Separar atributos em novas
linhas, mas não fazer coloque-os entre colchetes. Quando você tiver terminado, clique em
OK.
Você inseriu os atributos personalizados são aplicados ao tipo.
Para aplicar um atributo personalizado a um membro tipo
1. Clique no nome do membro na forma seu do tipo em um diagrama de classe, ou sua linha
na janela Detalhes classe.
2. Na janela Propriedades, localize a Custom Attributes propriedade para o membro.
3. Digite um ou mais atributos personalizados (um por linha), e pressione ENTER.
Você inseriu os atributos personalizados são aplicados ao tipo.
COMO: Exibir Herança entre Tipos

Em Class Designer, você pode exibir o relacionamento de herança, se existir, entre um tipo base e
seus tipos derivados no diagrama de classe. Uma relação de herança pode existir entre duas
classes, entre duas interfaces, ou entre uma classe e uma interface.
Observação
Você pode definir uma relação de herança se não existe nenhum. Para obter mais informações,
consulte COMO: Definir herança entre tipos.
Para exibir o tipo base

1. Sobre o diagrama de classe, selecione o tipo para que você deseja exibir a classe base ou
interface.
2. No menu Class Diagram, escolha Show Base Class ou Show Base Interfaces como
apropriado.
O tipo na classe base ou interface aparecerá selecionado no diagrama. Todas as linhas
ocultas de herança agora aparecem entre as duas formas.
Clique com o botão direito do mouse também o tipo cujo tipo base você deseja exibir, e escolha
Show Base Class ou Show Base Interfaces como apropriado.
Para exibir os tipos derivados

1. Sobre o diagrama de classe, selecione o tipo para o qual você deseja exibir a classes
derivadas e interfaces.

2. No menu Class Diagram, escolha Show Derived Classes ou Show Derived Interfaces
como apropriado.
O tipo é derivado classes ou interfaces aparecem no diagrama. Todas as linhas ocultas de
herança agora aparecem entre as formas.
Clique com o botão direito do também mouse o tipo para que você deseja ver seus tipos
derivados, e escolher Show Derived Classes ou Show Derived Interfaces conforme apropriado.
COMO: Exibir tipos derivados

Diagramas de classe podem exibir relacionamentos entre tipos, incluindo as relações de herança.
Uma relação de herança pode existir entre duas classes, entre duas interfaces, ou entre uma
classe e uma interface.
Observação
Nome Tipo Base um tipo é sempre será exibido dentro do cabeçalho forma. No caso de várias
interfaces, onde a lista pode obter longa, a lista pode estar recolhida para economizar espaço.
Este procedimento supõe que exista uma relação de herança entre o tipo e sua classe base ou
interface. Se nenhuma relação de herança existir, você pode criar um seguindo as etapas no
COMO: Definir herança entre tipos.
Observação
Para exibir um tipo derivado, uma relação de herança deve existir entre dois tipos. Para definir
uma relação de herança, consulte COMO: Definir herança entre tipos.
Para exibir os tipos derivados o tipo selecionado

1. Sobre o diagrama de classe, selecione o tipo para que você deseja exibir seus tipos
derivados.
2. No menu Class Diagram, Show Derived Classes ou Show Derived Interfaces conforme
apropriado.
As formas que representam a classes derivadas ou interfaces apareça selecionadas no
diagrama. Todas as linhas ocultas de herança aparecerão no diagrama.
Você pode também clique com o botão direito do mouse o tipo e escolha Show Derived Classes
ou Show Derived Interfaces como apropriado.
COMO: Remover formas de tipos de diagramas de classe

Em Class Designer, você pode remover uma forma Tipo do diagrama de classe sem afetar o tipo
o código subjacente.
Observação
Removendo formas Tipo de um diagrama de classe afeta apenas esse diagrama e não outros

diagramas no seu projeto.
Para remover uma forma de um diagrama de classe

1. Na diagrama de classe, selecione a forma tipo que deseja remover do diagrama.
2. No menu Edit, escolha Remove from Diagram.
A forma Tipo e nenhuma linha de associação ou herança conectado a forma mais aparecem
no diagrama.
Você pode também selecione a forma e pressionar a tecla DELETE ou clique com o botão direito
do mouse na forma e escolha Remove from Diagram.
COMO: Exibir compartimentos em formas de tipo

No Class Designer, você pode exibir os membros de tipos sobre o diagrama de classe.
Compartimentos dentro da forma tipo exibir os membros do tipo. Para obter mais informações
sobre como exibir e criar tipos, consulte COMO: Exibir tipos existentes.
Observação
Na diagrama de classe, formas tipo aparecem recolhidas por padrão para simplificar o modo de
exibição do diagrama. Você pode expandir a forma Tipo para exibir seu conteúdo. No entanto,
compartimentos sem membros não aparecem na forma tipo.
Nomes compartimento descrever a natureza dos membros tipo e o idioma do projeto e a ordem de
grupo selecionado para exibir esses participantes dependem. Por exemplo, se você agrupar por
tipo, membros tipo compartment nomes, como Fields, Properties, Methods. e Events pode
aparecer na forma Se você agrupar membros alfabeticamente, somente um compartimento
chamado Members aparecerá. Compartment nomes, como Public, Protected se você agrupar
membros por modificador de acesso,,. ou Private pode aparecer Para obter mais informações,
consulte COMO: Agrupar membros de tipo.
Para expandir ou recolher uma forma tipo

1. A partir do projeto no Solution Explorer, abra o arquivo diagrama de classe (.CD).
2. Sobre o diagrama de classe, selecione a forma tipo.
3. No menu Class Diagram, escolha Expand ou Collapse.
A forma Tipo para exibir seu compartimentos expande ou recolhe para ocultar seu
compartimentos.
Você também pode expandir ou recolher a forma, clicando no botão cumulativo ou rolldown, que
aparece como uma divisa, sobre a forma tipo ou clicando com o botão direito do mouse na forma
Tipo e escolhendo Expand ou Collapse no menu de atalho.
Quando a forma tipo estiver expandida, formas tipo mostram seus compartimentos por padrão. No
entanto, você pode ocultar compartimentos individuais e membros dentro da forma tipo para
enfatizar determinados aspectos do tipo no diagrama. Ocultando ou mostrando compartimentos e
seus membros não afeta o código.
Para ocultar um compartimento

1. No diagrama de classe, expanda a forma tipo se necessário.

2. Na forma tipo, clique no nome compartimento.
3. No menu Class Diagram, escolha Hide Compartment.
O compartimento está oculto dentro da forma tipo expandida.
Também pode clique com o botão direito do mouse no nome compartimento e escolha Hide
Compartment a partir do menu de atalho. Você também pode selecionar as caixas de seleção na
coluna Hide da janela classe detalhes para todos os membros no compartimento para ocultar o
compartimento Para obter mais informações, consulte COMO: Abrir a janela Class Details.
Para mostrar um compartimento

1. Abrir ou exibir a janela Detalhes classe se ele estiver fechado.
2. Na janela Class Details, desmarque a caixa de seleção na coluna Hide para o
compartimento você deseja mostrar.
O compartimento e seus membros aparecem na forma tipo no diagrama de classe.
COMO: Exibir detalhes do tipo:

Você pode exibir os detalhes para tipos mostrados em um diagrama de classe utilizando a janela
Class Details. O controle árvore e Grade janela Detalhes classe torna possível para que você
possa exibir detalhes para todos os tipos, bem como editá-los para tipos de leitura / gravação.
Dica
Verifique se a janela Detalhes classe está aberta. Para obter mais informações, consulte COMO:
Abrir a janela Class Details.
Observação
A janela Detalhes classe, diagrama de classe, e janela Propriedades todos exibir informações
sobre o elemento que tem foco. Você pode usar todas as janelas três simultaneamente para exibir
informações sobre o elemento. Para mais informações, consulte Janela Properties.
Para exibir detalhes para um tipo

1. No projeto no Solution Explorer, abra o diagrama de classe para o tipo.
2. Sobre o diagrama de classe, selecione o tipo.
Se a Class Details janela estiver aberta, ele exibirá os detalhes para os membros do
mesmo tipo. Para ver nome cada membro ’, tipo, modificador, e os comentários que tiver
sido inseridos para ele. Se a forma é somente para leitura, você não pode editar qualquer
um desses campos. Em qualquer forma, você pode ocultar ou mostrar o membro ao marcar
ou desmarcar a caixa de seleção na coluna Hide.
Para exibir detalhes de um tipo diferente, clique em desse tipo. Quando o foco alterna para outro
tipo, seus detalhes são mostrados na janela Class Details.

COMO: Alternar entre notação de membro e notação de
associação
Em Class Designer, você pode alterar da maneira a diagrama de classe representa um
relacionamento de associação entre dois tipos da notação membro em notação de associação e
vice-versa. Membros exibidos como linhas de associação geralmente fornecem uma visualização
de como tipos estão relacionados útil.
Observação
Relações associação podem ser representadas como um propriedade de membro ou campo.

Para alterar notação membro para notação de associação, um tipo deve ter um membro de outro
tipo. Para alterar notação de associação para notação membro, os dois tipos devem estar
conectados por um linha de associação. Para obter mais informações, consulte COMO: Definir
associações entre tipos.Se o projeto contém vários diagramas de classe, as alterações que você
faz para a forma como um diagrama exibe relações de associação afetarão somente esse
diagrama. Para alterar a maneira como um outro diagrama exibe relações de associação, abra ou
exibir esse diagrama e execute estas etapas.
Para alterar notação membro para notação de associação

1. Do nó de projeto em Solution Explorer, abra o arquivo diagrama de classe (.CD).
2. Na forma tipo no diagrama de classe, clique com o botão direito do mouse no propriedade
de membro ou campo representando a associação, e escolha Show as Association.
Dica
Se nenhum propriedades ou campos estiverem visíveis na forma tipo, os compartimentos na

forma podem estar recolhidos. Para expandir a forma tipo, clique duas vezes no nome
compartimento ou clique com o botão direito do mouse na forma tipo, e escolha Expand.
3. O membro desaparece do compartimento na forma tipo e um linha de associação aparece

para conectar os dois tipos. A linha de associação é rotulada com o nome do campo ou
propriedade.
Para alterar notação de associação para notação membro
• Na diagrama de classe, clique com o botão direito do mouse a linha de associação, e
escolha Show as Property ou Show as Field como apropriado.
A linha de associação desaparecer, e a propriedade exibe no compartimento apropriado em
sua forma tipo no diagrama.
COMO: Exibir membros de tipo

Em Class Designer, você pode mostrar ou ocultar os membros em seus compartimentos nas
formas tipo no diagrama de classe Ocultar membros em seus compartimentos pode ajudar a
simplificar o modo do diagrama ou para enfatizar determinados aspectos dos tipos que aparecem
no diagrama.
Observação

O diagrama de classe exibe membros em compartimentos por padrão. Quando todos os membros
em um compartimento estiverem ocultas, o compartimento ficar ocultos. Ocultando ou mostrando
compartimentos e seus membros não afeta o código. Para obter mais informações, consulte
COMO: Exibir compartimentos em formas de tipo.
Para mostrar membros ocultos em uma forma tipo

• No diagrama de classe, clique com o botão direito do mouse no nome compartimento e
escolha Show All Members.
Membros ocultos aparecem no compartimento.
Você também pode mostrar um membro tipo usando a janela Detalhes classe desmarcando a
Hide caixa de seleção para o membro. Para obter mais informações, consulte COMO: Abrir a
janela Class Details.
Para ocultar um membro de uma forma tipo

• No diagrama de classe, clique com o botão direito do mouse no nome membro e escolha
Hide.
Deixa o membro é visível no compartimento.
Você também pode ocultar um membro usando a Class Details janela, marcando a Hide caixa de
seleção para o membro. Para obter mais informações, consulte COMO: Abrir a janela Class
Details.
COMO: Adicionar diagramas de classes a projetos

Você pode começar criando, editando, e classes refactoring e outros tipos em um projeto do
Visual Studio usando Class Designer adicionando um diagrama de classe para o projeto. Você
pode adicionar a seu projeto, Diagramas de classe em branco ou você pode criar diagramas de
tipos existentes no seu projeto. Cada projeto pode conter vários diagramas de classe, útil para
visualizar código diferentes áreas de projeto.
Para adicionar um diagrama de classe a um projeto

1. No Solution Explorer, clique com o botão direito do mouse no nome do projeto e execute
uma das opções a seguir:
o Clique em Add New Item.
o Aponte para Add, e clique em New Item.
2. No painel Modelos da caixa Add New Item de diálogo, execute uma das opções a seguir:
o Para criar um diagrama de classe com o nome padrão, clique duas vezes Class
Diagram.
o Para criar um diagrama de classe com outro nome, clique em Class Diagram,
alterar o nome na caixa Name, e clique em Add.
O diagrama de classe é aberta no Class Designer e aparece como um arquivo com uma
extensão.CD no Solution Explorer dentro da hierarquia do projeto. Caixa de ferramentas
Class Designer aparece e contém formas e linhas você pode arrastar para o diagrama.
3. Para adicionar vários diagramas de classe, repita as etapas no procedimento.
Observação que você também pode criar um diagrama de classe para sua solução,
clicando no Class Diagram botão no Solution Explorer, ou escolhendo View Class

Diagram dos menus de contexto de Class e Project Nós de Solution Explorer e
Namespace. e Type Nós de Class View
COMO: Exibir tipos existentes

Em Class Designer, para exibir a estrutura de um tipo existente em um projeto do Visual Studio,
exibindo sua forma correspondente em um diagrama de classe. A forma contém compartimentos
que exibir os membros pertencentes ao tipo.
Você pode exibir tipos local e referência. Um tipo local existe em um projeto aberto no momento e
é leitura / gravação. Um tipo de referência existe em outro projeto ou em um conjunto de
referência e é somente leitura.
Para criar novos tipos em diagramas de classe, consulte COMO: Criar Tipos em Diagramas de
Classe.
Para exibir tipos em um projeto em um diagrama de classe

1. Do nó de projeto em Solution Explorer, abrir um arquivo diagrama de classe (.CD).
Dica
Se nenhum diagrama de classe existir, adicionar um diagrama de classe ao projeto. Para obter
mais informações, consulte COMO: Adicionar diagramas de classes a projetos.
2. No nó de projeto em Solution Explorer, arraste um arquivo código fonte para o diagrama de

classe.
Formas que representam os tipos definidos no arquivo de código de origem aparecem no
diagrama na posição onde você arrastado o arquivo.
Também pode exibir tipos no projeto, arrastando um ou mais tipos do nó de projeto em Class View
para o diagrama de classe.
Dica
Se não estiver aberto, Exibir Classe Abrir exibir classe no menu View. Para obter mais
informações sobre modo classe, consulte Exibir classes e seus membros.
Para exibir tipos nos locais padrão no diagrama, selecione um ou mais tipos no modo de classe,
clique com o botão direito do mouse os tipos selecionados, e escolha View Class Diagram.
Observação
Se um diagrama de classe fechado contendo o tipo já existe no projeto, o diagrama de classe

abrirá para exibir a forma tipo. No entanto, se nenhum diagrama de classe contendo o tipo existir
no projeto, Class Designer cria um novo diagrama de classe no projeto e abre o arquivo para
exibir o tipo.

Quando você primeiro exibir um tipo no diagrama, sua forma aparece recolhida por padrão. Você
pode expandir a forma para ver o respectivo conteúdo. Para obter mais informações, consulte
COMO: Exibir compartimentos em formas de tipo.
Para exibir um projeto ou espaço para nome em um diagrama de classe

• No Solution Explorer (para projetos) ou exibição classe (para espaços para nome) clique
com o botão direito do mouse no projeto ou espaço para nome e escolha Exibir no diagrama.
Um diagrama classe populated auto-é criado.
Ententendo um código que você não escreveu

Você pode usar o Class Designer como uma ferramenta para ajudá-lo a entender classes e tipos
escritos por outras pessoas. A ferramenta exibe uma representação gráfica do código. Você pode
personalizar esta exibição para atender às suas preferências; por exemplo, você pode mostrar
mais detalhes ou menos, grupo e filtrar membros de tipos, explicitamente ocultar membros, e
exibir linhas que indicam relacionamentos, como a herança.
Também pode optar por visualizar o mesmo projeto de maneiras diferentes. Para fazer isso, crie
vários diagramas de classe no projeto e então personalizar cada uma para enfocar detalhes
diferentes. Para obter mais informações, consulte COMO: Adicionar diagramas de classes a
projetos.
COMO: Agrupar membros de tipo

Em Class Designer, você pode agrupar membros tipo em seus compartimentos no diagrama de
classe por seu modificador de acesso, tipo, como Public ou Private. ou alfabeticamente
Para membros de grupo de um tipo

1. No projeto no Solution Explorer, abra o diagrama de classe para o tipo.
2. No menu Class Diagram, escolha a ordem de grupo que você deseja.
Todas as formas no diagrama atual Atualizar seus compartimentos para refletir a ordem
selecionada.
Você também pode definir a ordem de grupo clicando com o botão direito do mouse um local em
branco no diagrama e selecionando uma ordem de grupo a partir do menu de atalho, definindo a
Group By propriedade para o diagrama na janela Propriedades, ou na barra de ferramentas Class
Designer.
COMO: Adicionar comentários a diagramas de classe

Você pode usar formas de comentário para anotar diagramas de classe. Um forma de comentário
possui uma propriedade, Text,. no qual você pode digitar texto Formas comentário existem
apenas na superfície do diagrama e não no código.
Um comentário reside em modo de exibição diagrama de classe em Class Designer; Se você

abrir uma segunda diagrama de classe até o mesmo projeto, comentários você criou no primeiro
modo são não visíveis. Se você excluir um diagrama, todos os comentários continha também
serão excluídos.
Você pode redimensionar um forma de comentário mas não pode alterar outros aspectos da sua
aparência, como seu tamanho cor, fonte, ou fonte de plano de fundo.

Para adicionar um comentário
1. Arraste um comentário de até o diagrama de classe. o Class Designer Toolbox
2. Clique no novo forma de comentário no diagrama e digite o texto desejado.
Personalizando diagramas de classe

Você pode alterar a maneira que diagramas de classe exiba informações sobre o projeto. Por
exemplo, você pode alterar tamanho aparente todo o diagrama é clicando na barra de ferramentas
Class Designer. e Zoom Out botões (ou por clicando uma quantidade Zoom na caixa de listagem)
a Zoom In Definir o zoom não afeta como um diagrama de classe impresso.
Observação
Não é possível alterar a terminologia exibida para tipos do o projeto é na superfície do diagrama.
Terminologia é dependente sobre a linguagem do projeto.
Os métodos disponíveis para alterar diagramas são resumidos na lista a seguir:
• Roteamento de linha manual. Primeiro, clique em um linha de associação para selecioná-

lo. Em seguida, você pode mover a linha, ou segmentos de linha, esquerda, direita, para cima,
ou para baixo. Pontos de extremidade da linha é permanecem ancorados nas formas se
conecta.
• Posicionamento rótulo de linha associação. Primeiro, clique no rótulo de um linha de
associação para selecioná-lo. Em seguida, você pode arrastar o rótulo para outra posição no
diagrama.
• Ocultar linha de associação. Com o botão direito do mouse uma linha de associação exibe
um menu de contexto. Em seguida, se você clicar em Show as Property, a linha é removida
do diagrama, mas a associação aparecerá como uma propriedade em uma forma. Consulte
COMO: Alternar entre notação de membro e notação de associação.
• Mostrar e ocultar formas. Para ocultar forma é um tipo, clique com o botão direito do
mouse em sua área de cabeçalho e clique em Remove from Diagram. Para mostrá-la
novamente, arraste-a para o diagrama de Class View.
• Mostrar e ocultar membros tipo. Usando o Class Designer ou janela Detalhes classe, você
pode mostrar membros é um tipo ou ocultá-las Para obter mais informações, consulte COMO:
Exibir membros de tipo.
• Expandir e recolher formas. Para recolher uma forma, clique com botão direito mouse sua
área de cabeçalho e clique em Collapse. Isso oculta todos os compartimentos a forma. Para
expandir a forma, clique com o botão direito do mouse e clique em Expand.
• Expandir e recolher compartimentos forma. Para recolher um compartimento em uma
forma, clique com o botão direito do mouse no rótulo compartimento e clique em Collapse.
Para exibir o compartimento, clique na forma (para que ele foco) e desmarque caixas o
compartimento ’ Hide na janela Detalhes classe.
• Agrupar e classificar membros. Você pode agrupar membros é um tipo de várias maneiras.
Para obter mais informações, consulte COMO: Agrupar membros de tipo.

COMO: Copiar elementos de diagrama de classe para um
documento do Microsoft Office
Você pode copiar um, vários ou todos as formas de um diagrama de classe em outros
documentos. Se a operação de cópia duplica a imagem visual da forma ou seu código subjacente
de depende do tipo de documento no qual colá-lo.
Para copiar um único elemento

• Clique com botão direito mouse a forma e escolha Copy as Image.
A forma é colocada na Área de transferência.
Para copiar vários elementos
1. Na superfície do diagrama, arraste o ponteiro para selecionar as formas que você deseja
copiar.
2. Clique com botão direito mouse uma das formas selecionadas e escolha Copy as Image.
Todas as formas selecionadas são colocadas na Área de transferência.
Para copiar todos os elementos em um diagrama de classe
1. Clique com o botão direito do mouse a superfície de diagrama e escolha Select All.
2. Clique no Copy ícone na barra de ferramentas Padrão, ou selecione Copy as image no
menu Editar.
Formas do todo o diagrama é são colocadas na Área de transferência.
Depois você copiados sua seleção, colá-lo usando o Paste Comando no programa de destino.
Programas orientado Text-exibir o código por trás do forma selecionada ou formas, enquanto
programas orientado a elementos gráficos-exibir a imagem da forma ou formas que você copiou.
Observação
Você também pode escolher Copy em vez de Copy as Image. Copia Copy a imagem como um
bitmap regular, e Copy as Image copia a imagem como uma imagem vetorial, que é melhor para
a maioria dos aplicativos do Office.
COMO: Imprimir diagramas de classe

Você pode imprimir um diagrama de classe usando o recurso de impressão do Visual Studio.
Para imprimir um diagrama de classe

1. Exibir o diagrama de classe. (Se necessário, selecione a guia diagrama de classe para
exibi-la.)
2. Clique Impressão no menu Arquivo.
O diagrama de classe inteira será impressa. Observe que você pode precisa ajustar as
configurações na caixa de diálogo Instalação página a fim de imprimir em um tamanho
adequado.

COMO: Ignorar membros de tipo
Em Class Designer, você pode permitir membros como métodos e propriedades em uma classe
filho para substituir membros herdados de uma classe base. Substituir um membro é possível
somente se aplica a seguinte circunstância:
• O método base seja substituído deve ser virtual, abstract, ou substituir. (Ele não pode ser
não-virtual ou estático.)
Para substituir um membro
1. No diagrama de classe, clique com o botão direito do mouse em uma forma de classe, e
escolha Intellisense DEPOIS Override Members.
Será exibida uma caixa de diálogo Exibir membros substituível.
2. Na lista, escolha um membro.
Um membro com o mesmo nome, modificador de acesso, valor de retorno, e assinatura
aparecerá como selecionado na classe, e sua Override propriedade é definida como True.
COMO: Renomear tipos e membros de tipo

Em Class Designer, você pode renomear um tipo ou um membro de um tipo no diagrama de
classe ou na janela Propriedades do. Na janela Detalhes classe, você pode editar o nome do
membro mas não um tipo. Renomear um tipo ou membro tipo propaga para todas as janelas e
locais de código onde o nome antigo apareceu.
Para renomear um nome no Class Designer

1. No diagrama de classe, selecione o tipo ou membro.
O nome do membro se tornará editável.
2. Digite o novo nome para o tipo ou membro tipo
Para renomear um nome na janela Detalhes classe
1. Para exibir a janela Detalhes classe, clique com o botão direito do mouse no tipo ou
membro Tipo e escolha Class Details.
A janela Detalhes classe aparece.
2. Na coluna Name, edite o nome do membro do tipo
3. Para mover o foco fora da célula, pressione a tecla Enter ou clique na célula fora do.
Observação
Na janela Detalhes classe, você pode editar o nome do membro mas não um tipo.
Para renomear um nome na janela Propriedades

1. No diagrama de classe ou na janela Detalhes classe, clique com o botão direito do mouse
no tipo ou membro e escolha Properties.
A janela Propriedades aparece e exibe propriedades para o tipo ou membro tipo.
2. Na propriedade Name, alterar o nome do tipo ou membro tipo.
O novo nome propaga para todas as janelas e locais de código no projeto atual onde o
nome antigo apareceu.

COMO: Mover um membro de tipo de um tipo para outro
Usando Class Designer, pode mover um membro Tipo de um tipo para outro tipo, se ambas
estiverem visíveis no diagrama de classe atual.
Para mover um membro Tipo de um tipo para outro

1. Em um tipo que esteja visível na superfície de design, clique com o botão direito do mouse
no membro você deseja mova para outro tipo, e clique Cut.
2. Clique com o botão direito do mouse no tipo de destino e clique em Paste.
A propriedade será removido do tipo de fonte e aparece em Tipo de destino.
COMO: Implementar uma interface

Em Class Designer, você pode implementar uma interface no diagrama de classe conectando-lo a
uma classe que fornece código para os métodos de interface. Class Designer gera um
implementação de interface e exibe a relação entre a interface e a classe como uma relação de
herança. Você pode implementar uma interface desenhando uma Linha de Herança entre a
interface e a classe ou arrastando a interface da exibição classe.
Dica
Você pode criar interfaces da mesma maneira que criar outros tipos. Se a interface existe mas não
é exibido no diagrama de classe, em seguida, primeiro exiba-o. Para obter mais informações,
consulte COMO: Criar Tipos em Diagramas de Classe e COMO: Exibir tipos existentes.
Para implementar uma interface desenhando uma Linha de Herança

1. Na diagrama de classe, exibir a interface e a classe será que implementam a interface.
2. Desenhe uma linha de herança da classe e a interface.
Um pirulito aparece anexado à classe e um rótulo com o nome da interface identifica a
relação de herança. O Visual Studio gera stubs para todos os membros de interface.
Para obter mais informações, consulte COMO: Definir herança entre tipos.
Para implementar uma interface a partir da janela Exibir Classe

1. Na diagrama de classe, exibir a classe que você deseja que implementam a interface.
2. Abra Exibir Classe e localize a interface.
Dica
Se não estiver aberto, Exibir Classe Abrir exibir classe no menu View. Para obter mais
informações sobre modo classe, consulte Exibir classes e seus membros.
3. Arraste o nó interface até a forma de classe no diagrama.

Um pirulito aparece anexado à classe e um rótulo com o nome da interface identifica a
relação de herança. O Visual Studio gera stubs para todos os membros de interface; neste
momento, a interface é implementada.

COMO: Implementar uma classe abstrata
Você pode usar Class Designer para implementar uma classe abstrata.
O seguinte para este procedimento, será adotado:
• O projeto contém uma classe abstrata.

• A classe abstrata contém membros abstratos.
• A classe abstrata é a classe base em uma relação de herança com outra classe. (A classe
derivada não precisa ser uma classe abstrata.)
Implementar uma classe abstrato
• Clique com o botão direito a classe derivada em seguida, escolha Intellisense, escolha
Implement Abstract Class. Todos os membros da classe base abstratos são implementados
na classe derivada.
COMO: Extrair para interface (C# somente)

Você pode extrair um ou mais membros públicos de um tipo em uma nova interface.
Para extrair membros para uma nova interface

1. Na Class Designer, clique com o botão direito do mouse o tipo que contém o membro ou
membros você deseja extrair, aponte para Refactor, e clique em Extract Interface.
A caixa de diálogo extrair interface exibe valores padrão para o nome da interface e o nome
do arquivo de código no qual ela vai ser declarada. Aceite os valores padrão ou alterá-las.
2. No painel Select public members to form interface, marque ou desmarque a caixa de
seleção ao lado os membros que você deseja extrair para a nova interface, e clique em OK.
Uma nova interface é criado, e o arquivo que abriga ele é adicionado ao projeto.
COMO: Reordenar parâmetros (C# somente)

Na Class Designer, você pode alterar a ordem dos parâmetros de método em tipos
Para alterar a ordem dos parâmetros

1. No diagrama de classe, expanda a forma tipo e o Methods compartimento.
2. No Methods compartimento, clique com o botão direito do mouse com os parâmetros você
deseja, aponte para Refactor, e escolha Reorder Parameters o método.
A Reorder Parameters caixa de diálogo será exibida.
3. Na caixa Reorder Parameters de diálogo, mova os parâmetros para a ordem você deseja,
e clique em OK.
As alterações ordem de parâmetro no código e na forma no diagrama de classe.
COMO: Criar um membro

Você pode criar um membro usando qualquer uma das seguintes ferramentas:
• Projeto de Classes
• Classe ferramentas Janela detalhes

• Classe janela Detalhes
Observação
Você também pode criar Construtores e destructors usando os procedimentos nesta seção.
Lembre-se que Construtores e destructors são tipos especiais de métodos, e como tal, são
exibidos no Methods compartimento na formas diagrama de classe e na seção Methods de
detalhes classe grade da janela.
Observação
A única entidade você pode adicionar a um delegado é parâmetro. Observe que o procedimento
chamado ' para criar um membro usando a barra de ferramentas Janela detalhes classe ' não é
válido para esta ação.
Para criar um membro usando Class Designer

1. Clique com o botão direito do mouse o tipo ao qual você deseja adicionar um membro,
aponte para Add, e clique em Add <member>.
A nova assinatura membro é criado e adicionado ao tipo. É fornecido um nome padrão que
você pode alterar, na Class Designer janela Detalhes classe, ou na janela Propriedades.
2. Como opção, especificar outros detalhes sobre o membro, tais como seu tipo.
Para criar um membro usando a barra de ferramentas Janela detalhes classe
1. Na superfície do diagrama, selecione o tipo ao qual você deseja adicionar um membro.
O tipo obtém foco e seu conteúdo são exibidos na janela Detalhes classe.
2. Na barra de ferramentas Janela detalhes classe, clique no ícone superior e selecione New
<member> na lista drop-o.
O cursor vai para o Name campo em uma linha para o tipo de membro que você deseja
adicionar. Por exemplo, se você clicou em New Property, em uma nova linha na seção
Properties da janela Detalhes classe moverá o cursor.
3. Digite o nome do membro você deseja criar e pressione ENTER (ou caso contrário mover
o foco, como pressionando TAB).
A nova assinatura membro é criado e adicionado ao tipo. O membro agora existe no código
e é exibido no Class Designer, a janela Detalhes classe, e a janela Propriedades.
Para criar um membro usando a classe detalhes janela
1. Na superfície do diagrama, selecione o tipo ao qual você deseja adicionar um membro.
O tipo obtém foco e seu conteúdo são exibidos na janela Detalhes classe.
2. Na janela Detalhes classe, na seção que contém o tipo de membro você deseja adicionar,
clique em <add member>. Por exemplo, se você deseja adicionar um campo, clique em
<add field>.
3. Digite o nome do membro você deseja criar e pressione ENTER.
A nova assinatura membro é criado e adicionado ao tipo. O membro agora existe no código
e é exibido na janela Detalhes classe, a Class Designer, o e a janela Propriedades.
Você Note: pode usar atalhos de teclado para criar membros. Para obter mais informações,
consulte Atalhos de teclado para a janela Detalhes de classe.

COMO: Implementar um designer para um controle
Este tópico descreve como implementar um designer (HelpLabelDesigner. o COMO: Implementar
um provedor Extender HelpLabel) para o HelpLabel controle provedor Extender descrito em O
designer é uma classe aninhada no controle HelpLabel. O exemplo de código Designer demonstra
os seguintes pontos:
• Derivar HelpLabelDesigner de ControlDesigner.

• Fornece HelpLabelDesigner um verbo Designer, substituindo a Verbs propriedade
especificada na interface IDesigner. No tempo de criação, verbos aparecem como comandos
no objeto que está associado com o designer. Para obter mais informações, consulte Verbos
Designer.
• Adiciona HelpLabelDesigner uma propriedade design-time (TrackSelection. por substituir o
PreFilterProperties método especificado pela interface IDesignerFilter) para HelpLabel Para
obter mais informações sobre como adicionar ou substituir propriedades e eventos, consulte
Filtragem de metadados.
Exemplo
O exemplo de código a seguir contém o código para o designer.
Observação
O seguinte código Designer por si só não será compilado. Em vez disso, compilar o exemplo no
COMO: Implementar um provedor Extender HelpLabel, que contém o código para o criador como
uma classe aninhada.
C#
// // <doc> // <desc> // This is a designer for the HelpLabel. This designer provides // design time feedback
for the label. The help label responds // to changes in the active control, but these events do not // occur at
design time. In order to provide some usable feedback // that the control is working the right way, this
designer listens // to selection change events and uses those events to trigger active // control changes. //
</desc> // </doc> //
[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name =
"FullTrust")] public class HelpLabelDesigner : System.Windows.Forms.Design.ControlDesigner { private
bool trackSelection = true; /// <summary> /// This property is added to the control's set of properties in the
method /// PreFilterProperties below. Note that on designers, properties that are /// explictly declared by
TypeDescriptor.CreateProperty can be declared as /// private on the designer. This helps to keep the
designer's publi /// object model clean. /// </summary> private bool TrackSelection { get { return
trackSelection; } set { trackSelection = value; if (trackSelection) { ISelectionService ss =
(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { UpdateHelpLabelSelection(ss); } }
else { HelpLabel helpLabel = (HelpLabel)Control; if (helpLabel.activeControl != null) {
helpLabel.activeControl = null; helpLabel.Invalidate(); } } } } public override DesignerVerbCollection Verbs {
get { DesignerVerb[] verbs = new DesignerVerb[] { new DesignerVerb("Sample Verb", new
EventHandler(OnSampleVerb)) }; return new DesignerVerbCollection(verbs); } } // // <doc> // <desc> //
Overrides Dispose. Here we remove our handler for the selection changed // event. With designers, it is
critical that they clean up any events they // have attached. Otherwise, during the course of an editing
session many // designers may get created and never destroyed. // </desc> // </doc> // protected override
void Dispose(bool disposing) { if (disposing) { ISelectionService ss =

(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { ss.SelectionChanged -= new
EventHandler(OnSelectionChanged); } } base.Dispose(disposing); } // // <doc> // <desc> // Overrides
initialize. Here we add an event handler to the selection service. // Notice that we are very careful not to
assume that the selection service is // available. It is entirely optional that a service is available and you
should // always degrade gracefully if a service could not be found. // </desc> // </doc> // public override
void Initialize(IComponent component) { base.Initialize(component); ISelectionService ss =
(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { ss.SelectionChanged += new
EventHandler(OnSelectionChanged); } } private void OnSampleVerb(object sender, EventArgs e) {
MessageBox.Show("You have just invoked a sample verb. Normally, this would do something interesting."); }
// // <doc> // <desc> // Our handler for the selection change event. Here we update the active control
within // the help label. // </desc> // </doc> // private void OnSelectionChanged(object sender, EventArgs
e) { if (trackSelection) { ISelectionService ss = (ISelectionService)sender; UpdateHelpLabelSelection(ss); } }
protected override void PreFilterProperties(IDictionary properties) { // Always call base first in PreFilter*
methods, and last in PostFilter* // methods. base.PreFilterProperties(properties); // We add a design-time
property called "TrackSelection" that is used to track // the active selection. If the user sets this to true (the
default), then // we will listen to selection change events and update the control's active // control to point to
the current primary selection. properties["TrackSelection"] = TypeDescriptor.CreateProperty(
this.GetType(), // the type this property is defined on "TrackSelection", // the name of the property
typeof(bool), // the type of the property new Attribute[] {CategoryAttribute.Design}); // attributes } ///
<summary> /// This is a helper method that, given a selection service, will update the active control /// of
our help label with the currently active selection. /// </summary> /// <param name="ss"></param>
private void UpdateHelpLabelSelection(ISelectionService ss) { Control c = ss.PrimarySelection as Control;
HelpLabel helpLabel = (HelpLabel)Control; if (c != null) { helpLabel.activeControl = c;
helpLabel.Invalidate(); } else { if (helpLabel.activeControl != null) { helpLabel.activeControl = null;
helpLabel.Invalidate(); } } } }
COMO: Criar e configurar componentes no modo Design

O designer personalizado pode criar e configurar componentes na superfície do design de forma
programada.
Exemplo
O exemplo de código a seguir demonstra como usar Serviços Designer para criar e iniciar os
componentes no seu designer personalizado. Uma classe chamada DemoControlDesigner Designer
está conectado a uma DemoControl classe e executa as seguintes operações:
• Cria e configura um Timer componente para exibição na superfície do design.

• Remove um Timer Componente da superfície de design.
• Inicializa uma instância da classe DemoControl quando ele é criado pelo Toolbox.
C#
using System; using System.Collections; using System.ComponentModel; using
System.ComponentModel.Design; using System.Diagnostics; using System.Drawing; using
System.Drawing.Design; using System.Data; using System.Reflection; using System.Runtime.Serialization;
using System.Text; using System.Windows.Forms; using System.Windows.Forms.Design; using
System.Windows.Forms.Design.Behavior; public class Form1 : Form { private DemoControl demoControl1;
private System.ComponentModel.IContainer components = null; public Form1() { InitializeComponent(); }

protected override void Dispose(bool disposing) { if (disposing && (components != null)) {
components.Dispose(); } base.Dispose(disposing); } [STAThread] static void Main() {
Application.EnableVisualStyles(); Application.Run(new Form1()); } #region Windows Form Designer
generated code private void InitializeComponent() { this.demoControl1 = new DemoControl();
this.SuspendLayout(); // // demoControl1 // this.demoControl1.AutoSize = true;
this.demoControl1.BackColor = System.Drawing.Color.Chartreuse; this.demoControl1.Location = new
System.Drawing.Point(0, 0); this.demoControl1.Name = "demoControl1"; this.demoControl1.Size = new
System.Drawing.Size(232, 14); this.demoControl1.TabIndex = 0; this.demoControl1.Text = "This text was set
by CreateComponentsCore."; // // Form1 // this.ClientSize = new System.Drawing.Size(492, 482);
this.Controls.Add(this.demoControl1); this.Name = "Form1"; this.Text = "r"; this.ResumeLayout(false);
this.PerformLayout(); } #endregion } // This control is derived from UserControl, with only a little // added
logic for the Toolbox interaction. // // All of the custom designer code is implemented in the //
DemoControlDesigner class. [DesignerAttribute(typeof(DemoControlDesigner))]
[ToolboxItem(typeof(DemoToolboxItem))] public class DemoControl : Label { private
System.ComponentModel.IContainer components = null; public DemoControl() { InitializeComponent();
MessageBox.Show("DemoControl", "Constructor"); } protected override void Dispose(bool disposing) { if
(disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } private void
InitializeComponent() { // // DemoControl // this.Name = "DemoControl"; } // Toolbox items must be
serializable. [Serializable]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Inheritan
ceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDem
and, Name="FullTrust")] class DemoToolboxItem : ToolboxItem { // The add components dialog in VS looks
for a public // ctor that takes a type. public DemoToolboxItem(Type toolType) : base(toolType) { } // And
you must provide this special constructor for serialization. // If you add additional data to MyToolboxItem
that you // want to serialize, you may override Deserialize and // Serialize methods to add that data.
DemoToolboxItem(SerializationInfo info, StreamingContext context) { Deserialize(info, context); } // This
implementation sets the new control's Text and // AutoSize properties. protected override IComponent[]
CreateComponentsCore( IDesignerHost host, IDictionary defaultValues) { IComponent[] comps =
base.CreateComponentsCore(host, defaultValues); // The returned IComponent array contains a single //
component, which is an instance of DemoControl. ((DemoControl)comps[0]).Text = "This text was set by
CreateComponentsCore."; ((DemoControl)comps[0]).AutoSize = true; return comps; } } } // This class
demonstrates a designer that attaches to various // services and changes the properties exposed by the
control // being designed.
"FullTrust")] public class DemoControlDesigner : ControlDesigner { // This member backs the Locked
property. private bool lockedValue = false; // This is the collection of DesignerActionLists that // defines the
smart tags offered on the control. private DesignerActionListCollection actionLists = null; // This Timer is
created when you select the Create Timer // smart tag item. private Timer createdTimer = null; // These are
the services which DemoControlDesigner will use. private DesignerActionService actionService = null;
private DesignerActionUIService actionUiService = null; private IComponentChangeService changeService =
null; private IDesignerEventService eventService = null; private IDesignerHost host = null; private
IDesignerOptionService optionService = null; private IEventBindingService eventBindingService = null;
private IExtenderListService listService = null; private IReferenceService referenceService = null; private
ISelectionService selectionService = null; private ITypeResolutionService typeResService = null; private
IComponentDiscoveryService componentDiscoveryService = null; private IToolboxService toolboxService =

null; private UndoEngine undoEng = null; public DemoControlDesigner() {
MessageBox.Show("DemoControlDesigner", "Constructor"); } // The Dispose method override is
implemented so event handlers // can be removed. This prevents objects from lingering in // memory
beyond the desired lifespan. protected override void Dispose(bool disposing) { if (disposing) { if
(this.changeService != null) { // Unhook event handlers. this.changeService.ComponentChanged -= new
ComponentChangedEventHandler( ChangeService_ComponentChanged);
this.changeService.ComponentAdded -= new ComponentEventHandler( ChangeService_ComponentAdded);
this.changeService.ComponentRemoved -= new ComponentEventHandler(
changeService_ComponentRemoved); } if (this.eventService != null) {
this.eventService.ActiveDesignerChanged -= new ActiveDesignerEventHandler(
eventService_ActiveDesignerChanged); } if (this.selectionService != null) {
this.selectionService.SelectionChanged -= new EventHandler( selectionService_SelectionChanged); } }
base.Dispose(disposing); } // This method initializes the designer. public override void
Initialize(IComponent component) { base.Initialize(component); // Connect to various designer services.
InitializeServices(); // Set up the BackColor value that will be serialized. // This is the shadowed property on
the designer. this.BackColor = Color.Chartreuse; // Set up the BackColor value that will be displayed.
this.Control.BackColor = Color.AliceBlue; } // This method creates the DesignerActionList on demand,
causing // smart tags to appear on the control being designed. public override DesignerActionListCollection
ActionLists { get { if (null == actionLists) { actionLists = new DesignerActionListCollection();
actionLists.Add( new DemoActionList(this.Component)); } return actionLists; } } // This utility method
connects the designer to various // services it will use. private void InitializeServices() { // Acquire a
reference to DesignerActionService. this.actionService = GetService(typeof(DesignerActionService)) as
DesignerActionService; // Acquire a reference to DesignerActionUIService. this.actionUiService =
GetService(typeof(DesignerActionUIService)) as DesignerActionUIService; // Acquire a reference to
IComponentChangeService. this.changeService = GetService(typeof(IComponentChangeService)) as
IComponentChangeService; // Hook the IComponentChangeService events. if (this.changeService != null) {
this.changeService.ComponentChanged += new ComponentChangedEventHandler(
ChangeService_ComponentChanged); this.changeService.ComponentAdded += new
ComponentEventHandler( ChangeService_ComponentAdded); this.changeService.ComponentRemoved +=
new ComponentEventHandler( changeService_ComponentRemoved); } // Acquire a reference to
ISelectionService. this.selectionService = GetService(typeof(ISelectionService)) as ISelectionService; // Hook
the SelectionChanged event. if (this.selectionService != null) { this.selectionService.SelectionChanged +=
new EventHandler(selectionService_SelectionChanged); } // Acquire a reference to IDesignerEventService.
this.eventService = GetService(typeof(IDesignerEventService)) as IDesignerEventService; if
(this.eventService != null) { this.eventService.ActiveDesignerChanged += new ActiveDesignerEventHandler(
eventService_ActiveDesignerChanged); } // Acquire a reference to IDesignerHost. this.host =
GetService(typeof(IDesignerHost)) as IDesignerHost; // Acquire a reference to IDesignerOptionService.
this.optionService = GetService(typeof(IDesignerOptionService)) as IDesignerOptionService; // Acquire a
reference to IEventBindingService. this.eventBindingService = GetService(typeof(IEventBindingService)) as
IEventBindingService; // Acquire a reference to IExtenderListService. this.listService =
GetService(typeof(IExtenderListService)) as IExtenderListService; // Acquire a reference to
IReferenceService. this.referenceService = GetService(typeof(IReferenceService)) as IReferenceService; //
Acquire a reference to ITypeResolutionService. this.typeResService =
GetService(typeof(ITypeResolutionService)) as ITypeResolutionService; // Acquire a reference to
IComponentDiscoveryService. this.componentDiscoveryService =
GetService(typeof(IComponentDiscoveryService)) as IComponentDiscoveryService; // Acquire a reference to

IToolboxService. this.toolboxService = GetService(typeof(IToolboxService)) as IToolboxService; // Acquire a
reference to UndoEngine. this.undoEng = GetService(typeof(UndoEngine)) as UndoEngine; if (this.undoEng
!= null) { MessageBox.Show("UndoEngine"); } } // This is the shadowed property on the designer. // This
value will be serialized instead of the // value of the control's property. public Color BackColor { get { return
(Color)ShadowProperties["BackColor"]; } set { if (this.changeService != null) { PropertyDescriptor
backColorDesc = TypeDescriptor.GetProperties(this.Control)["BackColor"];
this.changeService.OnComponentChanging( this.Control, backColorDesc);
this.ShadowProperties["BackColor"] = value; this.changeService.OnComponentChanged( this.Control,
backColorDesc, null, null); } } } // This is the property added by the designer in the // PreFilterProperties
method. private bool Locked { get { return lockedValue; } set { lockedValue = value; } } // The
PreFilterProperties method is where you can add or remove // properties from the component being
designed. // // In this implementation, the Visible property is removed, // the BackColor property is
shadowed by the designer, and // the a new property, called Locked, is added. protected override void
PreFilterProperties(IDictionary properties) { // Always call the base PreFilterProperties implementation //
before you modify the properties collection. base.PreFilterProperties(properties); // Remove the visible
property. properties.Remove("Visible"); // Shadow the BackColor property. PropertyDescriptor
propertyDesc = TypeDescriptor.CreateProperty( typeof(DemoControlDesigner),
(PropertyDescriptor)properties["BackColor"], new Attribute[0]); properties["BackColor"] = propertyDesc; //
Create the Locked property. properties["Locked"] = TypeDescriptor.CreateProperty(
typeof(DemoControlDesigner), "Locked", typeof(bool), CategoryAttribute.Design, DesignOnlyAttribute.Yes);
} // The PostFilterProperties method is where you modify existing // properties. You must only use this
method to modify existing // items. Do not add or remove items here. Also, be sure to // call
base.PostFilterProperties(properties) after your filtering // logic. // // In this implementation, the Enabled
property is hidden from // any PropertyGrid or Properties window. This is done by // creating a copy of the
existing PropertyDescriptor and // attaching two new Attributes: Browsable and EditorBrowsable. protected
override void PostFilterProperties(IDictionary properties) { PropertyDescriptor pd = properties["Enabled"]
as PropertyDescriptor; pd = TypeDescriptor.CreateProperty( pd.ComponentType, pd, new Attribute[2] { new
BrowsableAttribute(false), new EditorBrowsableAttribute(EditorBrowsableState.Never)});
properties[pd.Name] = pd; // Always call the base PostFilterProperties implementation // after you modify
the properties collection. base.PostFilterProperties(properties); } #region Event Handlers void
eventService_ActiveDesignerChanged( object sender, ActiveDesignerEventArgs e) { if (e.NewDesigner !=
null) { MessageBox.Show( e.NewDesigner.ToString(), "ActiveDesignerChanged"); } } void
ChangeService_ComponentChanged( object sender, ComponentChangedEventArgs e) { string msg =
String.Format( "{0}, {1}", e.Component, e.Member); MessageBox.Show(msg, "ComponentChanged"); } void
ChangeService_ComponentAdded( object sender, ComponentEventArgs e) { MessageBox.Show(
e.Component.ToString(), "ComponentAdded"); } void changeService_ComponentRemoved( object sender,
ComponentEventArgs e) { MessageBox.Show( e.Component.ToString(), "ComponentRemoved"); } void
selectionService_SelectionChanged( object sender, EventArgs e) { if (this.selectionService != null) { if
(this.selectionService.PrimarySelection == this.Control) { MessageBox.Show( this.Control.ToString(),
"SelectionChanged"); } } } #endregion // This class defines the smart tags that appear on the control // that
is being designed. internal class DemoActionList : System.ComponentModel.Design.DesignerActionList { //
Cache a reference to the designer host. private IDesignerHost host = null; // Cache a reference to the control.
private DemoControl relatedControl = null; // Cache a reference to the designer. private
DemoControlDesigner relatedDesigner = null; //The constructor associates the control //with the smart tag
list. public DemoActionList(IComponent component) : base(component) { this.relatedControl = component
as DemoControl; this.host = this.Component.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;

IDesigner dcd = host.GetDesigner(this.Component); this.relatedDesigner = dcd as DemoControlDesigner; }
// This method creates and populates the // DesignerActionItemCollection which is used to // display smart
tag items. public override DesignerActionItemCollection GetSortedActionItems() {
DesignerActionItemCollection items = new DesignerActionItemCollection(); // If the Timer component has
not been created, show the // "Create Timer" DesignerAction item. // // If the Timer component exists, show
the timer-related // options. if (this.relatedDesigner.createdTimer == null) { items.Add(new
DesignerActionMethodItem( this, "CreateTimer", "Create Timer", true)); } else { items.Add(new
DesignerActionMethodItem( this, "ShowEventHandlerCode", "Show Event Handler Code", true));
items.Add(new DesignerActionMethodItem( this, "RemoveTimer", "Remove Timer", true)); } items.Add(new
DesignerActionMethodItem( this, "GetExtenderProviders", "Get Extender Providers", true)); items.Add(new
DesignerActionMethodItem( this, "GetDemoControlReferences", "Get DemoControl References", true));
items.Add(new DesignerActionMethodItem( this, "GetPathOfAssembly", "Get Path of Executing Assembly",
true)); items.Add(new DesignerActionMethodItem( this, "GetComponentTypes", "Get ScrollableControl
Types", true)); items.Add(new DesignerActionMethodItem( this, "GetToolboxCategories", "Get Toolbox
Categories", true)); items.Add(new DesignerActionMethodItem( this, "SetBackColor", "Set Back Color",
true)); return items; } // This method creates a Timer component using the //
IDesignerHost.CreateComponent method. It also // creates an event handler for the Timer component's //
tick event. private void CreateTimer() { if (this.host != null) { if (this.relatedDesigner.createdTimer == null) {
// Create and configure the Timer object. this.relatedDesigner.createdTimer =
this.host.CreateComponent(typeof(Timer)) as Timer; Timer t = this.relatedDesigner.createdTimer; t.Interval
= 1000; t.Enabled = true; EventDescriptorCollection eventColl = TypeDescriptor.GetEvents(t, new
Attribute[0]); if (eventColl != null) { EventDescriptor ed = eventColl["Tick"] as EventDescriptor; if (ed !=
null) { PropertyDescriptor epd = this.relatedDesigner.eventBindingService.GetEventProperty(ed);
epd.SetValue(t, "timer_Tick"); } } this.relatedDesigner.actionUiService.Refresh(this.relatedControl); } } } //
This method uses the IEventBindingService.ShowCode // method to start the Code Editor. It places the caret
// in the timer_tick method created by the CreateTimer method. private void ShowEventHandlerCode() {
Timer t = this.relatedDesigner.createdTimer; if (t != null) { EventDescriptorCollection eventColl =
TypeDescriptor.GetEvents(t, new Attribute[0]); if (eventColl != null) { EventDescriptor ed =
eventColl["Tick"] as EventDescriptor; if (ed != null) { this.relatedDesigner.eventBindingService.ShowCode(t,
ed); } } } } // This method uses the IDesignerHost.DestroyComponent method // to remove the Timer
component from the design environment. private void RemoveTimer() { if (this.host != null) { if
(this.relatedDesigner.createdTimer != null) { this.host.DestroyComponent(
this.relatedDesigner.createdTimer); this.relatedDesigner.createdTimer = null;
this.relatedDesigner.actionUiService.Refresh( this.relatedControl); } } } // This method uses
IExtenderListService.GetExtenderProviders // to enumerate all the extender providers and display them //
in a MessageBox. private void GetExtenderProviders() { if (this.relatedDesigner.listService != null) {
StringBuilder sb = new StringBuilder(); IExtenderProvider[] providers =
this.relatedDesigner.listService.GetExtenderProviders(); for (int i = 0; i < providers.Length; i++) {
sb.Append(providers[i].ToString()); sb.Append("\r\n"); } MessageBox.Show( sb.ToString(), "Extender
Providers"); } } // This method uses the IReferenceService.GetReferences method // to enumerate all the
instances of DemoControl on the // design surface. private void GetDemoControlReferences() { if
(this.relatedDesigner.referenceService != null) { StringBuilder sb = new StringBuilder(); object[] refs =
this.relatedDesigner.referenceService.GetReferences(typeof(DemoControl)); for (int i = 0; i < refs.Length;
i++) { sb.Append(refs[i].ToString()); sb.Append("\r\n"); } MessageBox.Show( sb.ToString(), "DemoControl
References"); } } // This method uses the ITypeResolutionService.GetPathOfAssembly // method to display
the path of the executing assembly. private void GetPathOfAssembly() { if

(this.relatedDesigner.typeResService != null) { System.Reflection.AssemblyName name =
System.Reflection.Assembly.GetExecutingAssembly().GetName(); MessageBox.Show(
this.relatedDesigner.typeResService.GetPathOfAssembly(name), "Path of executing assembly"); } } // This
method uses the IComponentDiscoveryService.GetComponentTypes // method to find all the types that
derive from // ScrollableControl. private void GetComponentTypes() { if
(this.relatedDesigner.componentDiscoveryService != null) { ICollection components =
this.relatedDesigner.componentDiscoveryService.GetComponentTypes(host, typeof(ScrollableControl)); if
(components != null) { if (components.Count > 0) { StringBuilder sb = new StringBuilder(); IEnumerator e =
components.GetEnumerator(); while (e.MoveNext()) { sb.Append(e.Current.ToString()); sb.Append("\r\n");
} MessageBox.Show( sb.ToString(), "Controls derived from ScrollableControl"); } } } } // This method uses
the IToolboxService.CategoryNames // method to enumerate all the categories that appear // in the Toolbox.
private void GetToolboxCategories() { if (this.relatedDesigner.toolboxService != null) { StringBuilder sb =
new StringBuilder(); CategoryNameCollection names = this.relatedDesigner.toolboxService.CategoryNames;
foreach (string name in names) { sb.Append(name.ToString()); sb.Append("\r\n"); }
MessageBox.Show(sb.ToString(), "Toolbox Categories"); } } // This method sets the shadowed BackColor
property on the // designer. This is the value that is serialized by the // design environment. private void
SetBackColor() { ColorDialog d = new ColorDialog(); if (d.ShowDialog() == DialogResult.OK) {
this.relatedDesigner.BackColor = d.Color; } } } }
Você pode criar e configurar um componente, solicitando uma instância do ambiente de

desenvolvimento e definindo suas propriedades. Você também pode configurar um componente
quando ela é criada da Toolbox.
Criando e configurando um componente programaticamente
O exemplo de código a seguir chama o CreateComponent método para criar um Timer

componente. O Timer componente é inicializado, definindo e Enabled Propriedades. seu Interval
Este exemplo também usa o GetEventProperty método para anexar um manipulador de eventos.
C#
// This method creates a Timer component using the // IDesignerHost.CreateComponent method. It also //
creates an event handler for the Timer component's // tick event. private void CreateTimer() { if (this.host !=
null) { if (this.relatedDesigner.createdTimer == null) { // Create and configure the Timer object.
this.relatedDesigner.createdTimer = this.host.CreateComponent(typeof(Timer)) as Timer; Timer t =
this.relatedDesigner.createdTimer; t.Interval = 1000; t.Enabled = true; EventDescriptorCollection eventColl
= TypeDescriptor.GetEvents(t, new Attribute[0]); if (eventColl != null) { EventDescriptor ed =
eventColl["Tick"] as EventDescriptor; if (ed != null) { PropertyDescriptor epd =
this.relatedDesigner.eventBindingService.GetEventProperty(ed); epd.SetValue(t, "timer_Tick"); } }
this.relatedDesigner.actionUiService.Refresh(this.relatedControl); } } }
Remover um componente programaticamente
O exemplo de código a seguir chama o DestroyComponent método para remover um Timer

componente do ambiente de design.
C#
// This method uses the IDesignerHost.DestroyComponent method // to remove the Timer component from
the design environment. private void RemoveTimer() { if (this.host != null) { if

this.relatedDesigner.actionUiService.Refresh( this.relatedControl); } } }
Inicializar um componente criado por caixa de ferramentas
Você também pode configurar componentes quando eles são criados pela Toolbox. Você
implementar um personalizado ToolboxItem e substituir o CreateComponentsCore método.
C#
// Toolbox items must be serializable. [Serializable]
CreateComponentsCore."; ((DemoControl)comps[0]).AutoSize = true; return comps; } }
Anexar o componente a sua ToolboxItem Classe usando ToolboxItemAttribute.
C#
[DesignerAttribute(typeof(DemoControlDesigner))] [ToolboxItem(typeof(DemoToolboxItem))] public class
DemoControl : Label {
Quando você faz alterações aos aspectos em tempo de criação de um componente, você
precisará recriar o projeto de controle. Além disso, se não houver outro projeto Windows Forms
que é aberto e usa esse componente, você provavelmente precisará atualizar o projeto para ver
as alterações. Normalmente, você precisará fechar e reabrir a janela de design que contém o
componente.
Como: Acessar suporte em tempo de design no Windows

Forms
Componentes personalizados e controles são designable, que significa têm configurações que os
usuários podem configurar com uma interface gráfica do usuário (UI) em tempo de design. Essas
configurações geralmente afetam instâncias do componente em tempo de execução.
Se sua classe implementa a IComponent interface, ele pode participar de um ambiente de criação
como Visual Studio.

Para acessar o suporte em tempo de criação fornecido pelo .NET Framework, você precisa
concluir as etapas a seguir.
Para acessar suporte Design-time

1. Adicione uma referência ao conjunto System.Design.
2. Se você estiver implementando ou PropertyGrid controle, importar espaço para nome
System.Drawing.Design. ou se o componente está interagindo com um UITypeEditor um
Toolbox
C#
using System.Drawing.Design;
1. Se você estiver implementando uma experiência em tempo de design personalizada para o

componente, importar espaço para nome System.ComponentModel.Design.
C#
using System.ComponentModel.Design;
1. Se você estiver implementando uma experiência em tempo de design personalizada para o

controle Windows Forms, importar espaço para nome System.Windows.Forms.Design. Você
pode criar marcas inteligentes ou um designer personalizado para o componente COM tipos
no espaço para esse nome.
C#
using System.Windows.Forms.Design;
Consulte também
COMO: Implementar um provedor Extender HelpLabel

Um Provedor Extender é um componente que fornece propriedades para outros componentes.
Por exemplo, o ToolTip controle é implementado como um provedor Extender. Quando você
adiciona um ToolTip controle para a Form, todos. outros controles na Form ter uma ToolTip
propriedade adicionada à sua lista Propriedades
O exemplo a seguir demonstra como criar um provedor Extender ao criar o HelpLabel controle. Ela
mostra a implementação de método CanExtend e a HelpText propriedade. O CanExtend método é
usado pelo Windows Forms Designer para determinar se deve estender essa propriedade para
um determinado controle. O HelpLabel controle estende a HelpText propriedade para uso com os
controles em um formulário. O texto de ajuda para um controle é exibido em um painel quando o
controle tem foco.
O exemplo inclui um designer aninhada que é descrita em COMO: Implementar um designer para
um controle.
O exemplo demonstra os seguintes itens:
• O provedor HelpLabel Extender implementa IExtenderProvider.

• Do ProvidePropertyAttribute o HelpLabel controle utiliza para especificar o nome de
propriedade fornecida,, assim como o tipo de componentes que podem receber a propriedade.
• é HelpLabel próprio Um controle Windows Forms e daí derivar de Control.
• O CanExtend método retorna true para qualquer controle exceto HelpLabel, porque ele é
não significativo para estender uma propriedade no próprio.

• tem HelpLabel um método denominado GetHelpText que obtém a propriedade que HelpLabel
torna disponível para outros controles. O SetHelpText método define o valor da propriedade.
Exemplo
A HostApp classe usa o HelpLabel controle em um formulário.
C#
namespace Microsoft.Samples.WinForms.Cs.HelpLabel { using System; using System.Collections; using
System.ComponentModel; using System.ComponentModel.Design; using System.Drawing; using
System.Windows.Forms; using System.Windows.Forms.Design; // // <doc> // <desc> // Help Label offers
an extender property called // "HelpText". It monitors the active control // and displays the help text for the
active control. // </desc> // </doc> // [ ProvideProperty("HelpText",typeof(Control)),
Designer(typeof(HelpLabel.HelpLabelDesigner)) ] public class HelpLabel : Control,
System.ComponentModel.IExtenderProvider { /// <summary> /// Required designer variable. ///
</summary> private System.ComponentModel.Container components; private Hashtable helpTexts; private
System.Windows.Forms.Control activeControl; // // <doc> // <desc> // Creates a new help label object. //
</desc> // </doc> // public HelpLabel() { // // Required for Windows Form Designer support //
InitializeComponent(); helpTexts = new Hashtable(); } /// <summary> /// Clean up any resources being
used. /// </summary> protected override void Dispose(bool disposing) { if (disposing) {
components.Dispose(); } base.Dispose(disposing); } /// <summary> /// Required method for Designer
support - do not modify /// the contents of this method with the code editor. /// </summary> private void
InitializeComponent() { this.components = new System.ComponentModel.Container (); this.BackColor =
System.Drawing.SystemColors.Info; this.ForeColor = System.Drawing.SystemColors.InfoText; this.TabStop
= false; } // // <doc> // <desc> // Overrides the text property of Control. This label ignores // the text
property, so we add additional attributes here so the // property does not show up in the properties window
and is not // persisted. // </desc> // </doc> // [ Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) ] public override string Text { get {
return base.Text; } set { base.Text = value; } } // // <doc> // <desc> // This implements the
IExtenderProvider.CanExtend method. The // help label provides an extender property, and the design time
// framework will call this method once for each component to determine // if we are interested in providing
our extended properties for the // component. We return true here if the object is a control and is // not a
HelpLabel (since it would be silly to add this property to // ourselves). // </desc> // </doc> // bool
IExtenderProvider.CanExtend(object target) { if (target is Control && !(target is HelpLabel)) { return true; }
return false; } // // <doc> // <desc> // This is the extended property for the HelpText property. Extended //
properties are actual methods because they take an additional parameter // that is the object or control to
provide the property for. // </desc> // </doc> // [ DefaultValue(""), ] public string GetHelpText(Control
control) { string text = (string)helpTexts[control]; if (text == null) { text = string.Empty; } return text; } // //
<doc> // <desc> // This is an event handler that responds to the OnControlEnter // event. We attach this to
each control we are providing help // text for. // </desc> // </doc> // private void OnControlEnter(object
sender, EventArgs e) { activeControl = (Control)sender; Invalidate(); } // // <doc> // <desc> // This is an
event handler that responds to the OnControlLeave // event. We attach this to each control we are providing
help // text for. // </desc> // </doc> // private void OnControlLeave(object sender, EventArgs e) { if
(sender == activeControl) { activeControl = null; Invalidate(); } } // // <doc> // <desc> // This is the
extended property for the HelpText property. // </desc> // </doc> // public void SetHelpText(Control
control, string value) { if (value == null) { value = string.Empty; } if (value.Length == 0) {

helpTexts.Remove(control); control.Enter -= new EventHandler(OnControlEnter); control.Leave -= new
EventHandler(OnControlLeave); } else { helpTexts[control] = value; control.Enter += new
EventHandler(OnControlEnter); control.Leave += new EventHandler(OnControlLeave); } if (control ==
activeControl) { Invalidate(); } } // // <doc> // <desc> // Overrides Control.OnPaint. Here we draw our //
label. // </desc> // </doc> // protected override void OnPaint(PaintEventArgs pe) { // Let the base draw.
This will cover our back // color and set any image that the user may have // provided. // base.OnPaint(pe);
// Draw a rectangle around our control. // Rectangle rect = ClientRectangle; Pen borderPen = new
Pen(ForeColor); pe.Graphics.DrawRectangle(borderPen, rect); borderPen.Dispose(); // Finally, draw the
text over the top of the // rectangle. // if (activeControl != null) { string text =
(string)helpTexts[activeControl]; if (text != null && text.Length > 0) { rect.Inflate(-2, -2); Brush brush = new
SolidBrush(ForeColor); pe.Graphics.DrawString(text, Font, brush, rect); brush.Dispose(); } } } // <doc> //
<desc> // Returns true if the backColor should be persisted in code gen. We // override this because we
change the default back color. // </desc> // <retvalue> // true if the backColor should be persisted. //
</retvalue> // </doc> // public bool ShouldSerializeBackColor() {
return(!BackColor.Equals(SystemColors.Info)); } // <doc> // <desc> // Returns true if the foreColor should
be persisted in code gen. We // override this because we change the default foreground color. // </desc> //
<retvalue> // true if the foreColor should be persisted. // </retvalue> // </doc> // public bool
ShouldSerializeForeColor() { return(!ForeColor.Equals(SystemColors.InfoText)); } // // <doc> // <desc> //
This is a designer for the HelpLabel. This designer provides // design time feedback for the label. The help
label responds // to changes in the active control, but these events do not // occur at design time. In order to
provide some usable feedback // that the control is working the right way, this designer listens // to selection
change events and uses those events to trigger active // control changes. // </desc> // </doc> //
"FullTrust")] public class HelpLabelDesigner : System.Windows.Forms.Design.ControlDesigner { private
bool trackSelection = true; /// <summary> /// This property is added to the control's set of properties in the
method /// PreFilterProperties below. Note that on designers, properties that are /// explictly declared by
TypeDescriptor.CreateProperty can be declared as /// private on the designer. This helps to keep the
designer's publi /// object model clean. /// </summary> private bool TrackSelection { get { return
trackSelection; } set { trackSelection = value; if (trackSelection) { ISelectionService ss =
(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { UpdateHelpLabelSelection(ss); } }
else { HelpLabel helpLabel = (HelpLabel)Control; if (helpLabel.activeControl != null) {
helpLabel.activeControl = null; helpLabel.Invalidate(); } } } } public override DesignerVerbCollection Verbs {
get { DesignerVerb[] verbs = new DesignerVerb[] { new DesignerVerb("Sample Verb", new
EventHandler(OnSampleVerb)) }; return new DesignerVerbCollection(verbs); } } // // <doc> // <desc> //
Overrides Dispose. Here we remove our handler for the selection changed // event. With designers, it is
critical that they clean up any events they // have attached. Otherwise, during the course of an editing
session many // designers may get created and never destroyed. // </desc> // </doc> // protected override
void Dispose(bool disposing) { if (disposing) { ISelectionService ss =
(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { ss.SelectionChanged -= new
EventHandler(OnSelectionChanged); } } base.Dispose(disposing); } // // <doc> // <desc> // Overrides
initialize. Here we add an event handler to the selection service. // Notice that we are very careful not to
assume that the selection service is // available. It is entirely optional that a service is available and you
should // always degrade gracefully if a service could not be found. // </desc> // </doc> // public override
void Initialize(IComponent component) { base.Initialize(component); ISelectionService ss =
(ISelectionService)GetService(typeof(ISelectionService)); if (ss != null) { ss.SelectionChanged += new
EventHandler(OnSelectionChanged); } } private void OnSampleVerb(object sender, EventArgs e) {

MessageBox.Show("You have just invoked a sample verb. Normally, this would do something interesting."); }
// // <doc> // <desc> // Our handler for the selection change event. Here we update the active control
within // the help label. // </desc> // </doc> // private void OnSelectionChanged(object sender, EventArgs
e) { if (trackSelection) { ISelectionService ss = (ISelectionService)sender; UpdateHelpLabelSelection(ss); } }
protected override void PreFilterProperties(IDictionary properties) { // Always call base first in PreFilter*
methods, and last in PostFilter* // methods. base.PreFilterProperties(properties); // We add a design-time
property called "TrackSelection" that is used to track // the active selection. If the user sets this to true (the
default), then // we will listen to selection change events and update the control's active // control to point to
the current primary selection. properties["TrackSelection"] = TypeDescriptor.CreateProperty(
this.GetType(), // the type this property is defined on "TrackSelection", // the name of the property
typeof(bool), // the type of the property new Attribute[] {CategoryAttribute.Design}); // attributes } ///
<summary> /// This is a helper method that, given a selection service, will update the active control /// of
our help label with the currently active selection. /// </summary> /// <param name="ss"></param>
private void UpdateHelpLabelSelection(ISelectionService ss) { Control c = ss.PrimarySelection as Control;
HelpLabel helpLabel = (HelpLabel)Control; if (c != null) { helpLabel.activeControl = c;
helpLabel.Invalidate(); } else { if (helpLabel.activeControl != null) { helpLabel.activeControl = null;
helpLabel.Invalidate(); } } } } } }
C#
namespace Microsoft.Samples.WinForms.Cs.HostApp { using System; using System.ComponentModel;
using System.Drawing; using System.Windows.Forms; using Microsoft.Samples.WinForms.Cs.HelpLabel;
public class HostApp : System.Windows.Forms.Form { /// <summary> /// Required designer variable. ///
</summary> private System.ComponentModel.Container components; private
System.Windows.Forms.Label label1; private System.Windows.Forms.TextBox textBox1; private
System.Windows.Forms.Button button1; private Microsoft.Samples.WinForms.Cs.HelpLabel.HelpLabel
helpLabel1; public HostApp() { // // Required for Windows Form Designer support //
InitializeComponent(); } /// <summary> /// Clean up any resources being used. /// </summary> protected
override void Dispose(bool disposing) { if (disposing) { components.Dispose(); } base.Dispose(disposing); }
/// <summary> /// Required method for Designer support - do not modify /// the contents of this method
with the code editor. /// </summary> private void InitializeComponent() { this.components = new
System.ComponentModel.Container(); this.label1 = new System.Windows.Forms.Label(); this.button1 = new
System.Windows.Forms.Button(); this.textBox1 = new System.Windows.Forms.TextBox(); this.helpLabel1 =
new Microsoft.Samples.WinForms.Cs.HelpLabel.HelpLabel(); label1.Location = new
System.Drawing.Point(16, 16); label1.Text = "Name:"; label1.Size = new System.Drawing.Size(56, 24);
label1.TabIndex = 3; helpLabel1.Dock = System.Windows.Forms.DockStyle.Bottom; helpLabel1.Size = new
System.Drawing.Size(448, 40); helpLabel1.TabIndex = 0; helpLabel1.Location = new
System.Drawing.Point(0, 117); button1.Anchor = AnchorStyles.Right | AnchorStyles.Bottom; button1.Size =
new System.Drawing.Size(104, 40); button1.TabIndex = 1; helpLabel1.SetHelpText(button1, "This is the Save
Button. Press the Save Button to save your work."); button1.Text = "&Save"; button1.Location = new
System.Drawing.Point(336, 56); this.Text = "Control Example"; this.ClientSize = new
System.Drawing.Size(448, 157); textBox1.Anchor = AnchorStyles.Left| AnchorStyles.Right |
AnchorStyles.Top; textBox1.Location = new System.Drawing.Point(80, 16); textBox1.Text = "<Name>";
helpLabel1.SetHelpText(textBox1, "This is the name field. Please enter your name here."); textBox1.TabIndex
= 2; textBox1.Size = new System.Drawing.Size(360, 20); this.Controls.Add(label1);
this.Controls.Add(textBox1); this.Controls.Add(button1); this.Controls.Add(helpLabel1); } /// <summary>

/// The main entry point for the application. /// </summary> [STAThread] public static void Main(string[]
args) { Application.Run(new HostApp()); } } }
COMO: Acessar serviços em tempo de criação

O exemplo de código a seguir descreve como para obter acesso ao conjunto de serviços .NET
Framework Rich para que possa integrar a componentes e controles ao ambiente de
desenvolvimento.
Exemplo
Este exemplo de código demonstra como acessar serviços no seu designer personalizado. Uma
classe chamada DemoControlDesigner Designer está conectado a uma DemoControl classe e
executa as seguintes operações:
• Cria um Timer componente usando o CreateComponent método.

• Do Code Editor usa o ShowCode método para iniciar e exibir um manipulador de eventos
que é criado quando o Timer componente é criado.
• Usa o DestroyComponent método para remover um Timer componente do ambiente de
design.
• Usa GetExtenderProviders para enumerar todos os provedores Extender e exibi-los em um
MessageBox.
• Usa o GetReferences método para enumerar todas as instâncias DemoControl na
superfície do design.
• Usa o GetPathOfAssembly método para exibir o caminho do conjunto de execução.
• Usa o GetComponentTypes método para localizar todos os tipos que derivar de
ScrollableControl.
• Usa o CategoryNames método para enumerar todas as categorias que aparecem no
Toolbox.
• Define uma propriedade sombreada BackColor no designer, que for serializado, o
ambiente de desenvolvimento em vez do valor BackColor do DemoControl.
• Adiciona e remove usando PreFilterProperties propriedades e PostFilterProperties
métodos.
C#





A DemoControl classe é derivada da UserControl classe, mas exige nenhuma lógica especial para
estender sua interface do usuário em tempo de design. A interface de usuário em tempo de design
é implementada pela classe DemoControlDesigner.
A conexão com serviços
A DemoControl classe adquire referências a vários serviços em seu InitializeServices método.
C#
// These are the services which DemoControlDesigner will use. private DesignerActionService actionService
= null; private DesignerActionUIService actionUiService = null; private IComponentChangeService
changeService = null; private IDesignerEventService eventService = null; private IDesignerHost host = null;
private IDesignerOptionService optionService = null; private IEventBindingService eventBindingService =
null; private IExtenderListService listService = null; private IReferenceService referenceService = null;
private ISelectionService selectionService = null; private ITypeResolutionService typeResService = null;
private IComponentDiscoveryService componentDiscoveryService = null; private IToolboxService
toolboxService = null; private UndoEngine undoEng = null;
C#
// This utility method connects the designer to various // services it will use. private void InitializeServices()
{ // Acquire a reference to DesignerActionService. this.actionService =
GetService(typeof(DesignerActionService)) as DesignerActionService; // Acquire a reference to
DesignerActionUIService. this.actionUiService = GetService(typeof(DesignerActionUIService)) as
DesignerActionUIService; // Acquire a reference to IComponentChangeService. this.changeService =
GetService(typeof(IComponentChangeService)) as IComponentChangeService; // Hook the
IComponentChangeService events. if (this.changeService != null) { this.changeService.ComponentChanged
+= new ComponentChangedEventHandler( ChangeService_ComponentChanged);
this.changeService.ComponentAdded += new ComponentEventHandler(
ChangeService_ComponentAdded); this.changeService.ComponentRemoved += new
ComponentEventHandler( changeService_ComponentRemoved); } // Acquire a reference to

!= null) { MessageBox.Show("UndoEngine"); } }
Eventos serviço
Alguns serviços eventos de oferta ao qual o designer pode anexar. Por exemplo, a
DemoControlDesigner classe anexa manipuladores de eventos para o ComponentChanged,
ComponentAdded., e ComponentRemoved eventos
C#
// Hook the IComponentChangeService events. if (this.changeService != null) {
new ComponentEventHandler( changeService_ComponentRemoved); }
C#
void ChangeService_ComponentChanged( object sender, ComponentChangedEventArgs e) { string msg =
ComponentEventArgs e) { MessageBox.Show( e.Component.ToString(), "ComponentRemoved"); }
Implementar o método Dispose no criador
Tenha cuidado ao desanexar o manipuladores de eventos no método seu designer Dispose. Isso
evita comportamento indesejado quando seu designer sai do escopo.
C#
// The Dispose method override is implemented so event handlers // can be removed. This prevents objects
from lingering in // memory beyond the desired lifespan. protected override void Dispose(bool disposing) { if
(disposing) { if (this.changeService != null) { // Unhook event handlers.
this.changeService.ComponentChanged -= new ComponentChangedEventHandler(
ChangeService_ComponentChanged); this.changeService.ComponentAdded -= new
ComponentEventHandler( ChangeService_ComponentAdded); this.changeService.ComponentRemoved -=
new ComponentEventHandler( changeService_ComponentRemoved); } if (this.eventService != null) {

base.Dispose(disposing); }
Usando serviços
A DemoControl classe usa vários serviços no seu Painel marca inteligente. Uma classe interno
chamado DemoActionList é derivada da DesignerActionList classe. Essa classe tem métodos que
permitem que você se criar, excluir, e enumerar vários objetos que estão disponíveis no ambiente
de desenvolvimento. Ela expõe esses métodos como marcas inteligentes. Por exemplo, o
exemplo de código a seguir utiliza o GetExtenderProviders método para enumerar todos os
provedores Extender presentes no ambiente de desenvolvimento.
C#
// This method uses IExtenderListService.GetExtenderProviders // to enumerate all the extender providers
and display them // in a MessageBox. private void GetExtenderProviders() { if
(this.relatedDesigner.listService != null) { StringBuilder sb = new StringBuilder(); IExtenderProvider[]
providers = this.relatedDesigner.listService.GetExtenderProviders(); for (int i = 0; i < providers.Length; i++)
{ sb.Append(providers[i].ToString()); sb.Append("\r\n"); } MessageBox.Show( sb.ToString(), "Extender
Providers"); } }
componente.
COMO: Serializar coleções de tipos padrão com o

DesignerSerializationVisibilityAttribute
Quando os controles personalizados expor uma coleção como uma propriedade, você pode
serializar a coleta no horário de design.
Exemplo
Este exemplo demonstra como usar a DesignerSerializationVisibilityAttribute classe para controlar

como uma coleção for serializada em tempo de design. Aplicar o Content valor a sua propriedade
coleção garante que a propriedade será ser serializada.
Há suporte para esta tarefa no Visual Studio abrangente.
C#
using System; using System.Collections.Generic; using System.ComponentModel; using System.Drawing;
using System.Text; using System.Windows.Forms; // This sample demonstrates the use of the //
DesignerSerializationVisibility attribute // to serialize a collection of strings // at design time. namespace
SerializationDemo { class Form1 : Form { private SerializationDemoControl serializationDemoControl1;
public Form1() { InitializeComponent(); } // The Windows Forms Designer emits code to this method. // If
an instance of SerializationDemoControl is added // to the form, the Strings will be serialized here. private
void InitializeComponent() { this.serializationDemoControl1 = new

SerializationDemo.SerializationDemoControl(); this.SuspendLayout(); // // serializationDemoControl1 //
this.serializationDemoControl1.Location = new System.Drawing.Point(0, 0);
this.serializationDemoControl1.Name = "serializationDemoControl1";
this.serializationDemoControl1.Padding = new System.Windows.Forms.Padding(5);
this.serializationDemoControl1.TabIndex = 0; // // Form1 // this.ClientSize = new
System.Drawing.Size(292, 273); this.Controls.Add(this.serializationDemoControl1); this.Name = "Form1";
this.Text = "Form1"; this.ResumeLayout(false); } [STAThread] static void Main() {
Application.EnableVisualStyles(); Application.Run(new Form1()); } } public class SerializationDemoControl :
UserControl { // This is the TextBox contained by // the SerializationDemoControl. private
System.Windows.Forms.TextBox textBox1; // This field backs the Strings property. private String[]
stringsValue = new String[1]; public SerializationDemoControl() { InitializeComponent(); } // When the
DesignerSerializationVisibility attribute has // a value of "Content" or "Visible" the designer will // serialize
the property. This property can also be edited // at design time with a CollectionEditor.
[DesignerSerializationVisibility( DesignerSerializationVisibility.Content )] public String[] Strings { get {
return this.stringsValue; } set { this.stringsValue = value; // Populate the contained TextBox with the values
// in the stringsValue array. StringBuilder sb = new StringBuilder(this.stringsValue.Length); for (int i = 0; i
< this.stringsValue.Length; i++) { sb.Append(this.stringsValue[i]); sb.Append("\r\n"); } this.textBox1.Text =
sb.ToString(); } } private void InitializeComponent() { this.textBox1 = new
System.Windows.Forms.TextBox(); this.SuspendLayout(); // Settings for the contained TextBox control.
this.textBox1.AutoSize = false; this.textBox1.Dock = System.Windows.Forms.DockStyle.Fill;
this.textBox1.Location = new System.Drawing.Point(5, 5); this.textBox1.Margin = new
System.Windows.Forms.Padding(0); this.textBox1.Multiline = true; this.textBox1.Name = "textBox1";
this.textBox1.ReadOnly = true; this.textBox1.ScrollBars = ScrollBars.Vertical; this.textBox1.Size = new
System.Drawing.Size(140, 140); this.textBox1.TabIndex = 0; // Settings for SerializationDemoControl.
this.Controls.Add(this.textBox1); this.Name = "SerializationDemoControl"; this.Padding = new
System.Windows.Forms.Padding(5); this.ResumeLayout(false); } } }
Como: Executar inicialização personalizada para controles no

modo de design
Você pode usar o designer personalizado para inicializar componentes e controles como elas são
criadas pelo ambiente de desenvolvimento.
Exemplo
O exemplo de código a seguir demonstra como inicializar um controle quando ele é criado pelo
ambiente de desenvolvimento. Esta criação ocorre quando você arrastar uma instância do
controle para o formulário, e ele também ocorre quando você inicia o designer para o formulário.
Para obter uma explicação sobre neste exemplo, de código completa Consulte Como: Estender a
aparência e comportamento de controles no modo de design.
C#
// This demonstrates changing the appearance of a control while // it is being designed. In this case, the
BackColor property is // set to LightBlue. public override void InitializeNewComponent(IDictionary
defaultValues) { base.InitializeNewComponent(defaultValues); PropertyDescriptor colorPropDesc =
TypeDescriptor.GetProperties(Component)["BackColor"]; if (colorPropDesc != null &&

colorPropDesc.PropertyType == typeof(Color) && !colorPropDesc.IsReadOnly &&
colorPropDesc.IsBrowsable) { colorPropDesc.SetValue(Component, Color.LightBlue); } }
Quando o ambiente de desenvolvimento cria uma instância do controle ou componente, ele

chama método seu designer InitializeNewComponent. No exemplo de código anterior, a
propriedade do controle BackColor é definida usando um PropertyDescriptor.
componente.
COMO: Implementar um conversor de tipo

Um conversor tipo pode ser usado para converter valores entre tipos de dados, e para ajudar
configuração propriedade em tempo de design, fornecendo uma lista drop-down de valores para
selecionar de conversão de texto para valor-ou. Se configurado corretamente, um conversor tipo
poderá produzir Propriedade configuração código utilizando e System.Reflection objetos para
fornecer o sistema de serialização Designer as informações necessárias para gerar código que
inicializa a propriedade em tempo de execução. um InstanceDescriptor
Conversores tipo para tradução valor
Conversores tipo podem ser usados para conversões valor seqüência-para-ou conversão para ou
de tipos de dados com suporte em tempo de criação quanto no tempo de execução. Em um host
como um navegador propriedade em um designer de formulários, tipo Os conversores permitem
que um valor de propriedade para ser representado como texto para o usuário, e eles podem
converter um texto inserido pelo usuário em um valor do tipo de dados apropriado.
Mais nativos tipos de dados (Int32. tipos de enumeração, e outros) ter conversores tipo padrão
que fornecem valor seqüência-para-conversões e executar verificações de validação, String Os
conversores tipo padrão estão no espaço para nome System.ComponentModel e são nomeados
TypeConverterNameConverter. Você pode estender um conversor tipo quando a funcionalidade
padrão não é adequada para seu fins ou implementar um conversor Tipo personalizado quando
você define um tipo personalizado que não tenha um conversor de tipos associados.
Observação
Um TypeConverterAttribute Atributo geralmente é aplicado a uma propriedade ou um membro de

dados para associá-lo a um conversor tipo. Se a um tipo, não é necessário para ser reaplicada
aos membros propriedades ou dados do tipo. é aplicada uma TypeConverterAttribute
A implementação de um conversor tipo é independente de qualquer funcionalidade da interface do

usuário. Portanto, o mesmo conversor tipo pode ser aplicado no Windows Forms e em formulários
da Web.
Para implementar um conversor de tipo simples que pode converter uma seqüência para
um ponto
1. Definir uma classe que deriva de TypeConverter.

2. Substituir o CanConvertFrom método que especifica o tipo o conversor pode converter do.
Este método está sobrecarregado.
3. Substituir o ConvertFrom método que implementa a conversão. Este método está
sobrecarregado.
4. Substituir o CanConvertTo método que especifica o tipo o conversor pode converter para.
Não é necessário para substituir esse método para conversão para um tipo de seqüência.
Este método está sobrecarregado.
5. Substituir o ConvertTo método que implementa a conversão. Este método está
sobrecarregado.
6. Substituir o IsValid método que realiza validação. Este método está sobrecarregado.
O exemplo de código a seguir implementa um conversor tipo que converte um String tipo em um
Point tipo e a Point. em um String O CanConvertTo e IsValid métodos não são substituídos,
neste exemplo.
C#
using System; using System.ComponentModel; using System.Globalization; using System.Drawing; public
class PointConverter : TypeConverter { // Overrides the CanConvertFrom method of TypeConverter. // The
ITypeDescriptorContext interface provides the context for the // conversion. Typically, this interface is used
at design time to // provide information about the design-time container. public override bool
CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { if (sourceType == typeof(string)) {
return true; } return base.CanConvertFrom(context, sourceType); } // Overrides the ConvertFrom method of
TypeConverter. public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture,
object value) { if (value is string) { string[] v = ((string)value).Split(new char[] {','}); return new
Point(int.Parse(v[0]), int.Parse(v[1])); } return base.ConvertFrom(context, culture, value); } // Overrides the
ConvertTo method of TypeConverter. public override object ConvertTo(ITypeDescriptorContext context,
CultureInfo culture, object value, Type destinationType) { if (destinationType == typeof(string)) { return
((Point)value).X + "," + ((Point)value).Y; } return base.ConvertTo(context, culture, value, destinationType); }
}
Conversores tipo que fornecer uma lista de valores padrão para uma janela Propriedades
Um conversor tipo pode fornecer uma lista de valores para um tipo em um controle janela
Propriedades. Quando um conversor tipo fornece um conjunto de valores padrão para um tipo, o
campo de entrada valor de uma propriedade do tipo associado em um controle janela
Propriedades exibe uma seta para baixo que exibe uma lista de valores para definir o valor da
propriedade para quando clicado.
Quando uma propriedade do tipo está associado a este conversor tipo selecionada em um
navegador Propriedade de ambiente em tempo de design, o campo de entrada Valor conterá um
botão que exibe uma lista drop-down dos valores padrão para o tipo de propriedade que você
pode selecionar de.
Para implementar um conversor de tipo simples que fornece uma lista drop-down de
valores padrão em um navegador Propriedade
2. Substituir o GetStandardValuesSupported método e retornar true.
3. Substituir o GetStandardValues método e retornar os valores padrão para o tipo de
propriedade com StandardValuesCollection. Os valores padrão para uma propriedade deve
ser do mesmo tipo que a propriedade próprio.

4. Substituir o CanConvertFrom método e retornar true para um sourceType valor de
parâmetro do tipo seqüência.
5. Substituir o ConvertFrom método e retornar o valor adequado para a propriedade com
base no parâmetro value.
6. Aplicar uma TypeConverterAttribute que indica o tipo de seu conversor tipo para o tipo
que você está fornecendo um conjunto de valores padrão para.
O exemplo a seguir demonstra um conversor tipo que fornece uma lista de valores padrão para
um controle janela Propriedades para uma propriedade do tipo ele está associado. O conversor
tipo exemplo oferece suporte propriedades do tipo inteiro com o qual ele foi associado. Para usar
o exemplo no Visual Studio .NET, compilar o código para uma biblioteca de classe, e adicione o
IntStandardValuesControl componente para o Toolbox. Do IntStandardValuesControl adicionar uma
instância da um formulário no modo de design, e rolar para a TestInt propriedade na janela
Propriedades enquanto o controle esteja selecionado. Selecione o campo de entrada de valor
para a propriedade exibir uma seta para baixo que exibe uma lista drop-down de valores padrão
quando clicado. Inserir um valor inteiro será adicione o valor para a lista de valores padrão, e
defina a propriedade para o valor especificado.
C#
using System; using System.ComponentModel; using System.Collections; using System.Drawing; using

System.Windows.Forms; namespace StandardValuesTest { public class StandardValuesIntConverter :
System.ComponentModel.TypeConverter { private ArrayList values; public StandardValuesIntConverter() {
// Initializes the standard values list with defaults. values = new ArrayList(new int[] { 1, 2, 3, 4, 5 }); } //
Indicates this converter provides a list of standard values. public override bool
GetStandardValuesSupported(System.ComponentModel.ITypeDescriptorContext context) { return true; } //
Returns a StandardValuesCollection of standard value objects. public override
System.ComponentModel.TypeConverter.StandardValuesCollection
GetStandardValues(System.ComponentModel.ITypeDescriptorContext context) { // Passes the local integer
array. StandardValuesCollection svc = new StandardValuesCollection(values); return svc; } // Returns true
for a sourceType of string to indicate that // conversions from string to integer are supported. (The //
GetStandardValues method requires a string to native type // conversion because the items in the drop-down
list are // translated to string.) public override bool
CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType) { if(
sourceType == typeof(string) ) return true; else return base.CanConvertFrom(context, sourceType); } // If
the type of the value to convert is string, parses the string // and returns the integer to set the value of the
property to. // This example first extends the integer array that supplies the // standard values collection if
the user-entered value is not // already in the array. public override object
ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo
culture, object value) { if( value.GetType() == typeof(string) ) { // Parses the string to get the integer to set to
the property. int newVal = int.Parse((string)value); // Tests whether new integer is already in the list. if(
!values.Contains(newVal) ) { // If the integer is not in list, adds it in order. values.Add(newVal);
values.Sort(); } // Returns the integer value to assign to the property. return newVal; } else return
base.ConvertFrom(context, culture, value); } } // Provides a test control with an integer property associated
with // the StandardValuesIntConverter type converter. public class IntStandardValuesControl :
System.Windows.Forms.UserControl { [TypeConverter(typeof(StandardValuesIntConverter))] public int
TestInt { get { return this.integer_field; } set { if(value.GetType() == typeof(int)) this.integer_field = value; }
} private int integer_field = 0; public IntStandardValuesControl() { this.BackColor = Color.White; this.Size =

new Size(472, 80); } // OnPaint override displays instructions for the example. protected override void
OnPaint(System.Windows.Forms.PaintEventArgs e) { if(this.DesignMode) {
e.Graphics.DrawString("TypeConverter.GetStandardValues Example Control", new
Font(FontFamily.GenericMonospace, 10), new SolidBrush(Color.Blue), 5, 5); e.Graphics.DrawString("The
type converter for the TestInt property of this", new Font(FontFamily.GenericMonospace, 10), new
SolidBrush(Color.Black), 5, 20); e.Graphics.DrawString("component provides a list of standard values to
the", new Font(FontFamily.GenericMonospace, 10), new SolidBrush(Color.Black), 5, 30);
e.Graphics.DrawString("Properties window. Setting a value through a property", new
Font(FontFamily.GenericMonospace, 10), new SolidBrush(Color.Black), 5, 40); e.Graphics.DrawString("grid
adds it to the list of standard values.", new Font(FontFamily.GenericMonospace, 10), new
SolidBrush(Color.Black), 5, 50); } else { e.Graphics.DrawString("TypeConverter.GetStandardValues Example
Control", new Font(FontFamily.GenericMonospace, 10), new SolidBrush(Color.Blue), 5, 5);
e.Graphics.DrawString("This control was intended for use in design mode.", new
Font(FontFamily.GenericMonospace, 10), new SolidBrush(Color.Black), 5, 20); } } } }
Horário conversores tipo que gerar código para inicialização Propriedade em execução
O.NET Framework fornece a capacidade para gerar código de inicialização dinâmica propriedade
em tempo de design que será inicializar uma propriedade em tempo de execução.
Os desenvolvedores podem criar código de inicialização baseado no construtor-que produz um

conversor tipo. Esses conversores tipo podem gerar códigos de construtor dinamicamente usando
valores definidos em tempo de design a fim de configurar propriedades de um tipo em tempo de
execução. O conversor tipo implementa a lógica para configurar o tipo e valores de um construtor
para a propriedade.
Caso você precise produzir código além um construtor para inicializar uma propriedade, é possível
fazer dinamicamente gerar código por implementar uma personalizada CodeDomSerializer e
aplicar uma DesignerSerializerAttribute que associa para um tipo com o tipo. seu
CodeDomSerializer Essa abordagem normalmente é usada somente para cenários nos quais a
geração de código dinamicamente controlado ou personalizados para inicialização componente é
importante. Para obter mais informações sobre essa abordagem, consulte a documentação para
CodeDomSerializer.
Para criar um inicializador-baseado no Construtor de propriedades personalizadas, você deve

associar um conversor tipo com o tipo da propriedade Ao inicializar, e o conversor tipo deve ser
capaz para converter em uma InstanceDescriptor.
Para implementar um conversor tipo que produz Propriedade baseado no construtor-

código de inicialização
2. Substituir o CanConvertTo método. Se igual tipo, o destinationType Parâmetro a
InstanceDescriptor retornar true.
3. Substituir o ConvertTo método. Se é o destinationType Parâmetro igual o
InstanceDescriptor tipo, construir e retornar um InstanceDescriptor que representa o
construtor e argumentos de construtor para gerar código para. Para criar um
InstanceDescriptor que representa o construtor apropriado e parâmetros, obter ou
GetConstructors método com a assinatura a método apropriado do construtor você está
procurando. da propriedade você estiver inicializando, chamando um ConstructorInfo o Type
o GetConstructor Criar um novo descritor da instância e passar para o tipo que representa o
tipo de construtor a ser usado, juntamente com uma matriz de objetos de parâmetro que
corresponde à assinatura de construtor. o ConstructorInfo

O exemplo a seguir implementa um conversor tipo que pode gerar código de inicialização
Propriedade-baseado no Construtor de propriedades do tipo Point.
C#
public class PointConverter : TypeConverter { public override bool CanConvertTo(ITypeDescriptorContext
context, Type destinationType) { if (destinationType == typeof(InstanceDescriptor)) return true; return
base.CanConvertTo(context, destinationType); } public override object ConvertTo(ITypeDescriptorContext
context, CultureInfo culture, object value, Type destinationType) { // Insert other ConvertTo operations
here. // if (destinationType == typeof(InstanceDescriptor) && value is Point) { Point pt = (Point)value;
ConstructorInfo ctor = typeof(Point).GetConstructor( new Type[] {typeof(int), typeof(int)}); if (ctor != null) {
return new InstanceDescriptor(ctor, new object[] {pt.X, pt.Y}); } } return base.ConvertTo(context, culture,
value, destinationType); }
• Quando você desenvolver seu personalizadas TypeConverter, é recomendável que você
definir o número de criação para incrementar com cada compilação. Isso impede que versões
mais antigas, armazenadas em cache de sendo criada no ambiente de desenvolvimento. seu
TypeConverter
COMO: Implementar um editor UI de tipo

Em algumas situações, uma conversão de valor para seqüência-simples que permite uma
propriedade a ser exibido como texto em um navegador propriedade pode não adequada. Além
disso, um estilo de configuração valor seqüência-para-talvez não adequado para alguns tipos. Por
exemplo, no caso de uma propriedade de cores, uma representação visual é mais desejável. Um
editor tipo UI pode fornecer uma representação visual de um valor propriedade em um controle de
grade propriedade, como um navegador Propriedade Design-time. Um editor tipo UI também pode
fornecer uma interface de usuário personalizada para configurar o valor ou valores de um objeto
de um tipo específico.
Observação
Um EditorAttribute é aplicada a um tipo ou como uma propriedade para associar o tipo ou a

propriedade com um editor tipo UI.
Para implementar um editor tipo UI personalizado para Windows Forms

1. Definir uma classe que deriva de System.Drawing.Design.UITypeEditor.
2. Substituir o EditValue método para configurar propriedades da interface do usuário. Este
método está sobrecarregado.
3. Substituir o GetEditStyle método para informar o navegador Propriedade sobre o suporte
de edição que você fornecerá.
Para uma amostra completa, consulte Passo-a-passo: Implementando um Editor de Tipos de

Interface do Usuário.
• Quando você desenvolver seu personalizadas UITypeEditor, é recomendável que você
definir o número de criação para incrementar com cada compilação. Isso impede que versões
mais antigas, armazenadas em cache de sendo criada no ambiente de desenvolvimento. seu
UITypeEditor

Como: Estender a aparência e comportamento de controles no
modo de design
Você pode estender o ambiente em tempo de design, criando seus próprios designer
personalizado. O designer personalizado pode alterar a aparência e comportamento do seu
controle enquanto o usuário é criar o controle.
Exemplo
O exemplo de código a seguir demonstra como criar um designer personalizado que estende a
interface de usuário (UI) para criar um controle personalizado. Uma classe chamada
DemoControlDesigner Designer é conectado a uma DemoControl classe, ativando Recursos os
seguir:
• Inicialização personalizada do novas DemoControl instâncias;

• Representação visual do controle Margin e Padding Propriedades;
• Interação mouse e teclado para definir a Anchor propriedade;
• Interface de marca inteligente para definir a Anchor propriedade.
C#
System.ComponentModel.Design; using System.Drawing; using System.Drawing.Design; using
System.Windows.Forms; using System.Windows.Forms.Design; using
private DemoControl demoControl2; private System.ComponentModel.IContainer components = null;
public Form1() { InitializeComponent(); } protected override void Dispose(bool disposing) { if (disposing &&
(components != null)) { components.Dispose(); } base.Dispose(disposing); } [STAThread] static void Main()
{ Application.EnableVisualStyles(); Application.Run(new Form1()); } private void InitializeComponent() {
this.demoControl2 = new DemoControl(); this.demoControl1 = new DemoControl(); this.SuspendLayout();
// // demoControl2 // this.demoControl2.Anchor =
((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top |
System.Windows.Forms.AnchorStyles.Bottom) | System.Windows.Forms.AnchorStyles.Left) |
System.Windows.Forms.AnchorStyles.Right))); this.demoControl2.BackColor =
System.Drawing.Color.LightBlue; this.demoControl2.Location = new System.Drawing.Point(40, 40);
this.demoControl2.Margin = new System.Windows.Forms.Padding(20); this.demoControl2.Name =
"demoControl2"; this.demoControl2.Padding = new System.Windows.Forms.Padding(20);
this.demoControl2.Size = new System.Drawing.Size(284, 177); this.demoControl2.TabIndex = 1; // //
demoControl1 // this.demoControl1.Anchor =
((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top |
System.Windows.Forms.AnchorStyles.Bottom) | System.Windows.Forms.AnchorStyles.Left)));
this.demoControl1.BackColor = System.Drawing.Color.LightBlue; this.demoControl1.Location = new
System.Drawing.Point(354, 21); this.demoControl1.Margin = new System.Windows.Forms.Padding(10);
this.demoControl1.Name = "demoControl1"; this.demoControl1.Padding = new
System.Windows.Forms.Padding(10); this.demoControl1.Size = new System.Drawing.Size(184, 207);
this.demoControl1.TabIndex = 0; // // Form1 // this.ClientSize = new System.Drawing.Size(594, 352);
this.Controls.Add(this.demoControl2); this.Controls.Add(this.demoControl1); this.Name = "Form1";
this.Padding = new System.Windows.Forms.Padding(20); this.Text = "a"; this.ResumeLayout(false); } } //
This control demonstrates the use of a custom designer. [DesignerAttribute(typeof(DemoControlDesigner))]

public class DemoControl : UserControl { private System.ComponentModel.IContainer components = null;
public DemoControl() { InitializeComponent(); } protected override void Dispose(bool disposing) { if
InitializeComponent() { // // DemoControl // this.Name = "DemoControl"; } } // This class demonstrates
how to build a custom designer. // When an instance of the associated control type is created // in a design
environment like Visual Studio, this designer // provides custom design-time behavior. // // When you drop
an instance of DemoControl onto a form, // this designer creates two adorner windows: one is used // for
glyphs that represent the Margin and Padding properties // of the control, and the other is used for glyphs
that // represent the Anchor property. // // The AnchorGlyph type defines an AnchorBehavior type that //
allows you to change the value of the Anchor property // by double-clicking on an AnchorGlyph. // // This
designer also offers a smart tag for changing the // Anchor property.
"FullTrust")] public class DemoControlDesigner : ControlDesigner { // This adorner holds the glyphs that
represent the Anchor property. private Adorner anchorAdorner = null; // This adorner holds the glyphs that
represent the Margin and // Padding properties. private Adorner marginAndPaddingAdorner = null; // This
defines the size of the anchor glyphs. private const int glyphSize = 6; // This defines the size of the hit bounds
for an AnchorGlyph. private const int hitBoundSize = glyphSize + 4; // References to designer services, for
convenience. private IComponentChangeService changeService = null; private ISelectionService
selectionService = null; private BehaviorService behaviorSvc = null; // This is the collection of
DesignerActionLists that // defines the smart tags offered on the control. private
DesignerActionListCollection actionLists = null; public DemoControlDesigner() { } protected override void
Dispose(bool disposing) { if (disposing) { if (this.behaviorSvc != null) { // Remove the adorners added by this
designer from // the BehaviorService.Adorners collection.
this.behaviorSvc.Adorners.Remove(this.marginAndPaddingAdorner);
this.behaviorSvc.Adorners.Remove(this.anchorAdorner); } } base.Dispose(disposing); } // This method is
where the designer initializes its state when // it is created. public override void Initialize(IComponent
component) { base.Initialize(component); // Connect to various designer services. InitializeServices(); //
Initialize adorners. this.InitializeMarginAndPaddingAdorner(); this.InitializeAnchorAdorner(); } // This
demonstrates changing the appearance of a control while // it is being designed. In this case, the BackColor
property is // set to LightBlue. public override void InitializeNewComponent(IDictionary defaultValues) {
base.InitializeNewComponent(defaultValues); PropertyDescriptor colorPropDesc =
TypeDescriptor.GetProperties(Component)["BackColor"]; if (colorPropDesc != null &&
colorPropDesc.PropertyType == typeof(Color) && !colorPropDesc.IsReadOnly &&
colorPropDesc.IsBrowsable) { colorPropDesc.SetValue(Component, Color.LightBlue); } } // This utility
method creates an adorner for the anchor glyphs. // It then creates four AnchorGlyph objects and adds them
to // the adorner's Glyphs collection. private void InitializeAnchorAdorner() { this.anchorAdorner = new
Adorner(); this.behaviorSvc.Adorners.Add(this.anchorAdorner); this.anchorAdorner.Glyphs.Add(new
AnchorGlyph( AnchorStyles.Left, this.behaviorSvc, this.changeService, this.selectionService, this,
this.anchorAdorner) ); this.anchorAdorner.Glyphs.Add(new AnchorGlyph( AnchorStyles.Top,
this.behaviorSvc, this.changeService, this.selectionService, this, this.anchorAdorner) );
this.anchorAdorner.Glyphs.Add(new AnchorGlyph( AnchorStyles.Right, this.behaviorSvc,
this.changeService, this.selectionService, this, this.anchorAdorner) ); this.anchorAdorner.Glyphs.Add(new
AnchorGlyph( AnchorStyles.Bottom, this.behaviorSvc, this.changeService, this.selectionService, this,
this.anchorAdorner) ); } // This utility method creates an adorner for the margin and // padding glyphs. It
then creates a MarginAndPaddingGlyph and // adds it to the adorner's Glyphs collection. private void
InitializeMarginAndPaddingAdorner() { this.marginAndPaddingAdorner = new Adorner();

this.behaviorSvc.Adorners.Add(this.marginAndPaddingAdorner);
this.marginAndPaddingAdorner.Glyphs.Add(new MarginAndPaddingGlyph( this.behaviorSvc,
this.changeService, this.selectionService, this, this.marginAndPaddingAdorner)); } // This utility method
connects the designer to various services. // These references are cached for convenience. private void
InitializeServices() { // Acquire a reference to IComponentChangeService. this.changeService =
GetService(typeof(IComponentChangeService)) as IComponentChangeService; // Acquire a reference to
ISelectionService. this.selectionService = GetService(typeof(ISelectionService)) as ISelectionService; //
Acquire a reference to BehaviorService. this.behaviorSvc = GetService(typeof(BehaviorService)) as
BehaviorService; } // This method creates the DesignerActionList on demand, causing // smart tags to
appear on the control being designed. public override DesignerActionListCollection ActionLists { get { if (null
== actionLists) { actionLists = new DesignerActionListCollection(); actionLists.Add( new
AnchorActionList(this.Component)); } return actionLists; } } // This class defines the smart tags that appear
on the control // being designed. In this case, the Anchor property appears // on the smart tag and its value
can be changed through a // UI Type Editor created automatically by the // DesignerActionService. public
class AnchorActionList : System.ComponentModel.Design.DesignerActionList { // Cache a reference to the
control. private DemoControl relatedControl; //The constructor associates the control //with the smart tag
list. public AnchorActionList(IComponent component): base(component) { this.relatedControl = component
as DemoControl; } // Properties that are targets of DesignerActionPropertyItem entries. public AnchorStyles
Anchor { get { return this.relatedControl.Anchor; } set { PropertyDescriptor pdAnchor =
TypeDescriptor.GetProperties(this.relatedControl)["Anchor"]; pdAnchor.SetValue(this.relatedControl,
value); } } // This method creates and populates the // DesignerActionItemCollection which is used to //
display smart tag items. public override DesignerActionItemCollection GetSortedActionItems() {
DesignerActionItemCollection items = new DesignerActionItemCollection(); // Add a descriptive header.
items.Add(new DesignerActionHeaderItem("Anchor Styles")); // Add a DesignerActionPropertyItem for the
Anchor // property. This will be displayed in a panel using // the AnchorStyles UI Type Editor.
items.Add(new DesignerActionPropertyItem( "Anchor", "Anchor Style") ); return items; } } #region Glyph
Implementations // This class implements a MarginAndPaddingGlyph, which draws // borders highlighting
the value of the control's Margin // property and the value of the control's Padding property. // // This glyph
has no mouse or keyboard interaction, so its // related behavior class, MarginAndPaddingBehavior, has no
// implementation. public class MarginAndPaddingGlyph : Glyph { private BehaviorService behaviorService
= null; private IComponentChangeService changeService = null; private ISelectionService selectionService =
null; private IDesigner relatedDesigner = null; private Adorner marginAndPaddingAdorner = null; private
Control relatedControl = null; public MarginAndPaddingGlyph( BehaviorService behaviorService,
IComponentChangeService changeService, ISelectionService selectionService, IDesigner relatedDesigner,
Adorner marginAndPaddingAdorner) : base(new MarginAndPaddingBehavior()) { this.behaviorService =
behaviorService; this.changeService = changeService; this.selectionService = selectionService;
this.relatedDesigner = relatedDesigner; this.marginAndPaddingAdorner = marginAndPaddingAdorner;
this.relatedControl = this.relatedDesigner.Component as Control; this.changeService.ComponentChanged
+= new ComponentChangedEventHandler(changeService_ComponentChanged); } void
changeService_ComponentChanged(object sender, ComponentChangedEventArgs e) { if
(object.ReferenceEquals( e.Component, this.relatedControl)) { if (e.Member.Name == "Margin" ||
e.Member.Name == "Padding" ) { this.marginAndPaddingAdorner.Invalidate(); } } } // This glyph has no
mouse or keyboard interaction, so // GetHitTest can return null. public override Cursor GetHitTest(Point p)
{ return null; } // This method renders the glyph as a simple focus rectangle. public override void
Paint(PaintEventArgs e) { ControlPaint.DrawFocusRectangle( e.Graphics, this.Bounds);
ControlPaint.DrawFocusRectangle( e.Graphics, this.PaddingBounds); } // This glyph's Bounds property is a

Rectangle defined by // the value of the control's Margin property. public override Rectangle Bounds { get {
Control c = this.relatedControl; Rectangle controlRect =
this.behaviorService.ControlRectInAdornerWindow(this.relatedControl); Rectangle boundsVal = new
Rectangle( controlRect.Left - c.Margin.Left, controlRect.Top - c.Margin.Top, controlRect.Width +
c.Margin.Right*2, controlRect.Height + c.Margin.Bottom*2); return boundsVal; } } // The PaddingBounds
property is a Rectangle defined by // the value of the control's Padding property. public Rectangle
PaddingBounds { get { Control c = this.relatedControl; Rectangle controlRect =
Rectangle( controlRect.Left + c.Padding.Left, controlRect.Top + c.Padding.Top, controlRect.Width -
c.Padding.Right * 2, controlRect.Height - c.Padding.Bottom * 2); return boundsVal; } } // There are no
keyboard or mouse behaviors associated with // this glyph, but you could add them to this class. internal
class MarginAndPaddingBehavior : Behavior { } } // This class implements an AnchorGlyph, which draws
grab handles // that represent the value of the control's Anchor property. // // This glyph has mouse and
keyboard interactions, which are // handled by the related behavior class, AnchorBehavior. // Double-
clicking on an AnchorGlyph causes its value to be // toggled between enabled and disable states. public class
AnchorGlyph : Glyph { // This defines the bounds of the anchor glyph. protected Rectangle boundsValue; //
This defines the bounds used for hit testing. // These bounds are typically different than the bounds // of the
glyph itself. protected Rectangle hitBoundsValue; // This is the cursor returned if hit test is positive.
protected Cursor hitTestCursor = Cursors.Hand; // Cache references to services that will be needed. private
BehaviorService behaviorService = null; private IComponentChangeService changeService = null; private
ISelectionService selectionService = null; // Keep a reference to the designer for convenience. private
IDesigner relatedDesigner = null; // Keep a reference to the adorner for convenience. private Adorner
anchorAdorner = null; // Keep a reference to the control being designed. private Control relatedControl =
null; // This defines the AnchorStyle which this glyph represents. private AnchorStyles anchorStyle; public
AnchorGlyph( AnchorStyles anchorStyle, BehaviorService behaviorService, IComponentChangeService
changeService, ISelectionService selectionService, IDesigner relatedDesigner, Adorner anchorAdorner) :
base(new AnchorBehavior(relatedDesigner)) { // Cache references for convenience. this.anchorStyle =
anchorStyle; this.behaviorService = behaviorService; this.changeService = changeService;
this.selectionService = selectionService; this.relatedDesigner = relatedDesigner; this.anchorAdorner =
anchorAdorner; // Cache a reference to the control being designed. this.relatedControl =
this.relatedDesigner.Component as Control; // Hook the SelectionChanged event.
this.selectionService.SelectionChanged += new EventHandler(selectionService_SelectionChanged); // Hook
the ComponentChanged event so the anchor glyphs // can correctly track the control's bounds.
this.changeService.ComponentChanged += new
ComponentChangedEventHandler(changeService_ComponentChanged); } #region Overrides public
override Rectangle Bounds { get { return this.boundsValue; } } // This method renders the AnchorGlyph as a
filled rectangle // if the glyph is enabled, or as an open rectangle if the // glyph is disabled. public override
void Paint(PaintEventArgs e) { if (this.IsEnabled) { using (Brush b = new SolidBrush(Color.Tomato)) {
e.Graphics.FillRectangle(b, this.Bounds); } } else { using (Pen p = new Pen(Color.Tomato)) {
e.Graphics.DrawRectangle(p, this.Bounds); } } } // An AnchorGlyph has keyboard and mouse interaction, so
it's // important to return a cursor when the mouse is located in // the glyph's hit region. When this occurs,
the // AnchorBehavior becomes active. public override Cursor GetHitTest(Point p) { if
(hitBoundsValue.Contains(p)) { return hitTestCursor; } return null; } #endregion #region Event Handlers //
The AnchorGlyph objects should mimic the resize glyphs; // they should only be visible when the control is
the // primary selection. The adorner is enabled when the // control is the primary selection and disabled
when // it is not. void selectionService_SelectionChanged(object sender, EventArgs e) { if

(object.ReferenceEquals( this.selectionService.PrimarySelection, this.relatedControl)) {
this.ComputeBounds(); this.anchorAdorner.Enabled = true; } else { this.anchorAdorner.Enabled = false; } }
// If any of several properties change, the bounds of the // AnchorGlyph must be computed again. void
changeService_ComponentChanged( object sender, ComponentChangedEventArgs e) { if
(object.ReferenceEquals( e.Component, this.relatedControl)) { if (e.Member.Name == "Anchor" ||
e.Member.Name == "Size" || e.Member.Name == "Height" || e.Member.Name == "Width" ||
e.Member.Name == "Location") { // Compute the bounds of this glyph. this.ComputeBounds(); // Tell the
adorner to repaint itself. this.anchorAdorner.Invalidate(); } } } #endregion #region Implementation // This
utility method computes the position and size of // the AnchorGlyph in the Adorner window's coordinates. //
It also computes the hit test bounds, which are // slightly larger than the glyph's bounds. private void
ComputeBounds() { Rectangle translatedBounds = new Rectangle(
this.behaviorService.ControlToAdornerWindow(this.relatedControl), this.relatedControl.Size); if
((this.anchorStyle & AnchorStyles.Top) == AnchorStyles.Top) { this.boundsValue = new Rectangle(
translatedBounds.X + (translatedBounds.Width / 2) - (glyphSize / 2), translatedBounds.Y + glyphSize,
glyphSize, glyphSize); } if ((this.anchorStyle & AnchorStyles.Bottom) == AnchorStyles.Bottom) {
this.boundsValue = new Rectangle( translatedBounds.X + (translatedBounds.Width / 2) - (glyphSize / 2),
translatedBounds.Bottom - 2*glyphSize, glyphSize, glyphSize); } if ((this.anchorStyle & AnchorStyles.Left)
== AnchorStyles.Left) { this.boundsValue = new Rectangle( translatedBounds.X + glyphSize,
translatedBounds.Y + (translatedBounds.Height / 2) - (glyphSize / 2), glyphSize, glyphSize); } if
((this.anchorStyle & AnchorStyles.Right) == AnchorStyles.Right) { this.boundsValue = new Rectangle(
translatedBounds.Right - 2*glyphSize, translatedBounds.Y + (translatedBounds.Height / 2) - (glyphSize / 2),
glyphSize, glyphSize); } this.hitBoundsValue = new Rectangle( this.Bounds.Left - hitBoundSize / 2,
this.Bounds.Top - hitBoundSize / 2, hitBoundSize, hitBoundSize ); } // This utility property determines if the
AnchorGlyph is // enabled, according to the value specified by the // control's Anchor property. private bool
IsEnabled { get { return ((this.anchorStyle & this.relatedControl.Anchor) == this.anchorStyle); } }
#endregion #region Behavior Implementation // This Behavior specifies mouse and keyboard handling
when // an AnchorGlyph is active. This happens when // AnchorGlyph.GetHitTest returns a non-null value.
internal class AnchorBehavior : Behavior { private IDesigner relatedDesigner = null; private Control
relatedControl = null; internal AnchorBehavior(IDesigner relatedDesigner) { this.relatedDesigner =
relatedDesigner; this.relatedControl = relatedDesigner.Component as Control; } // When you double-click
on an AnchorGlyph, the value of // the control's Anchor property is toggled. // // Note that the value of the
Anchor property is not set // by direct assignment. Instead, the // PropertyDescriptor.SetValue method is
used. This // enables notification of the design environment, so // related events can be raised, for example,
the // IComponentChangeService.ComponentChanged event. public override bool OnMouseDoubleClick(
Glyph g, MouseButtons button, Point mouseLoc) { base.OnMouseDoubleClick(g, button, mouseLoc); if
(button == MouseButtons.Left) { AnchorGlyph ag = g as AnchorGlyph; PropertyDescriptor pdAnchor =
TypeDescriptor.GetProperties(ag.relatedControl)["Anchor"]; if (ag.IsEnabled) { // The glyph is enabled. //
Clear the AnchorStyle flag to disable the Glyph. pdAnchor.SetValue( ag.relatedControl,
ag.relatedControl.Anchor ^ ag.anchorStyle ); } else { // The glyph is disabled. // Set the AnchorStyle flag to
enable the Glyph. pdAnchor.SetValue( ag.relatedControl, ag.relatedControl.Anchor | ag.anchorStyle); } }
return true; } } #endregion } #endregion }
A DemoControl classe é derivada da UserControl classe, mas exige nenhuma lógica especial para
estender sua interface do usuário em tempo de design. A interface de usuário em tempo de design
é implementada pela classe DemoControlDesigner.

Os DemoControlDesigner usos de classe a Glyph, Behavior., e Adorner classes para estender a
experiência em tempo de design para DemoControl Do Glyph são implementados com os
aspectos visuais da interface de usuário estendida e Adorner Classes. As interações mouse e
teclado são implementadas na classe Behavior.
Você pode estender a aparência Design-time e o comportamento do seu designer, substituindo

apenas ControlDesigner métodos como OnPaintAdornments e OnMouseEnter. mas a Glyph
classe fornece uma maneira conveniente de aparência e comportamento lógica fora do seu
designer fator
Estendendo a aparência
Você estender a aparência do seu projeto personalizado UI, implementar uma Glyph classe. A
MarginAndPaddingGlyph classe deriva da classe Glyph. Ele pinta dois retângulos que representam
os valores do controle é Margin e Padding Propriedades. A MarginAndPaddingGlyph classe
manipula o ComponentChanged evento para atualizar a exibição quando os valores das
propriedades do controle Margin ou Padding a alteração.
O exemplo de código a seguir mostra como implementar uma MarginAndPaddingGlyph classe que
deriva de Glyph.
C#
// This class implements a MarginAndPaddingGlyph, which draws // borders highlighting the value of the
control's Margin // property and the value of the control's Padding property. // // This glyph has no mouse
or keyboard interaction, so its // related behavior class, MarginAndPaddingBehavior, has no //
implementation. public class MarginAndPaddingGlyph : Glyph { private BehaviorService behaviorService =
null; private IComponentChangeService changeService = null; private ISelectionService selectionService =
null; private IDesigner relatedDesigner = null; private Adorner marginAndPaddingAdorner = null; private
Control relatedControl = null; public MarginAndPaddingGlyph( BehaviorService behaviorService,
Adorner marginAndPaddingAdorner) : base(new MarginAndPaddingBehavior()) { this.behaviorService =
behaviorService; this.changeService = changeService; this.selectionService = selectionService;
this.relatedDesigner = relatedDesigner; this.marginAndPaddingAdorner = marginAndPaddingAdorner;
this.relatedControl = this.relatedDesigner.Component as Control; this.changeService.ComponentChanged
+= new ComponentChangedEventHandler(changeService_ComponentChanged); } void
changeService_ComponentChanged(object sender, ComponentChangedEventArgs e) { if
(object.ReferenceEquals( e.Component, this.relatedControl)) { if (e.Member.Name == "Margin" ||
e.Member.Name == "Padding" ) { this.marginAndPaddingAdorner.Invalidate(); } } } // This glyph has no
mouse or keyboard interaction, so // GetHitTest can return null. public override Cursor GetHitTest(Point p)
{ return null; } // This method renders the glyph as a simple focus rectangle. public override void
Paint(PaintEventArgs e) { ControlPaint.DrawFocusRectangle( e.Graphics, this.Bounds);
ControlPaint.DrawFocusRectangle( e.Graphics, this.PaddingBounds); } // This glyph's Bounds property is a
Rectangle defined by // the value of the control's Margin property. public override Rectangle Bounds { get {
Control c = this.relatedControl; Rectangle controlRect =
Rectangle( controlRect.Left - c.Margin.Left, controlRect.Top - c.Margin.Top, controlRect.Width +
c.Margin.Right*2, controlRect.Height + c.Margin.Bottom*2); return boundsVal; } } // The PaddingBounds
property is a Rectangle defined by // the value of the control's Padding property. public Rectangle
PaddingBounds { get { Control c = this.relatedControl; Rectangle controlRect =

Rectangle( controlRect.Left + c.Padding.Left, controlRect.Top + c.Padding.Top, controlRect.Width -
c.Padding.Right * 2, controlRect.Height - c.Padding.Bottom * 2); return boundsVal; } } // There are no
keyboard or mouse behaviors associated with // this glyph, but you could add them to this class. internal
class MarginAndPaddingBehavior : Behavior { } }
Estender o comportamento
Você estender o comportamento do seu projeto personalizado UI, implementar uma Behavior
classe. A Behavior classe é subordinado à Glyph Classe.
Cuidado
O ambiente de desenvolvimento não permite Behavior objetos que não estão conectados a um
Glyph objeto.
Você anexar um Behavior objeto a um Glyph objeto no construtor seu Glyph do tipo.
O exemplo de código a seguir mostra como implementar o AnchorGlyph Construtor.
C#
public AnchorGlyph( AnchorStyles anchorStyle, BehaviorService behaviorService,
Adorner anchorAdorner) : base(new AnchorBehavior(relatedDesigner)) { // Cache references for
convenience. this.anchorStyle = anchorStyle; this.behaviorService = behaviorService; this.changeService =
changeService; this.selectionService = selectionService; this.relatedDesigner = relatedDesigner;
this.anchorAdorner = anchorAdorner; // Cache a reference to the control being designed. this.relatedControl
= this.relatedDesigner.Component as Control; // Hook the SelectionChanged event.
ComponentChangedEventHandler(changeService_ComponentChanged); }
A AnchorGlyph classe pinta alças de seleção que correspondem ao valor da propriedade do

controle Anchor. Você substituir o GetHitTest método para retornar um Cursor objeto quando o
ponteiro do mouse está sobre o glifo o ponto de acesso. Quando o ambiente de desenvolvimento
recebe um valor do GetHitTest método que não null estiver, ele ativa o Behavior objeto
associado com o Glyph.
O exemplo de código a seguir mostra como implementar a AnchorGlyph classe.
C#
// This class implements an AnchorGlyph, which draws grab handles // that represent the value of the
control's Anchor property. // // This glyph has mouse and keyboard interactions, which are // handled by
the related behavior class, AnchorBehavior. // Double-clicking on an AnchorGlyph causes its value to be //
toggled between enabled and disable states. public class AnchorGlyph : Glyph { // This defines the bounds of
the anchor glyph. protected Rectangle boundsValue; // This defines the bounds used for hit testing. // These
bounds are typically different than the bounds // of the glyph itself. protected Rectangle hitBoundsValue; //

This is the cursor returned if hit test is positive. protected Cursor hitTestCursor = Cursors.Hand; // Cache
references to services that will be needed. private BehaviorService behaviorService = null; private
IComponentChangeService changeService = null; private ISelectionService selectionService = null; // Keep a
reference to the designer for convenience. private IDesigner relatedDesigner = null; // Keep a reference to
the adorner for convenience. private Adorner anchorAdorner = null; // Keep a reference to the control being
designed. private Control relatedControl = null; // This defines the AnchorStyle which this glyph represents.
private AnchorStyles anchorStyle; public AnchorGlyph( AnchorStyles anchorStyle, BehaviorService
behaviorService, IComponentChangeService changeService, ISelectionService selectionService, IDesigner
relatedDesigner, Adorner anchorAdorner) : base(new AnchorBehavior(relatedDesigner)) { // Cache
references for convenience. this.anchorStyle = anchorStyle; this.behaviorService = behaviorService;
this.changeService = changeService; this.selectionService = selectionService; this.relatedDesigner =
relatedDesigner; this.anchorAdorner = anchorAdorner; // Cache a reference to the control being designed.
this.relatedControl = this.relatedDesigner.Component as Control; // Hook the SelectionChanged event.
ComponentChangedEventHandler(changeService_ComponentChanged); } #region Overrides public
override Rectangle Bounds { get { return this.boundsValue; } } // This method renders the AnchorGlyph as a
filled rectangle // if the glyph is enabled, or as an open rectangle if the // glyph is disabled. public override
void Paint(PaintEventArgs e) { if (this.IsEnabled) { using (Brush b = new SolidBrush(Color.Tomato)) {
e.Graphics.FillRectangle(b, this.Bounds); } } else { using (Pen p = new Pen(Color.Tomato)) {
e.Graphics.DrawRectangle(p, this.Bounds); } } } // An AnchorGlyph has keyboard and mouse interaction, so
it's // important to return a cursor when the mouse is located in // the glyph's hit region. When this occurs,
the // AnchorBehavior becomes active. public override Cursor GetHitTest(Point p) { if
(hitBoundsValue.Contains(p)) { return hitTestCursor; } return null; } #endregion #region Event Handlers //
The AnchorGlyph objects should mimic the resize glyphs; // they should only be visible when the control is
the // primary selection. The adorner is enabled when the // control is the primary selection and disabled
when // it is not. void selectionService_SelectionChanged(object sender, EventArgs e) { if
(object.ReferenceEquals( this.selectionService.PrimarySelection, this.relatedControl)) {
this.ComputeBounds(); this.anchorAdorner.Enabled = true; } else { this.anchorAdorner.Enabled = false; } }
// If any of several properties change, the bounds of the // AnchorGlyph must be computed again. void
changeService_ComponentChanged( object sender, ComponentChangedEventArgs e) { if
(object.ReferenceEquals( e.Component, this.relatedControl)) { if (e.Member.Name == "Anchor" ||
e.Member.Name == "Size" || e.Member.Name == "Height" || e.Member.Name == "Width" ||
e.Member.Name == "Location") { // Compute the bounds of this glyph. this.ComputeBounds(); // Tell the
adorner to repaint itself. this.anchorAdorner.Invalidate(); } } } #endregion #region Implementation // This
utility method computes the position and size of // the AnchorGlyph in the Adorner window's coordinates. //
It also computes the hit test bounds, which are // slightly larger than the glyph's bounds. private void
ComputeBounds() { Rectangle translatedBounds = new Rectangle(
this.behaviorService.ControlToAdornerWindow(this.relatedControl), this.relatedControl.Size); if
((this.anchorStyle & AnchorStyles.Top) == AnchorStyles.Top) { this.boundsValue = new Rectangle(
translatedBounds.X + (translatedBounds.Width / 2) - (glyphSize / 2), translatedBounds.Y + glyphSize,
glyphSize, glyphSize); } if ((this.anchorStyle & AnchorStyles.Bottom) == AnchorStyles.Bottom) {
this.boundsValue = new Rectangle( translatedBounds.X + (translatedBounds.Width / 2) - (glyphSize / 2),
translatedBounds.Bottom - 2*glyphSize, glyphSize, glyphSize); } if ((this.anchorStyle & AnchorStyles.Left)
== AnchorStyles.Left) { this.boundsValue = new Rectangle( translatedBounds.X + glyphSize,

translatedBounds.Y + (translatedBounds.Height / 2) - (glyphSize / 2), glyphSize, glyphSize); } if
((this.anchorStyle & AnchorStyles.Right) == AnchorStyles.Right) { this.boundsValue = new Rectangle(
translatedBounds.Right - 2*glyphSize, translatedBounds.Y + (translatedBounds.Height / 2) - (glyphSize / 2),
glyphSize, glyphSize); } this.hitBoundsValue = new Rectangle( this.Bounds.Left - hitBoundSize / 2,
this.Bounds.Top - hitBoundSize / 2, hitBoundSize, hitBoundSize ); } // This utility property determines if the
AnchorGlyph is // enabled, according to the value specified by the // control's Anchor property. private bool
IsEnabled { get { return ((this.anchorStyle & this.relatedControl.Anchor) == this.anchorStyle); } }
#endregion
A AnchorBehavior classe implementa a interação de mouse personalizado. Você substituir

Behavior métodos de classe como OnMouseEnter Para definir a UI personalizado.
O exemplo de código a seguir mostra como implementar a AnchorBehavior classe.
C#
// This Behavior specifies mouse and keyboard handling when // an AnchorGlyph is active. This happens
when // AnchorGlyph.GetHitTest returns a non-null value. internal class AnchorBehavior : Behavior {
private IDesigner relatedDesigner = null; private Control relatedControl = null; internal
AnchorBehavior(IDesigner relatedDesigner) { this.relatedDesigner = relatedDesigner; this.relatedControl =
relatedDesigner.Component as Control; } // When you double-click on an AnchorGlyph, the value of // the
control's Anchor property is toggled. // // Note that the value of the Anchor property is not set // by direct
assignment. Instead, the // PropertyDescriptor.SetValue method is used. This // enables notification of the
design environment, so // related events can be raised, for example, the //
IComponentChangeService.ComponentChanged event. public override bool OnMouseDoubleClick( Glyph g,
MouseButtons button, Point mouseLoc) { base.OnMouseDoubleClick(g, button, mouseLoc); if (button ==
MouseButtons.Left) { AnchorGlyph ag = g as AnchorGlyph; PropertyDescriptor pdAnchor =
TypeDescriptor.GetProperties(ag.relatedControl)["Anchor"]; if (ag.IsEnabled) { // The glyph is enabled. //
Clear the AnchorStyle flag to disable the Glyph. pdAnchor.SetValue( ag.relatedControl,
ag.relatedControl.Anchor ^ ag.anchorStyle ); } else { // The glyph is disabled. // Set the AnchorStyle flag to
enable the Glyph. pdAnchor.SetValue( ag.relatedControl, ag.relatedControl.Anchor | ag.anchorStyle); } }
return true; } }
Ativar A interface do usuário em tempo de criação
Ativar o glifos, criando uma Adorner janela e adicioná-los para a Glyphs coleção. Ativar a UI
Design-time personalizada adicionando a Adorner janela à coleção Adorners da BehaviorService.
Executar essas ações no método seu designer Initialize.
O exemplo de código a seguir mostra como ativar a interface Design-time.
C#
// This method is where the designer initializes its state when // it is created. public override void
InitializeServices(); // Initialize adorners. this.InitializeMarginAndPaddingAdorner();
this.InitializeAnchorAdorner(); }
C#

// This utility method creates an adorner for the anchor glyphs. // It then creates four AnchorGlyph objects
and adds them to // the adorner's Glyphs collection. private void InitializeAnchorAdorner() {
this.anchorAdorner = new Adorner(); this.behaviorSvc.Adorners.Add(this.anchorAdorner);
this.anchorAdorner.Glyphs.Add(new AnchorGlyph( AnchorStyles.Left, this.behaviorSvc, this.changeService,
this.selectionService, this, this.anchorAdorner) ); this.anchorAdorner.Glyphs.Add(new AnchorGlyph(
AnchorStyles.Top, this.behaviorSvc, this.changeService, this.selectionService, this, this.anchorAdorner) );
this.anchorAdorner.Glyphs.Add(new AnchorGlyph( AnchorStyles.Right, this.behaviorSvc,
this.changeService, this.selectionService, this, this.anchorAdorner) ); this.anchorAdorner.Glyphs.Add(new
AnchorGlyph( AnchorStyles.Bottom, this.behaviorSvc, this.changeService, this.selectionService, this,
this.anchorAdorner) ); }
C#
// This utility method creates an adorner for the margin and // padding glyphs. It then creates a
MarginAndPaddingGlyph and // adds it to the adorner's Glyphs collection. private void
InitializeMarginAndPaddingAdorner() { this.marginAndPaddingAdorner = new Adorner();
this.behaviorSvc.Adorners.Add(this.marginAndPaddingAdorner);
this.marginAndPaddingAdorner.Glyphs.Add(new MarginAndPaddingGlyph( this.behaviorSvc,
this.changeService, this.selectionService, this, this.marginAndPaddingAdorner)); }
componente.
COMO: Criar um controle de formulários do Windows que tira

vantagem de recursos em tempo de criação
O exemplo a seguir ilustra como criar um controle personalizado e um designer personalizado
associado. Quando essa biblioteca é criada, você pode criar implementações personalizadas
MarqueeControl que executados em um formulário.
Há suporte para esta tarefa no Visual Studio abrangente.
Exemplo
C#
using System; namespace MarqueeControlLibrary { // This interface defines the contract for any class that is
to // be used in constructing a MarqueeControl. public interface IMarqueeWidget { // This method starts the
animation. If the control can // contain other classes that implement IMarqueeWidget as // children, the
control should call StartMarquee on all // its IMarqueeWidget child controls. void StartMarquee(); // This
method stops the animation. If the control can // contain other classes that implement IMarqueeWidget as
// children, the control should call StopMarquee on all // its IMarqueeWidget child controls. void
StopMarquee(); // This method specifies the refresh rate for the animation, // in milliseconds. int
UpdatePeriod { get; set; } } }
C#

using System; using System.ComponentModel; using System.ComponentModel.Design; using
System.Diagnostics; using System.Drawing; using System.Drawing.Design; using System.Threading; using
System.Windows.Forms; using System.Windows.Forms.Design; namespace MarqueeControlLibrary { //
This defines the possible values for the MarqueeBorder // control's SpinDirection property. public enum
MarqueeSpinDirection { CW, CCW } // This defines the possible values for the MarqueeBorder // control's
LightShape property. public enum MarqueeLightShape { Square, Circle }
[Designer(typeof(MarqueeControlLibrary.Design.MarqueeBorderDesigner ))]
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)] public class
MarqueeBorder : Panel, IMarqueeWidget { public static int MaxLightSize = 10; // These fields back the
public properties. private int updatePeriodValue = 50; private int lightSizeValue = 5; private int
lightPeriodValue = 3; private int lightSpacingValue = 1; private Color lightColorValue; private Color
darkColorValue; private MarqueeSpinDirection spinDirectionValue = MarqueeSpinDirection.CW; private
MarqueeLightShape lightShapeValue = MarqueeLightShape.Square; // These brushes are used to paint the
light and dark // colors of the marquee lights. private Brush lightBrush; private Brush darkBrush; // This
field tracks the progress of the "first" light as it // "travels" around the marquee border. private int
currentOffset = 0; // This component updates the control asynchronously. private
System.ComponentModel.BackgroundWorker backgroundWorker1; public MarqueeBorder() { // This call is
required by the Windows.Forms Form Designer. InitializeComponent(); // Initialize light and dark colors //
to the control's default values. this.lightColorValue = this.ForeColor; this.darkColorValue = this.BackColor;
this.lightBrush = new SolidBrush(this.lightColorValue); this.darkBrush = new
SolidBrush(this.darkColorValue); // The MarqueeBorder control manages its own padding, // because it
requires that any contained controls do // not overlap any of the marquee lights. int pad = 2 *
(this.lightSizeValue + this.lightSpacingValue); this.Padding = new Padding(pad, pad, pad, pad);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true); }
/////////////////////////////////////////////////////////////////////// #region IMarqueeWidget
implementation public virtual void StartMarquee() { // The MarqueeBorder control may contain any number
of // controls that implement IMarqueeWidget, so find // each IMarqueeWidget child and call its
StartMarquee // method. foreach (Control cntrl in this.Controls) { if (cntrl is IMarqueeWidget) {
IMarqueeWidget widget = cntrl as IMarqueeWidget; widget.StartMarquee(); } } // Start the updating thread
and pass it the UpdatePeriod. this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod); } public
virtual void StopMarquee() { // The MarqueeBorder control may contain any number of // controls that
implement IMarqueeWidget, so find // each IMarqueeWidget child and call its StopMarquee // method.
foreach (Control cntrl in this.Controls) { if (cntrl is IMarqueeWidget) { IMarqueeWidget widget = cntrl as
IMarqueeWidget; widget.StopMarquee(); } } // Stop the updating thread.
this.backgroundWorker1.CancelAsync(); } [Category("Marquee")] [Browsable(true)] public virtual int
UpdatePeriod { get { return this.updatePeriodValue; } set { if (value > 0) { this.updatePeriodValue = value; }
else { throw new ArgumentOutOfRangeException("UpdatePeriod", "must be > 0"); } } } #endregion
/////////////////////////////////////////////////////////////////////// #region Public Properties
[Category("Marquee")] [Browsable(true)] public int LightSize { get { return this.lightSizeValue; } set { if
(value > 0 && value <= MaxLightSize) { this.lightSizeValue = value; this.DockPadding.All = 2 * value; } else {
throw new ArgumentOutOfRangeException("LightSize", "must be > 0 and < MaxLightSize"); } } }
[Category("Marquee")] [Browsable(true)] public int LightPeriod { get { return this.lightPeriodValue; } set { if
(value > 0) { this.lightPeriodValue = value; } else { throw new
ArgumentOutOfRangeException("LightPeriod", "must be > 0 "); } } } [Category("Marquee")]
[Browsable(true)] public Color LightColor { get { return this.lightColorValue; } set { // The LightColor
property is only changed if the // client provides a different value. Comparing values // from the ToArgb

method is the recommended test for // equality between Color structs. if (this.lightColorValue.ToArgb() !=
value.ToArgb()) { this.lightColorValue = value; this.lightBrush = new SolidBrush(value); } } }
[Category("Marquee")] [Browsable(true)] public Color DarkColor { get { return this.darkColorValue; } set {
// The DarkColor property is only changed if the // client provides a different value. Comparing values //
from the ToArgb method is the recommended test for // equality between Color structs. if
(this.darkColorValue.ToArgb() != value.ToArgb()) { this.darkColorValue = value; this.darkBrush = new
SolidBrush(value); } } } [Category("Marquee")] [Browsable(true)] public int LightSpacing { get { return
this.lightSpacingValue; } set { if (value >= 0) { this.lightSpacingValue = value; } else { throw new
ArgumentOutOfRangeException("LightSpacing", "must be >= 0"); } } } [Category("Marquee")]
[Browsable(true)] [EditorAttribute(typeof(LightShapeEditor),
typeof(System.Drawing.Design.UITypeEditor))] public MarqueeLightShape LightShape { get { return
this.lightShapeValue; } set { this.lightShapeValue = value; } } [Category("Marquee")] [Browsable(true)]
public MarqueeSpinDirection SpinDirection { get { return this.spinDirectionValue; } set {
this.spinDirectionValue = value; } } #endregion
/////////////////////////////////////////////////////////////////////// #region Implementation
protected override void OnLayout(LayoutEventArgs levent) { base.OnLayout(levent); // Repaint when the
layout has changed. this.Refresh(); } // This method paints the lights around the border of the // control. It
paints the top row first, followed by the // right side, the bottom row, and the left side. The color // of each
light is determined by the IsLit method and // depends on the light's position relative to the value // of
currentOffset. protected override void OnPaint(PaintEventArgs e) { Graphics g = e.Graphics;
g.Clear(this.BackColor); base.OnPaint(e); // If the control is large enough, draw some lights. if (this.Width >
MaxLightSize && this.Height > MaxLightSize) { // The position of the next light will be incremented // by
this value, which is equal to the sum of the // light size and the space between two lights. int increment =
this.lightSizeValue + this.lightSpacingValue; // Compute the number of lights to be drawn along the //
horizontal edges of the control. int horizontalLights = (this.Width - increment) / increment; // Compute the
number of lights to be drawn along the // vertical edges of the control. int verticalLights = (this.Height -
increment) / increment; // These local variables will be used to position and // paint each light. int xPos = 0;
int yPos = 0; int lightCounter = 0; Brush brush; // Draw the top row of lights. for (int i = 0; i <
horizontalLights; i++) { brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush; DrawLight(g, brush,
xPos, yPos); xPos += increment; lightCounter++; } // Draw the lights flush with the right edge of the control.
xPos = this.Width - this.lightSizeValue; // Draw the right column of lights. for (int i = 0; i < verticalLights;
i++) { brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush; DrawLight(g, brush, xPos, yPos); yPos
+= increment; lightCounter++; } // Draw the lights flush with the bottom edge of the control. yPos =
this.Height - this.lightSizeValue; // Draw the bottom row of lights. for (int i = 0; i < horizontalLights; i++) {
brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush; DrawLight(g, brush, xPos, yPos); xPos -=
increment; lightCounter++; } // Draw the lights flush with the left edge of the control. xPos = 0; // Draw the
left column of lights. for (int i = 0; i < verticalLights; i++) { brush = IsLit(lightCounter) ? this.lightBrush :
this.darkBrush; DrawLight(g, brush, xPos, yPos); yPos -= increment; lightCounter++; } } } // This method
determines if the marquee light at lightIndex // should be lit. The currentOffset field specifies where // the
"first" light is located, and the "position" of the // light given by lightIndex is computed relative to this //
offset. If this position modulo lightPeriodValue is zero, // the light is considered to be on, and it will be
painted // with the control's lightBrush. protected virtual bool IsLit(int lightIndex) { int directionFactor =
(this.spinDirectionValue == MarqueeSpinDirection.CW ? -1 : 1); return ( (lightIndex + directionFactor *
this.currentOffset) % this.lightPeriodValue == 0 ); } protected virtual void DrawLight( Graphics g, Brush
brush, int xPos, int yPos) { switch (this.lightShapeValue) { case MarqueeLightShape.Square: {
g.FillRectangle(brush, xPos, yPos, this.lightSizeValue, this.lightSizeValue); break; } case

MarqueeLightShape.Circle: { g.FillEllipse(brush, xPos, yPos, this.lightSizeValue, this.lightSizeValue); break;
} default: { Trace.Assert(false, "Unknown value for light shape."); break; } } } // This method is called in the
worker thread's context, // so it must not make any calls into the MarqueeBorder // control. Instead, it
communicates to the control using // the ProgressChanged event. // // The only work done in this event
handler is // to sleep for the number of milliseconds specified // by UpdatePeriod, then raise the
ProgressChanged event. private void backgroundWorker1_DoWork(object sender,
System.ComponentModel.DoWorkEventArgs e) { BackgroundWorker worker = sender as
BackgroundWorker; // This event handler will run until the client cancels // the background task by calling
CancelAsync. while (!worker.CancellationPending) { // The Argument property of the DoWorkEventArgs //
object holds the value of UpdatePeriod, which // was passed as the argument to the RunWorkerAsync //
method. Thread.Sleep((int)e.Argument); // The DoWork eventhandler does not actually report // progress;
the ReportProgress event is used to // periodically alert the control to update its state.
worker.ReportProgress(0); } } // The ProgressChanged event is raised by the DoWork method. // This event
handler does work that is internal to the // control. In this case, the currentOffset is incremented, // and the
control is told to repaint itself. private void backgroundWorker1_ProgressChanged( object sender,
System.ComponentModel.ProgressChangedEventArgs e) { this.currentOffset++; this.Refresh(); } // This
class demonstrates the use of a custom UITypeEditor. // It allows the MarqueeBorder control's LightShape
property // to be changed at design time using a customized UI element // that is invoked by the Properties
window. The UI is provided // by the LightShapeSelectionControl class. internal class LightShapeEditor :
UITypeEditor { private IWindowsFormsEditorService editorService = null; public override
UITypeEditorEditStyle GetEditStyle( System.ComponentModel.ITypeDescriptorContext context) { return
UITypeEditorEditStyle.DropDown; } public override object EditValue( ITypeDescriptorContext context,
IServiceProvider provider, object value) { if (provider != null) { editorService = provider.GetService(
typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; } if (editorService != null) {
LightShapeSelectionControl selectionControl = new LightShapeSelectionControl(
(MarqueeLightShape)value, editorService); editorService.DropDownControl(selectionControl); value =
selectionControl.LightShape; } return value; } // This method indicates to the design environment that // the
type editor will paint additional content in the // LightShape entry in the PropertyGrid. public override bool
GetPaintValueSupported( ITypeDescriptorContext context) { return true; } // This method paints a graphical
representation of the // selected value of the LightShpae property. public override void
PaintValue(PaintValueEventArgs e) { MarqueeLightShape shape = (MarqueeLightShape)e.Value; using (Pen
p = Pens.Black) { if (shape == MarqueeLightShape.Square) { e.Graphics.DrawRectangle(p, e.Bounds); } else
{ e.Graphics.DrawEllipse(p, e.Bounds); } } } } private void InitializeComponent() { this.backgroundWorker1
= new System.ComponentModel.BackgroundWorker(); // // backgroundWorker1 //
this.backgroundWorker1.WorkerReportsProgress = true;
this.backgroundWorker1.WorkerSupportsCancellation = true; this.backgroundWorker1.ProgressChanged +=
new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged);
this.backgroundWorker1.DoWork += new
System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); } #endregion } }
C#
using System; using System.ComponentModel; using System.ComponentModel.Design; using
System.Diagnostics; using System.Drawing; using System.Threading; using System.Windows.Forms; using
System.Windows.Forms.Design; namespace MarqueeControlLibrary {
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)] public class
MarqueeText : Label, IMarqueeWidget { // When isLit is true, the text is painted in the light color; // When

isLit is false, the text is painted in the dark color. // This value changes whenever the BackgroundWorker
component // raises the ProgressChanged event. private bool isLit = true; // These fields back the public
properties. private int updatePeriodValue = 50; private Color lightColorValue; private Color darkColorValue;
// These brushes are used to paint the light and dark // colors of the text. private Brush lightBrush; private
Brush darkBrush; // This component updates the control asynchronously. private BackgroundWorker
backgroundWorker1; public MarqueeText() { // This call is required by the Windows.Forms Form Designer.
InitializeComponent(); // Initialize light and dark colors // to the control's default values.
this.lightColorValue = this.ForeColor; this.darkColorValue = this.BackColor; this.lightBrush = new
SolidBrush(this.lightColorValue); this.darkBrush = new SolidBrush(this.darkColorValue); }
/////////////////////////////////////////////////////////////////////// #region IMarqueeWidget
implementation public virtual void StartMarquee() { // Start the updating thread and pass it the
UpdatePeriod. this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod); } public virtual void
StopMarquee() { // Stop the updating thread. this.backgroundWorker1.CancelAsync(); }
[Category("Marquee")] [Browsable(true)] public int UpdatePeriod { get { return this.updatePeriodValue; }
set { if (value > 0) { this.updatePeriodValue = value; } else { throw new
ArgumentOutOfRangeException("UpdatePeriod", "must be > 0"); } } } #endregion
/////////////////////////////////////////////////////////////////////// #region Public Properties
[Category("Marquee")] [Browsable(true)] public Color LightColor { get { return this.lightColorValue; } set {
// The LightColor property is only changed if the // client provides a different value. Comparing values //
from the ToArgb method is the recommended test for // equality between Color structs. if
(this.lightColorValue.ToArgb() != value.ToArgb()) { this.lightColorValue = value; this.lightBrush = new
SolidBrush(value); } } } [Category("Marquee")] [Browsable(true)] public Color DarkColor { get { return
this.darkColorValue; } set { // The DarkColor property is only changed if the // client provides a different
value. Comparing values // from the ToArgb method is the recommended test for // equality between Color
structs. if (this.darkColorValue.ToArgb() != value.ToArgb()) { this.darkColorValue = value; this.darkBrush =
new SolidBrush(value); } } } #endregion
/////////////////////////////////////////////////////////////////////// #region Implementation
protected override void OnPaint(PaintEventArgs e) { // The text is painted in the light or dark color, //
depending on the current value of isLit. this.ForeColor = this.isLit ? this.lightColorValue :
this.darkColorValue; base.OnPaint(e); } // This method is called in the worker thread's context, // so it must
not make any calls into the MarqueeText control. // Instead, it communicates to the control using the //
ProgressChanged event. // // The only work done in this event handler is // to sleep for the number of
milliseconds specified // by UpdatePeriod, then raise the ProgressChanged event. private void
backgroundWorker1_DoWork( object sender, System.ComponentModel.DoWorkEventArgs e) {
BackgroundWorker worker = sender as BackgroundWorker; // This event handler will run until the client
cancels // the background task by calling CancelAsync. while (!worker.CancellationPending) { // The
Argument property of the DoWorkEventArgs // object holds the value of UpdatePeriod, which // was passed
as the argument to the RunWorkerAsync // method. Thread.Sleep((int)e.Argument); // The DoWork
eventhandler does not actually report // progress; the ReportProgress event is used to // periodically alert
the control to update its state. worker.ReportProgress(0); } } // The ProgressChanged event is raised by the
DoWork method. // This event handler does work that is internal to the // control. In this case, the text is
toggled between its // light and dark state, and the control is told to // repaint itself. private void
backgroundWorker1_ProgressChanged(object sender,
System.ComponentModel.ProgressChangedEventArgs e) { this.isLit = !this.isLit; this.Refresh(); } private
void InitializeComponent() { this.backgroundWorker1 = new
System.ComponentModel.BackgroundWorker(); // // backgroundWorker1 //

this.backgroundWorker1.WorkerReportsProgress = true;
this.backgroundWorker1.WorkerSupportsCancellation = true; this.backgroundWorker1.ProgressChanged +=
new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged);
this.backgroundWorker1.DoWork += new
System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); } #endregion } }
C#
System.ComponentModel.Design; using System.Drawing; using System.Windows.Forms; using
System.Windows.Forms.Design; namespace MarqueeControlLibrary { [Designer( typeof(
MarqueeControlLibrary.Design.MarqueeControlRootDesigner ), typeof( IRootDesigner ) )] public class
MarqueeControl : UserControl { // Required designer variable. private System.ComponentModel.Container
components = null; public MarqueeControl() { // This call is required by the Windows.Forms Form
Designer. InitializeComponent(); // Minimize flickering during animation by enabling // double buffering.
SetStyle(ControlStyles.OptimizedDoubleBuffer, true); } /// <summary> /// Clean up any resources being
used. /// </summary> protected override void Dispose( bool disposing ) { if( disposing ) { if(components !=
null) { components.Dispose(); } } base.Dispose( disposing ); } public void Start() { // The MarqueeControl
may contain any number of // controls that implement IMarqueeWidget, so // find each IMarqueeWidget
child and call its // StartMarquee method. foreach( Control cntrl in this.Controls ) { if( cntrl is
IMarqueeWidget ) { IMarqueeWidget widget = cntrl as IMarqueeWidget; widget.StartMarquee(); } } } public
void Stop() { // The MarqueeControl may contain any number of // controls that implement
IMarqueeWidget, so find // each IMarqueeWidget child and call its StopMarquee // method. foreach(
Control cntrl in this.Controls ) { if( cntrl is IMarqueeWidget ) { IMarqueeWidget widget = cntrl as
IMarqueeWidget; widget.StopMarquee(); } } } protected override void OnLayout(LayoutEventArgs levent) {
base.OnLayout (levent); // Repaint all IMarqueeWidget children if the layout // has changed. foreach(
Control cntrl in this.Controls ) { if( cntrl is IMarqueeWidget ) { Control control = cntrl as Control;
control.PerformLayout(); } } } #region Component Designer generated code /// <summary> /// Required
method for Designer support - do not modify /// the contents of this method with the code editor. ///
</summary> private void InitializeComponent() { components = new
System.ComponentModel.Container(); } #endregion } }
C#
using System; using System.Collections; using System.ComponentModel; using System.Drawing; using
System.Windows.Forms; using System.Windows.Forms.Design; namespace MarqueeControlLibrary { //
This control provides the custom UI for the LightShape property // of the MarqueeBorder. It is used by the
LightShapeEditor. public class LightShapeSelectionControl : System.Windows.Forms.UserControl { private
MarqueeLightShape lightShapeValue = MarqueeLightShape.Square; private IWindowsFormsEditorService
editorService = null; private System.Windows.Forms.Panel squarePanel; private
System.Windows.Forms.Panel circlePanel; // Required designer variable. private
System.ComponentModel.Container components = null; // This constructor takes a MarqueeLightShape
value from the // design-time environment, which will be used to display // the initial state. public
LightShapeSelectionControl( MarqueeLightShape lightShape, IWindowsFormsEditorService editorService )
{ // This call is required by the designer. InitializeComponent(); // Cache the light shape value provided by
the // design-time environment. this.lightShapeValue = lightShape; // Cache the reference to the editor
service. this.editorService = editorService; // Handle the Click event for the two panels.
this.squarePanel.Click += new EventHandler(squarePanel_Click); this.circlePanel.Click += new

EventHandler(circlePanel_Click); } protected override void Dispose( bool disposing ) { if( disposing ) { // Be
sure to unhook event handlers // to prevent "lapsed listener" leaks. this.squarePanel.Click -= new
EventHandler(squarePanel_Click); this.circlePanel.Click -= new EventHandler(circlePanel_Click);
if(components != null) { components.Dispose(); } } base.Dispose( disposing ); } // LightShape is the property
for which this control provides // a custom user interface in the Properties window. public
MarqueeLightShape LightShape { get { return this.lightShapeValue; } set { if( this.lightShapeValue != value )
{ this.lightShapeValue = value; } } } protected override void OnPaint(PaintEventArgs e) { base.OnPaint (e);
using( Graphics gSquare = this.squarePanel.CreateGraphics(), gCircle = this.circlePanel.CreateGraphics() ) {
// Draw a filled square in the client area of // the squarePanel control. gSquare.FillRectangle( Brushes.Red,
0, 0, this.squarePanel.Width, this.squarePanel.Height ); // If the Square option has been selected, draw a //
border inside the squarePanel. if( this.lightShapeValue == MarqueeLightShape.Square ) {
gSquare.DrawRectangle( Pens.Black, 0, 0, this.squarePanel.Width-1, this.squarePanel.Height-1); } // Draw a
filled circle in the client area of // the circlePanel control. gCircle.Clear( this.circlePanel.BackColor );
gCircle.FillEllipse( Brushes.Blue, 0, 0, this.circlePanel.Width, this.circlePanel.Height ); // If the Circle option
has been selected, draw a // border inside the circlePanel. if( this.lightShapeValue ==
MarqueeLightShape.Circle ) { gCircle.DrawRectangle( Pens.Black, 0, 0, this.circlePanel.Width-1,
this.circlePanel.Height-1); } } } private void squarePanel_Click(object sender, EventArgs e) {
this.lightShapeValue = MarqueeLightShape.Square; this.Invalidate( false );
this.editorService.CloseDropDown(); } private void circlePanel_Click(object sender, EventArgs e) {
this.lightShapeValue = MarqueeLightShape.Circle; this.Invalidate( false );
this.editorService.CloseDropDown(); } #region Component Designer generated code /// <summary> ///
Required method for Designer support - do not modify /// the contents of this method with the code editor.
/// </summary> private void InitializeComponent() { this.squarePanel = new
System.Windows.Forms.Panel(); this.circlePanel = new System.Windows.Forms.Panel();
this.SuspendLayout(); // // squarePanel // this.squarePanel.Location = new System.Drawing.Point(8, 10);
this.squarePanel.Name = "squarePanel"; this.squarePanel.Size = new System.Drawing.Size(60, 60);
this.squarePanel.TabIndex = 2; // // circlePanel // this.circlePanel.Location = new
System.Drawing.Point(80, 10); this.circlePanel.Name = "circlePanel"; this.circlePanel.Size = new
System.Drawing.Size(60, 60); this.circlePanel.TabIndex = 3; // // LightShapeSelectionControl //
this.Controls.Add(this.squarePanel); this.Controls.Add(this.circlePanel); this.Name =
"LightShapeSelectionControl"; this.Size = new System.Drawing.Size(150, 80); this.ResumeLayout(false); }
#endregion } }
C#
System.ComponentModel.Design; using System.Diagnostics; using System.Windows.Forms; using
System.Windows.Forms.Design; namespace MarqueeControlLibrary.Design {
"FullTrust")] public class MarqueeBorderDesigner : ParentControlDesigner { public
MarqueeBorderDesigner() { Trace.WriteLine("MarqueeBorderDesigner"); } public bool Visible { get { return
(bool)ShadowProperties["Visible"]; } set { this.ShadowProperties["Visible"] = value; } } public bool Enabled {
get { return (bool)ShadowProperties["Enabled"]; } set { this.ShadowProperties["Enabled"] = value; } }
protected override void PreFilterProperties(IDictionary properties) { base.PreFilterProperties(properties); if
(properties.Contains("Padding")) { properties.Remove("Padding"); } properties["Visible"] =
TypeDescriptor.CreateProperty( typeof(MarqueeBorderDesigner), (PropertyDescriptor)properties["Visible"],
new Attribute[0]); properties["Enabled"] = TypeDescriptor.CreateProperty(

typeof(MarqueeBorderDesigner), (PropertyDescriptor)properties["Enabled"], new Attribute[0]); } private
void OnVerbRunTest(object sender, EventArgs e) { IMarqueeWidget widget = this.Control as
IMarqueeWidget; widget.StartMarquee(); } private void OnVerbStopTest(object sender, EventArgs e) {
IMarqueeWidget widget = this.Control as IMarqueeWidget; widget.StopMarquee(); } } }
C#
System.ComponentModel.Design; using System.Diagnostics; using System.Drawing.Design; using
System.Windows.Forms; using System.Windows.Forms.Design; namespace MarqueeControlLibrary.Design
{ [ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]
"FullTrust")] public class MarqueeControlRootDesigner : DocumentDesigner { public
MarqueeControlRootDesigner() { Trace.WriteLine("MarqueeControlRootDesigner ctor"); } public override
void Initialize(IComponent component) { base.Initialize(component); IComponentChangeService cs =
GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (cs != null) {
cs.ComponentChanged += new ComponentChangedEventHandler(OnComponentChanged); }
this.Verbs.Add( new DesignerVerb("Run Test", new EventHandler(OnVerbRunTest)) ); this.Verbs.Add( new
DesignerVerb("Stop Test", new EventHandler(OnVerbStopTest)) ); } private void OnComponentChanged(
object sender, ComponentChangedEventArgs e) { if (e.Component is IMarqueeWidget) {
this.Control.Refresh(); } } private void OnVerbRunTest(object sender, EventArgs e) { MarqueeControl c =
this.Control as MarqueeControl; c.Start(); } private void OnVerbStopTest(object sender, EventArgs e) {
MarqueeControl c = this.Control as MarqueeControl; c.Stop(); } } }
COMO: Anexar marcas inteligentes para um componente de

formulários do Windows
Este exemplo mostra como adicionar suporte a marcas inteligentes para componentes e controles
personalizados.
Para obter uma explicação sobre neste exemplo, de código completa Consulte Passo-a-passo:
Adicionando Marcas Inteligentes a um Componente do Windows Forms.
Exemplo
C#
///////////////////////////////////////////////////////////////////// // Pull model smart tag example.
// Need references to System.dll, System.Windows.Forms.dll, // System.Design.dll, and System.Drawing.dll.
///////////////////////////////////////////////////////////////////// using System; using
System.Drawing; using System.Collections; using System.ComponentModel; using
System.ComponentModel.Design; using System.Windows.Forms; using System.Text; using
System.Reflection; namespace SmartTags { public class Form1 : System.Windows.Forms.Form { private
ColorLabel colorLabel2; public Form1() { InitializeComponent(); } // VS Forms Designer generated method
private void InitializeComponent() { this.colorLabel2 = new SmartTags.ColorLabel(); this.SuspendLayout();
// // colorLabel2 // this.colorLabel2.BackColor = System.Drawing.Color.Gold; this.colorLabel2.ColorLocked
= false; this.colorLabel2.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Bold,
System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.colorLabel2.Location = new

System.Drawing.Point(41, 42); this.colorLabel2.Name = "colorLabel2"; this.colorLabel2.Size = new
System.Drawing.Size(117, 25); this.colorLabel2.TabIndex = 0; this.colorLabel2.Text = "colorLabel2"; // //
Form1 // this.ClientSize = new System.Drawing.Size(292, 273); this.Controls.Add(this.colorLabel2);
this.Name = "Form1"; this.ResumeLayout(false); } [STAThread] static void Main() { Form1 f1 = new Form1();
f1.ShowDialog(); } } ///////////////////////////////////////////////////////////////// // ColorLabel is a
simple extension of the standard Label control, // with color property locking added.
/////////////////////////////////////////////////////////////////
[Designer(typeof(ColorLabelDesigner))] public class ColorLabel : System.Windows.Forms.Label { private
bool colorLockedValue = false; public bool ColorLocked { get { return colorLockedValue; } set {
colorLockedValue = value; } } public override Color BackColor { get { return base.BackColor; } set { if
(ColorLocked) return; else base.BackColor = value; } } public override Color ForeColor { get { return
base.ForeColor; } set { if (ColorLocked) return; else base.ForeColor = value; } } }
///////////////////////////////////////////////////////////////// // Designer for the ColorLabel control
with support for a smart // tag panel. // Must add reference to System.Design.dll
/////////////////////////////////////////////////////////////////
"FullTrust")] public class ColorLabelDesigner : System.Windows.Forms.Design.ControlDesigner { private
DesignerActionListCollection actionLists; // Use pull model to populate smart tag menu. public override
DesignerActionListCollection ActionLists { get { if (null == actionLists) { actionLists = new
DesignerActionListCollection(); actionLists.Add( new ColorLabelActionList(this.Component)); } return
actionLists; } } } ///////////////////////////////////////////////////////////////// // DesignerActionList-
derived class defines smart tag entries and // resultant actions.
///////////////////////////////////////////////////////////////// public class ColorLabelActionList :
System.ComponentModel.Design.DesignerActionList { private ColorLabel colLabel; private
DesignerActionUIService designerActionUISvc = null; //The constructor associates the control //with the
smart tag list. public ColorLabelActionList( IComponent component ) : base(component) { this.colLabel =
component as ColorLabel; // Cache a reference to DesignerActionUIService, so the // DesigneractionList can
be refreshed. this.designerActionUISvc = GetService(typeof(DesignerActionUIService)) as
DesignerActionUIService; } // Helper method to retrieve control properties. Use of // GetProperties enables
undo and menu updates to work properly. private PropertyDescriptor GetPropertyByName(String
propName) { PropertyDescriptor prop; prop = TypeDescriptor.GetProperties(colLabel)[propName]; if (null
== prop) throw new ArgumentException( "Matching ColorLabel property not found!", propName); else
return prop; } // Properties that are targets of DesignerActionPropertyItem entries. public Color BackColor {
get { return colLabel.BackColor; } set { GetPropertyByName("BackColor").SetValue(colLabel, value); } }
public Color ForeColor { get { return colLabel.ForeColor; } set {
GetPropertyByName("ForeColor").SetValue(colLabel, value); } } // Boolean properties are automatically
displayed with binary // UI (such as a checkbox). public bool LockColors { get { return colLabel.ColorLocked;
} set { GetPropertyByName("ColorLocked").SetValue(colLabel, value); // Refresh the list.
this.designerActionUISvc.Refresh(this.Component); } } public String Text { get { return colLabel.Text; } set {
GetPropertyByName("Text").SetValue(colLabel, value); } } // Method that is target of a
DesignerActionMethodItem public void InvertColors() { Color currentBackColor = colLabel.BackColor;
BackColor = Color.FromArgb( 255 - currentBackColor.R, 255 - currentBackColor.G, 255 -
currentBackColor.B); Color currentForeColor = colLabel.ForeColor; ForeColor = Color.FromArgb( 255 -
currentForeColor.R, 255 - currentForeColor.G, 255 - currentForeColor.B); } // Implementation of this
abstract method creates smart tag // items, associates their targets, and collects into list. public override
DesignerActionItemCollection GetSortedActionItems() { DesignerActionItemCollection items = new

DesignerActionItemCollection(); //Define static section header entries. items.Add(new
DesignerActionHeaderItem("Appearance")); items.Add(new DesignerActionHeaderItem("Information"));
//Boolean property for locking color selections. items.Add(new DesignerActionPropertyItem("LockColors",
"Lock Colors", "Appearance", "Locks the color properties.")); if (!LockColors) { items.Add(new
DesignerActionPropertyItem("BackColor", "Back Color", "Appearance", "Selects the background color."));
items.Add(new DesignerActionPropertyItem("ForeColor", "Fore Color", "Appearance", "Selects the
foreground color.")); //This next method item is also added to the context menu // (as a designer verb).
items.Add(new DesignerActionMethodItem(this, "InvertColors", "Invert Colors", "Appearance", "Inverts the
fore and background colors.", true)); } items.Add(new DesignerActionPropertyItem("Text", "Text String",
"Appearance", "Sets the display text.")); //Create entries for static Information section. StringBuilder
location = new StringBuilder("Location: "); location.Append(colLabel.Location); StringBuilder size = new
StringBuilder("Size: "); size.Append(colLabel.Size); items.Add(new
DesignerActionTextItem(location.ToString(), "Information")); items.Add(new
DesignerActionTextItem(size.ToString(), "Information")); return items; } } }
Compilar o código
Sempre que fizer alterações aos aspectos em tempo de criação de um componente, você
que é aberto e usa esse componente, então você provavelmente precisará atualizar o projeto para
ver as alterações. Normalmente, você precisará fechar e reabrir a janela de design que contém o
componente.
COMO: Ajustar atributos, eventos e propriedades de um

componente no modo Design
Você pode usar o designer personalizado para modificar o atributos, eventos, e propriedades de
seu componente no modo Design.
Exemplo
O exemplo de código a seguir demonstra como criar um designer personalizado que ajusta um
componente na atributos, eventos, e propriedades. Uma classe chamada DemoControlDesigner
Designer está conectado a uma DemoControl classe e executa as seguintes operações:
• Adiciona uma propriedade para a DemoControl classe.

• Remove uma propriedade de classe DemoControl.
• As sombras uma propriedade de classe DemoControl.
• Atributos alterações de uma DemoControl propriedade de classe
• Cria um componente na superfície do design e anexa um manipulador de eventos.
C#





Para alterar os atributos, eventos e propriedades de seu componente no modo de design,

substituindo os seguintes métodos no seu designer:
• PreFilterAttributes
• PostFilterAttributes
• PreFilterEvents
• PostFilterEvents
• PreFilterProperties
• PostFilterProperties
O exemplo de código a seguir demonstra como substituir o PreFilterProperties e
Métodos PostFilterProperties para alterar as propriedades e atributos de classe DemoControl.
C#
// The PreFilterProperties method is where you can add or remove // properties from the component being
}
C#

// The PostFilterProperties method is where you modify existing // properties. You must only use this
the properties collection. base.PostFilterProperties(properties); }
componente.

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

12. Abra uma solução existente no Visual Studio com Visual Studio 2005 Tools for Office
instalado.
O Visual Studio Conversion Wizard aparece.
13. Leia as informações e avisos na primeira tela, e clique em Next.
14. 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.
15. Clique em Next.
16. Clique em Finish se tudo na página de resumo está correto.
Uma caixa de diálogo aparece com informações sobre propriedades padrão para
depuração do projeto.
17. 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.
18. 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.
19. Mover o código do arquivo classe principal antigo para o novo ThisDocument,
ThisWorkbook,. e Sheet Classes
20. Excluir o arquivo classe principal antigo após remover todo o código.
21. 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.
22. Substituir todos os controles ActiveX no documento ou pasta de trabalho por controles
gerenciados do Visual Studio Toolbox.

O Excel Usando Explicações Passo-a-passo
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
• Excel
Observação
Nesta etapa, você irá criar um projeto de aplicativos do Excel.

• 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:.
WinFormInput projeto para Solution Explorer.
Adicionar um controle NamedRange para a planilha
Para adicionar um intervalo nomeado para Sheet1
4. Selecione a célula A1 no Sheet1.
5. Na caixa Name, digite formInput.
A Name caixa está localizada à esquerda da barra de fórmulas, logo acima coluna A da
planilha.
6. 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
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

6. Selecione o projeto WinFormInput no Solution Explorer.
7. No menu Project, clique em Add Windows Form.
8. Nome do formulário GetInputString.vb ou GetInputString.cs. e, em seguida clique em
Add
O novo formulário é aberto no designer.
9. Adicionar um TextBox e um Button. para o formulário
10. 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

4. Clique com o botão direito do mouse ThisWorkbook.vb ou ThisWorkbook.cs em
Solution Explorer e selecione View Code.
5. 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
6. 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(); }
7. 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
4. Clique com o botão direito do mouse GetInputString em Solution Explorer, e selecione
View Designer.
5. Clique duas vezes no botão para abrir o arquivo de código com manipulador de eventos do
botão Click adicionado.
6. 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.

6. Confirme se o formulário Windows aparece.
7. Digite Hello World na caixa de texto e clique em OK.
8. 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:
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.
• Adicione texto e controles para uma planilha.

Observação

Pré-requisitos

Criando o projeto
Excel.

• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Formatting.
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.

9. Verifique se a pasta de trabalho está abra no designer visual studio e que Sheet1 está
aberto.
10. Na guia Common Controls da Toolbox, arraste um CheckBox controle para ou próxima
célula B2 na Sheet1.
11. No menu View, selecione Properties Janela.

Name applyBoldFont
Text Negrito
13. Arraste uma segunda caixa de seleção ou próxima célula B4 e alterar as seguintes
propriedades:

Text Itálico
14. Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes
propriedades:


Text Sublinhado
15. Selecione todos os controles caixa de seleção três mantendo a tecla CTRL.
16. 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.
Para adicionar texto a um controle NamedRange

célula B9.
8. Clique em OK.
9. 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
10. 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:

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.
6. Clique com o botão direito do mouse Sheet1 e clique View Code no menu de atalho
seleção:
C#
private void applyBoldFont_Click(object sender, EventArgs e) { this.textFont.Font.Bold =
this.applyBoldFont.Checked; }

seleção:
C#

private void applyItalicFont_Click(object sender, EventArgs e) { this.textFont.Font.Italic =
this.applyItalicFont.Checked; }
9. 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; } }
10. Em C#, adicione manipuladores de eventos para as caixas de seleção para o Startup
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 sua pasta de trabalho para certificar-se que o texto está formatado
corretamente quando você marca ou desmarca uma caixa de seleção.

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:
Office:.
Walkthrough:.
Exibindo texto em uma caixa de texto em uma planilha usando

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.

Observação
Pré-requisitos

• Excel.
Criando o projeto
Excel.
• 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
Button projeto para Solution Explorer.
Para essa explicação passo a passo, será necessário um botão e uma caixa de texto na primeira
planilha.
6. Verifique se a My Excel Button.xls pasta de trabalho é aberta no designer visual studio,

com Sheet1 exibido.
7. Na guia Common Controls da caixa de ferramentas, arraste para Sheet1. um TextBox
10. Arraste um Button controle até Sheet1 e alterar as seguintes propriedades:
Name insertText

Text Inserir texto
Preencher a caixa de texto quando o botão é Clicked
4. Na Solution Explorer, clique com o botão direito do mouse Sheet1 e, em seguida clique
View Code no menu de atalho.
C#
private void insertText_Click(object sender, EventArgs e) { this.displayText.Text += "Hello World! ";
}
6. Em C#, adicione um manipulador de eventos para o Startup evento como mostrado abaixo.
C#
Testar o aplicativo
Agora você pode testar sua pasta de trabalho para certificar-se que a mensagem Hello World!

Próximas etapas
em planilhas do Excel. Aqui estão algumas tarefas que podem vie em seguida:
• 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

• Adicionar um NamedRange controle para uma planilha.

• Programa contra NamedRange Eventos de controle.
Observação
Pré-requisitos

Criando o projeto
Nesta etapa, você irá criar pasta de trabalho Excel usando Visual Studio Tools for Office Um do
projeto.
• Criar um projeto de pasta de trabalho do Excel com o nome My Named Range Events.
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
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
8. Verifique se a My Named Range Events.xls pasta de trabalho é aberta no designer visual

célula A1 no Sheet1.
A Add NamedRange Control caixa de diálogo será exibida.

10. 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.
11. 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
12. Adicionar um outro NamedRange controle a célula B3.
14. Clique em OK.
Célula B3 se torna um intervalo nomeado namedRange2.
Para adicionar texto a sua planilha
3. Na célula A1, digite o seguinte texto:

Este é um exemplo de um controle NamedRange.
4. 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
4. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs. e

selecione View Code
5. Adicione código para o namedRange1_BeforeDoubleClick manipulador de eventos é
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; }
6. 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
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 é

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.

8. Coloque o cursor no namedRange1, e verificar que o texto sobre o SelectionChange evento
é inserido e que um comentário é inserido na planilha.
9. Duplo clique dentro namedRange1, e verifique se o texto sobre BeforeDoubleClick eventos
está inserido com texto em itálico em namedRange2 vermelho.

10. 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.
11. Alterar o texto dentro namedRange1.
12. 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:
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

Pré-requisitos

Criando o projeto
• Criar um projeto de pasta de trabalho do Excel com o nome My Security Test. Verifique

12. Verifique se a My Security Test.xls pasta de trabalho é aberta no designer visual studio,
com Sheet1 exibido.
13. 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
C#

17. Clique em Save.
20. Feche o Excel.
Visual Studio.
nível do usuário.

12. 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.
13. Clique em Yes.

15. Clique em OK.
16. Feche o Excel.
Microsoft .NET.
prova.

13. Na caixa Create Strong Name Key de diálogo, digite SecurityTestKey na caixa Key file
name.
15. Clique em OK.
nome forte.
no nome forte.

atalho
12. Digite o nome Security Test Strong Name para o novo grupo de códigos, e clique em
Next.

16. Clique em Next.
Testar o aplicativo

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.
• Criar uma fonte de dados para um projeto do Excel.

• Rolar pelos registros do banco de dados.
Observação
Pré-requisitos
• Acesso a um servidor com o exemplo de SQL Server do Northwind.

• 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
9. Se a Data Sources janela não estiver visível, clique Show Data Sources no Data menu.
Observação
10. Clique Add New Data Source Para iniciar o Data Source Configuration Wizard.
12. 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.
16. Marque a caixa de seleção ao lado da Customers tabela.
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.
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
botões da Toolbox.
Para adicionar dois intervalos nomeados
8. Verifique se a My Simple Data Binding.xls pasta de trabalho é aberta no designer visual

9. Abra a Data Sources janela e expanda o Customers nó.
10. Selecione a CompanyName coluna, e clique na seta suspensa que aparece.
11. 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
12. Selecione a CustomerID coluna na janela Data Sources, e clique na seta suspensa que
aparece.
13. Clique NamedRange na lista drop-down, e arraste a CustomerID coluna à célula B1.
14. É criado na célula B1, e vinculado a outro NamedRange controle chamado
customerIDNamedRange o BindingSource.
Para adicionar quatro botões

Toolbox,
4. Adicionar mais três botões às seguintes células nesta ordem, para que os nomes são
conforme mostrado:
Célula (Nome)
B3 Button2
C3 Button3
D3 Button4
A próxima etapa é para adicionar texto para os botões, e em C# Adicionar manipuladores de

eventos.
Para inicializar os controles

5. 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 = ">|";
C#
EventHandler(button2_Click); this.button3.Click += new EventHandler(button3_Click);

Agora, adicione código para manipular os Click eventos dos botões para que o usuário pode
procurar pelos registros.
Para mover para o primeiro registro

código para mover para o primeiro registro a seguir:
C#
this.customersBindingSource.MoveFirst(); }
Para mover para o registro anterior

código a seguir para mover a posição de volta em um:
C#
this.customersBindingSource.MovePrevious(); }
Para mover para o próximo registro

código a seguir para avançar a posição em um:
C#
this.customersBindingSource.MoveNext(); }
Para mover para o último registro

código a seguir para mover para o último registro:
C#
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.

6. Confirme se o primeiro registro aparece nas células A1 e B1.
7. Clique em e B1. (Button3) botão e confirme se o registro seguinte aparece na célula A1 a >

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

• Salva qualquer alteração de dados de volta para o banco de dados.
Observação
Pré-requisitos

• 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
Observação
16. Marque a caixa de seleção ao lado da Employees tabela.
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.
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
5. Verifique se a My Complex Data Binding.xls pasta de trabalho é aberta no designer

6. Abra a Data Sources janela e selecione o Employees nó.
7. Clique na seta suspensa que aparece.
8. 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

5. Adicione o seguinte código para o Sheet1_Startup método para definir o texto para o b utton.
C#
this.button1.Text = "Save";
6. C# somente, para adicionar um manipulador de eventos para o Click evento para o

C#
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); } }
Testar o aplicativo
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
3. Clique em Célula B7, que deve conter o nome Davolio.

4. Digite o nome Anderson, e pressione ENTER.
Para modificar um cabeçalho de coluna
3. Clique na célula que contém no cabeçalho LastName da coluna.

4. Digitar Last Name, incluindo um espaço entre as duas palavras, e pressione ENTER.
Para salvar dados
5. Clique Save na planilha.

6. Feche a pasta de trabalho. Clique em No Quando solicitado a salvar as alterações feitas.
7. Pressione F5 para executar o projeto novamente.
O objeto lista é preenchido com dados da tabela Employees.
8. 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
3. 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
4. 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
3. Selecionar linha 16, que deve conter a nova linha que você adicionou, clicando no número
16 no lado esquerdo da planilha.
4. No menu Edit, clique em Delete.
Para classificar as linhas na lista

Botões de seta aparecem em cada cabeçalho de coluna.
5. Clique no botão SETA no cabeçalho da Last Name coluna.

6. Clique em Sort Ascending.
As linhas são classificadas em ordem alfabética por sobrenome.
Para filtrar informações

7. Clique no botão SETA no cabeçalho da Title coluna.
8. Clique em Sales Representative.
A lista mostra somente as linhas que têm Sales Representative na coluna Title.
9. Clique no botão SETA no cabeçalho da Title coluna novamente.
10. 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:
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.

• Configurar um DataSet para ser armazenados em uma planilha.
• Adicione código para Habilitar rolagem pelos registros.
Observação
Pré-requisitos

• Acesso ao exemplo de SQL Server do Northwind. O banco de dados pode ser no seu
computador de desenvolvimento ou em um servidor.

• 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
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
Server ou adicionar uma nova conexão usando o New Connection botão.
13. Após selecionar ou criar uma conexão, clique em Next.
16. Selecione a Orders tabela e a Order Details tabela.
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.
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
8. Verifique se a My Master-Detail.xls pasta de trabalho é aberta no designer visual studio,

com Sheet1 exibido.
9. Abra a Data Sources janela e expanda o Orders nó.

10. Selecione a OrderID coluna, e clique na seta suspensa que aparece.
11. 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
12. 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 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.
13. Clique ListObject na lista drop-down, e arraste a Order Details tabela à célula A6.
14. Um ListObject controle denominado Order_DetailsListObject é criado na célula A6, e
vinculado à BindingSource.
Para adicionar dois botões

Toolbox,
4. Adicionar um outro Button controle a célula B3 da planilha.
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

4. Selecione NorthwindDataSet No bandeja de componentes.
5. Na janela Properties, alterar a Modifiers propriedade para Public.
DataSets deverá ser pública antes cache está ativado.
6. 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.
Ao inicializar os dados e os controles

5. 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 = ">";
C#
EventHandler(button2_Click);
Para percorrer os registros

3. 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:
C#
private void button1_Click(object sender, EventArgs e) { this.ordersBindingSource.MovePrevious(); }
4. 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
esperado, e que você pode usar a solução off-line.
Para testar o cache de dados

9. Pressione F5.
10. Verifique que o intervalo nomeado e o objeto lista são preenchidos com dados da fonte de
dados.
11. Rolar pelos alguns dos registros clicando nos botões.
12. Pasta de trabalho, salve e feche a pasta de trabalho e Visual Studio.
13. 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
14. 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#.
15. Rolar pelos alguns dos registros para ver que a planilha opera normalmente quando
desconectado.
16. 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
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:

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.
• Adicionar um controle de usuário para uma planilha.

Observação
Pré-requisitos
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

5. Abra o Excel 2003.
Abre uma nova pasta de trabalho.
6. Clique com o botão direito do mouse na Sheet3 guia e, em seguida clique Rename no
menu de atalho.
7. Renomear a planilha para Data for Chart.
8. 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.

12. No menu Insert, clique em Chart.
O Chart Wizard abre.
13. Clique em Next, deixando os padrões selecionados.
14. Clique na caixa Data Range e desmarque qualquer seleção padrão.
15. 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.
16. Para aceitar todos os padrões para Step 3, clique Next em Next novamente.
17. No Step 4, garantir que As object in: está selecionado.
18. Na lista As object in:, selecione Sheet1.
20. Reposicionar o gráfico para que o canto direito superior alinhe com Célula E2.
21. Salve o arquivo para a unidade C: e nomeá-la ExcelChart.xls.
22. Feche o Excel.
Excel.

4. 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
5. Clique no Browse botão e vá para a pasta de trabalho que você criou anteriormente nessa
6. Clique em OK.
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:
Name dataChart
HasLegend False

4. Selecione o My Excel Chart projeto no Solution Explorer.
6. Na caixa Add New Item de diálogo, clique User Control, nome do controle ChartOptions,
e clique em Add
Name columnChart
8. Adicionar um botão de opção segundo para o controle de usuário, e alterar as

propriedades a seguir:
Name barChart
9. Adicionar um botão de opção terceiro para o controle de usuário, e alterar as propriedades

a seguir:
Name lineChart

10. Adicionar um botão de opção quarto para o controle de usuário, e alterar as propriedades a
seguir:
Name areaBlockChart
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
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.

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 {
Para manipular o evento CheckedChanged dos botões de opção

6. Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão areaBlockChart
de opção e depois gerar o evento.
C#
Microsoft.Office.Interop.Excel.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) {
7. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart de

opção.
C#
Microsoft.Office.Interop.Excel.XlChartType.xlBarClustered; if (this.SelectionChanged != null) {
8. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão columnChart

de opção.
C#

Microsoft.Office.Interop.Excel.XlChartType.xlColumnClustered; if (this.SelectionChanged != null) {
9. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart de

opção.
C#
Microsoft.Office.Interop.Excel.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) {
o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, conforme
C#
Adicionar o controle de usuário a planilha

Toolbox. Você pode, então, arrastar o controle da Toolbox. para seu Worksheet
Para adicionar o controle do usuário sua planilha

5. Clique com o botão direito do mouse Sheet1.vb no Solution Explorer, ou Sheet1.cs. e
selecione View Designer
6. Do Toolbox arraste o ChartOptions controle de para a planilha.
Para alterar o tipo de gráfico que é exibido na planilha

3. 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()); } }

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

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:
Office:.
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:
no Microsoft Office Excel 2003. Os controles demonstram uma Relação mestre / detalhes entre
tabelas em um banco de dados do SQL Server.

• Criar um controle painel Ações.
• Adicionar controles Windows Forms ligados a dados a um controle painel Ações.
Observação

Pré-requisitos
Criando o projeto
A primeira etapa é para criar um projeto de pasta de trabalho do Excel.

• Criar um projeto de pasta de trabalho do Excel com o nome My Excel Actions Pane.
Actions Pane projeto para Solution Explorer.
Adicionar uma nova fonte de dados ao projeto
Observação
Se Show Data Sources clique dentro na planilha do Excel e depois verificar novamente. não
estiver disponível,
14. Clique em Next.
17. Marque a caixa de seleção ao lado da Suppliers tabela.
18. Expandir a Products tabela e selecione ProductName, SupplierID, QuantityPerUnit. e
UnitPrice
O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele também

Em seguida, adicione um NamedRange controle e um ListObject controle à primeira planilha.
Para adicionar um NamedRange e um controle ListObject

8. Verifique se a My Excel Actions Pane.xls pasta de trabalho é aberta no designer visual
9. Na janela Data Sources , expanda a Suppliers tabela.
10. Clique na seta suspensa no nó Company Name, e selecione NamedRange.
11. 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,
12. 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.
13. 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,
14. No C# somente, selecione suppliersBindingSource No bandeja de componentes, e
alterar a Modifiers propriedade para Internal na janela Properties.
Em seguida, você precisa um controle painel Ações que contenha uma caixa de combinação.

4. Selecione o My Excel Actions Pane projeto no Solution Explorer.
ActionsControl e clique em Add
Para adicionar controles Windows Forms ligados a dados a um controle painel Ações
4. Das Common Controls guias da Toolbox, arraste um ComboBox controle para o controle
painel Ações.
5. Alterar a Size propriedade para 171, 21.
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

4. Clique com o botão direito do mouse no controle painel Ações e selecione View Code a
partir do menu de atalho
5. 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"; }
6. 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
C#
public ActionsControl() { InitializeComponent(); this.Load += new
EventHandler(ActionsControl_Load); }

4. Criar uma nova instância do controle do usuário na classe ThisWorkbook, da seguinte
maneira:
C#
ActionsControl actions = new ActionsControl();
5. No manipulador Startup de eventos de ThisWorkbook, adicione código de forma que ele

tenha como no exemplo a seguir:
C#
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.

7. 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.
8. Selecione várias empresas para verificar o nome da empresa e Detalhes do Produto altere
conforme apropriado.
Próximas etapas

um painel Ações no Excel. Aqui estão algumas tarefas que podem vie em seguida:
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:.
Implantando um Word ou Solution do Excel usando um manifesto

Deployment Walkthrough:
desenvolvimento.
Pré-requisitos

Observação


Criando o projeto



C#
private void ThisDocument_Startup(object sender, System.EventArgs e) { MessageBox.Show("The
document is deployed correctly."); }

10. Sair do Word.


8. Na caixa Specify the location to publish this application, digite C:\TestDeploy.
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.
Observação

Observação
Inclui Visual Studio Tools for Office um exemplo que demonstre como criar uma ferramenta que
consulte Aplicativo Manifest exemplo Editor.

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

ServerDocument(@"C:\TestDeploy\WordDeployment.doc"); sd.AppManifest.DeployManifestPath =
@"\\DeployServer\ShareFolder\WordDeployment.application"; sd.Save(); } finally { if (sd != null) {
sd.Close(); } }


manifesto de implantação é denominado WordDeployment.application, e está localizado
na pasta C:\TestDeploy de publicação.
5. 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 <dependentAssembly> Element (Visual Studio Tools for Office

solução.

do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na pasta
C:\TestDeploy\WordDeployment_1.0.0.0 de publicação.
6. 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

<dependentAssembly codebase="\\DeployServer\ShareFolder\WordDeployment.application"

para o servidor.

4. Crie uma WordDeployment_1.0.0.0 pasta sob a \\DeployServer\ShareFolder
compartilhamento de arquivos de rede.
Observação


Próximas etapas

Implantando um Word ou Solution do Excel usando um arquivo do Windows
Installer Walkthrough:
Office Word 2003.
Installer.
solução.
Observação
Pré-requisitos

Observação

Criando o projeto

• Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment. Verifique


C#
private void ThisWorkbook_Startup(object sender, System.EventArgs e) { MessageBox.Show("The
workbook is deployed successfully."); }

10. Saia do Excel.

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

10. Clique com o botão direito do mouse no ExcelSetup project nó em Solution Explorer.
16. Clique em OK.
17. No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó de
projeto.

Windows.
13. Clique em OK.
14. 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 é


13. Do ManifestEditor.cs clique com o botão direito do mouse no Solution Explorer, ou
ManifestEditor.vb arquivo e clique em View Code.
C#

C#
// Override the Install method to update the customization location // in the application manifest.
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) {

16. Clique com o ExcelCustomAction projeto no Solution Explorer, e, em seguida clique em
Build.
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

Custom Action.
18. 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
20. Clique com o botão direito do mouse Primary output from ExcelCustomAction (Active)
e, em seguida clique em Properties Window.
seqüência:

CustomActionData.


Passo-a-passo: Concedendo e removendo permissões para uma solução do
Office

Pré-requisitos

Criando o projeto


com Sheet1 exibido.
C#

17. Clique em Save.

20. Feche o Excel.
Visual Studio.
nível do usuário.

menu de atalho.
13. Clique em Yes.
15. Clique em OK.
16. Feche o Excel.
Microsoft .NET.
prova.


name.
15. Clique em OK.
nome forte.
no nome forte.

atalho
Next.
16. Clique em Next.
Testar o aplicativo


O Word Usando Explicações Passo-a-passo
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.
• Adicione texto e um controle a um documento.

Observação
Pré-requisitos

Criando o projeto
Neste procedimento, você irá criar projeto usando Visual Studio Tools for Office um documento do
Word.

• Criar um projeto Documento do Word com o nome My Word Formatting. Verifique que
Abre o novo documento do Word no designer e adiciona o My Word Formatting projeto para
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.

11. Na Common Controls guia e arraste-o para o documento. da Toolbox, arraste um
CheckBox
Name applyBoldFont
Text Negrito
14. Pressione Enter para mover o ponto de inserção abaixo da primeira caixa de seleção.
15. Adicionar uma segunda caixa de seleção para o documento abaixo da ApplyBoldFont caixa
de seleção e alterar as propriedades a seguir:
Text Itálico
16. Pressione Enter para mover o ponto de inserção abaixo da segunda caixa de seleção.
17. Adicionar uma caixa de seleção terceira para o documento abaixo da ApplyItalicFont caixa
de seleção e alterar as propriedades a seguir:
Text Sublinhado
18. 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

5. 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.
6. Na guia Word Controls na Toolbox, arraste um Bookmark controle para o documento.
7. Selecione o texto é adicionado ao documento e clique em OK.
Um Bookmark controle denominado Bookmark1 é adicionado ao texto selecionado no
documento.
8. 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.
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.

7. Clique com o botão direito do mouse ThisDocument no Solution Explorer, e, em seguida
8. No C# somente, adicionar as constantes a seguir para a ThisDocument classe:
C#
const int WordTrue = -1; const int WordFalse = 0;

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

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; } }
11. 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; } }
12. 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

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.

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
• Implantação do projeto. Para obter mais informações, consulte Como: Implantar arquivos
de solução usando o Publish Wizard.
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.

Observação
Pré-requisitos

Criando o 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
Abre o novo documento do Word no designer e adiciona o My Word Button projeto para
Adicionar controles ao documento do Word
Nesta seção, você adicionará um botão e uma caixa de texto para o documento Word.

7. Na guia Common Controls da Toolbox, arraste um TextBox controle para o documento.
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.

10. Arraste um Button controle para o documento e alterar as seguintes propriedades:
Name insertText
Text Inserir texto
Preencher a caixa de texto quando o botão É Clicked

4. Na Solution Explorer, clique com o botão direito do mouse ThisDocument e, em seguida
C#

private void insertText_Click(object sender, EventArgs e) { this.displayText.Text += "Hello World!"; }
6. Em C#, adicione um manipulador de eventos para o botão para o Startup evento como
C#
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.

Próximas etapas
em documentos do Word. Aqui estão algumas tarefas que podem vie em seguida:
• 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.
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.
• 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.
Observação
Pré-requisitos

Criando o projeto
Nesta etapa, você irá criar um projeto Documento do Word no Visual Studio.

• Criar um projeto Documento do Word com o nome My Bookmark Shortcut Menu.
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
4. Na guia Word Controls da Toolbox, arraste um Bookmark controle para o documento.
5. Selecione as palavras creating a shortcut menu when you right-click the text no seu
documento e clique em OK.
6. Adicionar outro Bookmark controle com as palavras right-click the text in a bookmark.
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
5. No Solution Explorer, clique com o botão direito do mouse ThisDocument e selecione
View Code.
6. 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;
7. 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); }
8. 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
4. 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; } } }
5. 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; } }
6. 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
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.

7. Clique com o botão direito do mouse dentro do indicador e selecione Bold primeiro.
8. Verificar se todos os o texto no bookmark1 é formatados como negrito.
9. Clique com o botão direito do mouse dentro do texto dos indicadores sobrepostos e
selecione Italic.
10. 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
• 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
CheckBox.
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.
• Adicionar um gráfico a um documento.

• Adicionar um controle de usuário a um documento.
Observação
Pré-requisitos

Criando o projeto

• Criar um projeto Documento do Word com o nome My Chart Options. Verifique que
Abre o novo documento do Word no designer e adiciona o My Chart Options projeto para
Adicionar um gráfico ao documento
Em seguida, adicione um gráfico para o documento.

6. 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.
7. Na lista Object type da guia Create New, selecione Microsoft Graph Chart e clique em
OK
Um gráfico é adicionado ao documento no ponto de inserção, e a Datasheet janela é
exibida com alguns dados padrão.
8. 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.
9. Clique com o botão direito do mouse no gráfico e selecione Format Object.
10. Na guia Layout da caixa de diálogo, selecione Square e Format Object Clique em OK.

4. Selecione o My Chart Options projeto no Solution Explorer.
6. Na caixa Add New Item de diálogo, clique User Control, nome do controle ChartOptions,
e clique em Add
Name columnChart
8. Adicionar um segundo Radio Button ao controle de usuário, e alterar as seguintes

propriedades:
Name barChart
9. Adicionar um terceiro Radio Button ao controle de usuário, e alterar as seguintes

propriedades:
Name lineChart
10. Adicionar um quarto Radio Button ao controle de usuário, e alterar as seguintes

propriedades:
Name areaBlockChart
Adicionar Referências

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

A Add Reference caixa de diálogo será exibida.
5. Clique na COM guia.
6. 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
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.

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 {
Para manipular o evento CheckedChange dos botões de opção
6. Definir o tipo de gráfico no manipulador CheckedChanged de eventos de botão areaBlockChart

de opção e depois gerar o evento.
C#
Microsoft.Office.Interop.Graph.XlChartType.xlAreaStacked; if (this.SelectionChanged != null) {
7. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão barChart de

opção.
C#
Microsoft.Office.Interop.Graph.XlChartType.xlBarClustered; if (this.SelectionChanged != null) {
8. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão columnChart

de opção.
C#

Microsoft.Office.Interop.Graph.XlChartType.xlColumnClustered; if (this.SelectionChanged != null) {
9. Definir o tipo de gráfico no manipulador CheckedChanged de eventos do botão lineChart de

opção.
C#
Microsoft.Office.Interop.Graph.XlChartType.xlLineMarkers; if (this.SelectionChanged != null) {
o código para o ChartOptions Construtor, sob a chamada para InitializeComponent, conforme
C#
Adicionando o controle de usuário ao documento

Toolbox. Do Toolbox Você pode, então, arrastar o controle de ao seu documento.
Para adicionar o controle de usuário do documento

ThisDocument.cs. e selecione View Designer
6. Do Toolbox arraste o ChartOptions controle de para o documento.
Para alterar o tipo de gráfico que é exibido no documento

3. 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); } }

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

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
Office:
Walkthrough:.
• Alterar formatação, selecionando um estilo da caixa de combinação. Para obter mais
CheckBox.
Vinculação de Dados para controles em um painel Ações do

Word Walkthrough:
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.
• 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.

Observação
Pré-requisitos
Criando o projeto

• Criar um projeto Documento do Word com o nome My Word Actions Pane. Verifique que
Abre o novo documento do Word no designer e adiciona o My Word Actions Pane projeto
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.

4. Selecione o My Word Actions Pane projeto no Solution Explorer.
ActionsControl, e clique em Add
Observação
Se Show Data Sources Clique dentro do documento do Word e marque novamente. não estiver
disponível,

13. Clique em Next.
16. Marque a caixa de seleção ao lado e Products tabelas. o Suppliers
O assistente adiciona a Suppliers tabela e Products Tabela à janela Data Sources. Ele também
Para adicionar controles Windows Forms ligados a dados a um controle painel Ações
13. Na janela Data Sources, expanda a Suppliers tabela.
14. Clique na seta suspensa no nó Company Name, e selecione ComboBox.
15. 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.
16. Mover a caixa de combinação para que ele seja sob o rótulo e alterar a Size propriedade
171, 21.
17. Expandir a Products tabela na janela Data Sources.
18. Clique na seta suspensa no nó ProductName, e selecione ListBox.
19. 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
20. 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.
21. Mover a caixa de listagem para que ele seja sob o rótulo e alterar a Size propriedade
171,95.
22. Arraste controlar e colocá-lo a caixa de listagem abaixo. de para o painel Ações um Button
o Toolbox
23. Clique com o botão direito do mouse clique Properties no menu de atalho, e altere as
seguintes propriedades: o Button,

Name Inserir
Text Inserir

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#
private void ActionsControl_Load(object sender, EventArgs e) {
this.suppliersTableAdapter.Fill(this.northwindDataSet.Suppliers);
this.productsTableAdapter.Fill(this.northwindDataSet.Products); }
7. Selecione o CompanyNameComboBox controle.

8. Na janela Properties, clique no botão para a direita da propriedade DataSource, e
selecione SuppliersBindingSource.
9. Na janela Properties, clique no botão para a direita da propriedade DisplayMember, e
selecione CompanyName.
10. Selecione o ProductNameListBox controle.
11. Na janela Properties, clique no botão para a direita da propriedade DataSource, expanda
SuppliersBindingSource, e selecione FK_Products_Suppliers.
12. 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 =
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
2. No manipulador Click de eventos do botão Insert, adicione código conforme mostrado no

exemplo o seguir:
Observação
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); } }

3. 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
C#
this.Insert.Click += new EventHandler(Insert_Click);

3. 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();
4. Adicione código ao manipulador Startup de eventos de ThisDocument forma que ele tenha
como no exemplo a seguir:
Observação
C#
this.ActionsPane.Controls.Add(actions);
Testar o aplicativo
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.

8. Selecione uma empresa na caixa de combinação e verifique que os itens na caixa
Products Lista alterar.
9. Selecione um produto, clique Insert no painel de ações, e verifique se os detalhes do
produto foram adicionados à tabela no Word.
10. Inserir outros produtos de várias empresas.
Próximas etapas
um painel Ações no Word. Aqui estão algumas tarefas que podem vie em seguida:

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

• 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,
Abre o novo documento do Word no designer e adiciona o My Smart Tag projeto para Solution
Explorer o Visual Studio.
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

6. Na guia COM, selecione biblioteca tipo 2.0 marcas inteligentes Microsoft e clique em OK.
7. 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.
8. 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

4. 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"));
5. 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};
6. 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.
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.

6. 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.
7. Clique no ícone de marca inteligente que aparece sobre a seqüência reconhecida e clique
em Convert to Celsius.
8. Confirme que a seqüência original é substituída por uma nova seqüência contendo a
temperatura em Celsius.

manifesto Deployment Walkthrough:
desenvolvimento.
Pré-requisitos

Observação

Criando o projeto



C#
private void ThisDocument_Startup(object sender, System.EventArgs e) { MessageBox.Show("The
document is deployed correctly."); }

10. Sair do Word.


8. Na caixa Specify the location to publish this application, digite C:\TestDeploy.
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.
Observação

Observação
Inclui Visual Studio Tools for Office um exemplo que demonstre como criar uma ferramenta que
consulte Aplicativo Manifest exemplo Editor.

C#

9. 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
C#
ServerDocument(@"C:\TestDeploy\WordDeployment.doc"); sd.AppManifest.DeployManifestPath =
@"\\DeployServer\ShareFolder\WordDeployment.application"; sd.Save(); } finally { if (sd != null) {
sd.Close(); } }


manifesto de implantação é denominado WordDeployment.application, e está localizado
na pasta C:\TestDeploy de publicação.
5. 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 <dependentAssembly> Element (Visual Studio Tools for Office

solução.

do aplicativo é denominado WordDeployment.dll.manifest, e está localizado na pasta
C:\TestDeploy\WordDeployment_1.0.0.0 de publicação.
6. 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

<dependentAssembly codebase="\\DeployServer\ShareFolder\WordDeployment.application"

para o servidor.

4. Crie uma WordDeployment_1.0.0.0 pasta sob a \\DeployServer\ShareFolder
compartilhamento de arquivos de rede.
Observação



Próximas etapas

arquivo do Windows Installer Walkthrough:
Office Word 2003.
Installer.
solução.
Observação
Pré-requisitos

Observação

Criando o projeto

• Criar um projeto de pasta de trabalho do Excel com o nome ExcelDeployment. Verifique


C#
private void ThisWorkbook_Startup(object sender, System.EventArgs e) { MessageBox.Show("The
workbook is deployed successfully."); }

10. Saia do Excel.

Deployment.

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

16. Clique em OK.
17. No Solution Explorer, expanda Detected Dependencies sob o ExcelSetup nó de
projeto.

Windows.
13. Clique em OK.

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

13. Do ManifestEditor.cs clique com o botão direito do mouse no Solution Explorer, ou
ManifestEditor.vb arquivo e clique em View Code.
C#

C#
// Override the Install method to update the customization location // in the application manifest.
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) {
16. Clique com o ExcelCustomAction projeto no Solution Explorer, e, em seguida clique em

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

Custom Action.
18. 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
20. Clique com o botão direito do mouse Primary output from ExcelCustomAction (Active)
e, em seguida clique em Properties Window.
seqüência:

CustomActionData.


Passo-a-passo: Concedendo e removendo permissões para
uma solução do Office

Pré-requisitos

Criando o projeto


com Sheet1 exibido.
C#

17. Clique em Save.

20. Feche o Excel.
Visual Studio.
nível do usuário.

menu de atalho.
13. Clique em Yes.
15. Clique em OK.
16. Feche o Excel.
Microsoft .NET.
prova.

name.
15. Clique em OK.
nome forte.
no nome forte.

atalho
Next.
16. Clique em Next.
Testar o aplicativo


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
Adicionando controles em tempo de design
Para arrastar um Windows Forms controle para o documento

Office:.
4. Na guia Common Controls Da Clique no controle que você deseja adicionar e arraste-o
para o documento. o Toolbox,
Observação

Para desenhar um Windows Forms controle sobre o documento

Office:.
5. Na guia Common Controls da caixa de ferramentas, clique no controle você deseja
adicionar.
6. 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


Para adicionar um controle Windows Forms para o documento clicando uma única vez
sobre o controle

Office:.
5. Na guia Common Controls Da clique Toolbox, o controle você deseja adicionar
6. Um documento, clique onde desejar o controle a ser adicionado.
O controle é adicionado ao documento com o tamanho padrão.
Observação

Para adicionar um controle Windows Forms para o documento clicando duas vezes no
controle

Office:.
4. Na guia Common Controls Controle você deseja para adicionar de clique duplo no
Toolbox.
Observação

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

ENTER

Office:.
4. Na guia Common Controls Da Clique no controle que você deseja adicionar e pressione a
tecla ENTER. o Toolbox,
Observação


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

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
3. Criar o intervalo nomeado.

C#
Microsoft.Office.Tools.Excel.NamedRange NamedRange1 =
this.Controls.AddNamedRange(this.get_Range("A1", missing), "NamedRange1");
4. 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();
• 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
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#
// 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 =
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 =
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); }

Esta página contém links para a Ajuda sobre tarefas de programação de dispositivos inteligentes
amplamente utilizadas. Para ver outras categorias de tarefas populares abordadas na Ajuda,
consulte Como Fazer em C#.
O que há de novo em projetos Smart Device

Os seguintes recursos novos ou expandido estão disponíveis no Visual Studio 2005.
O que há de novo no desenvolvimento visual aplicativos

dispositivos C++
Inclui Visual Studio 2005 Desenvolvimento do dispositivo no Visual C++. Anteriormente,
desenvolver projetos de dispositivo com Visual C++ necessária uma versão do eMbedded Visual
C++. Os novos recursos detalhados nas seções a seguir são aprimoramentos sobre eMbedded
Visual C++.
Ambiente de desenvolvimento integrado (IDE)
Destino vários sistemas operacionais
O Visual Studio 2005 conjunto de ferramentas fornece a capacidade para destino Pocket PC
2003, Smartphone 2003, personalizados SDKs baseado em Windows CE 5.0-, e libera SDK
futura.
Sistema do projeto
O sistema do projeto agora associa plataformas a suas arquiteturas CPU com suporte. Versões
anteriores do eMbedded Visual C++ permitido a seleção de uma arquitetura de CPU que não foi
aceito pelo atual do projeto ativo.
O IntelliSense
No Visual Studio 2005, IntelliSense reflete entre os arquivos de cabeçalho Software Development
Kit (SDK) para fornecer informações precisas sobre a plataforma de destino.
Modo misto Solutions
Ativa Visual Studio 2005 desenvolvedores do dispositivo para ter tanto gerenciados, código Basic,
Visual C# ou Visual e não gerenciado, Visual C++, código no mesmo solução. Ele também
habilitará Área de trabalho e dispositivo Código Visual C++ para estar no mesmo projeto.
Instalar do aplicativo
Permite que os desenvolvedores para compactar seus aplicativos do dispositivo e criar um

instalador da área de trabalho para distribuir os aplicativos para dispositivos.
Aplicativos personalizados e assistentes de classe
Torna Visual Studio 2005 fácil a gravar aplicativo e assistentes de classe para projetos de
dispositivo.

Editor de recursos
O Resource Editor e CAPEdit controles. inclui recursos específicos do dispositivo, como o State
of Input Panel
Depuração
O Visual Studio 2005 depurador do dispositivo C++ contém o seguintes recursos novos ou
aperfeiçoamentos:
• Robustez aprimorado e desempenho por depuradores do aplicativo do dispositivo anterior.

• A capacidade de desanexar e re-Attach para processos.
• A capacidade para anexar a um processo sem o executável.
• Suporte para pontos de interrupção de DLLs compartilhadas.
• Vários processo depuração.
• Avaliação aprimorado expressão incluindo mais expressive janelas depurador.
Compiladores
Os Visual Studio 2005 compiladores do dispositivo C++ ter o seguintes recursos novos ou
aperfeiçoamentos:
• Suporte para /LTCG geração (código de tempo de conexão).

• Aumentado limites do compilador.
• Alternar /GS o suporte para detecção de saturação de buffer.
• Suporte a palavra-chave __restrict.
• Atualiza em conformidade com uma porcentagem maior de normas C++.
Bibliotecas
As bibliotecas Visual C++ para dispositivos possui o seguintes recursos novos ou

aperfeiçoamentos:
• Microsoft (ATL) para dispositivos Active Template Library e Microsoft MFC (para
dispositivos Foundation Classes) foram atualizadas para o código 8.0 base.
• Segurança abrangente, desempenho, estabilidade e compatibilidade com padrões
funciona em MFC para dispositivos, ATL para dispositivos, a biblioteca (CRT) em tempo de
execução C para dispositivos, e a Biblioteca C++ Padrão para dispositivos
• Funcionalidade Common MFC e ATL foi mesclada.
• Suporte fluxo foi adicionado à Biblioteca C++ Padrão para dispositivos.
ATL
Os seguintes recursos foram adicionados ao ATL para dispositivos:
• Controle ActiveX hospeda.

• A capacidade de consomem serviços da Web.
• Bitmap suporte com a CImage classe.
• Novas classes para gerenciar matrizes, listas e árvores.
• Manipulação de seqüência de caracteres avançada e conversão.

• Estendido suporte soquete para IPv6.
MFC
Os seguintes recursos foram adicionados ao MFC para dispositivos:
• Agora disponível para Smartphone.

• Controle ActiveX que hospeda e criação.
O que há de novo no Managed projetos de dispositivo

A lista abaixo descreve aprimoramentos para o dispositivo gerenciado desenvolvimento de
aplicativos adicionadas desde o Visual Studio .NET 2003.
Observação
Embora você possa usar Visual Studio 2005 para programar contra versão 1 e versão 2 do .NET
Compact Framework, não há suporte para os recursos abaixo marcados com um asterisco (*) na
versão 1
Novos recursos
Os recursos a seguir estão disponíveis no Visual Studio 2005.
Recurso Details
*Anchoring controles em formulários do Windows HOW TO: Anchor controles em Windows

Forms
CAB Geração de arquivo usando projetos Visual Visão geral Solutions do dispositivo de
Studio instalação e implantação. Esse processo embalagem
elimina a necessidade de personalizar o arquivo.inf
manualmente.
Filtrar sem suporte propriedades / Methods / Recurso inclui IntelliSense filtrado, uma
eventos. etapa de verificação de criação, e
capacidade para converter controles sem
suporte.
Editor de cores Cores em que aparecem no dispositivo.

Definir caixa de diálogo de cor (dispositivos)
Controles personalizados Suporte completo. Use Criar e exibir

classes e tipos Para adicionar atributos
Controles *User
personalizados de designer.
*Docking controles em Windows Forms HOW TO: Dock controles em Windows

Forms

*Data criar suporte Dados em projetos de dispositivos
gerenciados
Editor fonte Fontes como suporte para a plataforma

atual. Caixa de diálogo Editor fonte
(dispositivos)
Formulário suporte fator, incluindo orientação e Caixa de diálogo de propriedades fator

resolução. (Dispositivos) de formulário
*Autoscale
Capa formulário com a criação de código Caixa de diálogo de propriedades fator

(Dispositivos) de formulário
*New controles e Components na Toolbox WebBrowser, Notification, DocumentList,

DateTimePicker, MonthCalendar,
LinkLabel, Splitter, BindingSource
WYSIWYG específicos de plataforma Designers aprimorados fornecem precisa

aparência para cada plataforma.
Destinos versão 1.0 do .NET Compact Framework Suporte Smartphone 2003 e Pocket PC
2003
Alterar plataformas usando o mesmo código de fonte Como Compartilhar Código Fonte Através
de Plataformas (Dispositivos)
Consulte também
Referência
Como Iniciar o Emulador de Dispositivo no Visual Studio

O emulador de dispositivo pode servir como um substituto para um dispositivo físico durante
grande parte do ciclo de desenvolvimento de um projeto de dispositivo inteligente. O emulador de
dispositivo oferece suporte várias opções, como especificar tamanho RAM, mas nem todos os
SDKs suporte todas as opções. Verifique a documentação do SDK para obter detalhes.
Para obter mais informações, inicie o emulador de dispositivo e clique em Help.
Para iniciar o emulador de dispositivos usando conectar para caixa de diálogo Dispositivo
1. No menu visual studio Tools, clique em Connect to Device.
2. Na caixa Connect to Device de diálogo, selecione um emulador na caixa Devices, e
clique em Connect
Para iniciar o emulador dispositivo usando o Gerenciador de emulador de dispositivo
1. No menu visual studio Tools, clique em Device Emulator Manager.
2. Na Device Emulator Manager janela, clique com botão direito o emulador você deseja
iniciar.

3. No menu de atalho, clique em Connect.
Visão geral do acesso de dados (projetos do dispositivo

gerenciado)
O Visual Studio ambiente para desenvolvimento de projetos de dispositivo que manipulam dados
é semelhante do ambiente para desenvolver aplicativos de dados do computador de mesa.
Aplicativos de dados gerenciado para dispositivos contam com ADO.NET espaços para nome
suporte para o.NET Compact Framework. Essa combinação presta se a aplicativos onde o
armazenamento de dados no dispositivo normalmente será desconectado de dados em um
servidor, e é sincronizada somente periodicamente.
Dados de dispositivos: o que há de novo no Visual Studio 2005

• Você pode criar bancos de dados do SQL Server Mobile, atribuir senhas, alterar
esquemas, e executar outras tarefas de gerenciamento banco de dados fundamental usando o
Visual Studio IDE
• Você pode usar DataSets digitados, ResultSets, objetos comerciais, SQL Server bancos
de dados, bancos de dados do SQL Mobile, ou serviços da Web como fontes de dados.
• Você pode arrastar e soltar essas fontes de dados de janela fontes de dados para um
formulário do Windows para gerar controles ligados a dados de sua escolha.
Observação
O Data Source Configuration Wizard não está disponível para projetos que destino versão 1.0
do .NET Compact Framework.
Arquitetura SQL Mobile Server
SQL Server Mobile representa o mecanismo de dados local melhor para dispositivos que são
conectados apenas ocasionalmente. Você pode programar com o .NET Compact Framework para
aplicativos gerenciados ou Microsoft Visual C++ para dispositivos para aplicativos nativos. Para
obter mais informações, consulte SQL Server Mobile Architecture.
Uso Típico do SQL Server Mobile
SQL Server Mobile oferece uma solução para dados conectados ocasionalmente cenários de
acesso em dispositivos móveis. Cenários empresariais móveis com freqüência são necessárias
para trabalhar com dados quando a conectividade não está disponível. SQL Server Mobile aborda
esses cenários, fornecendo um armazenamento relacional Rich que pode ser sincronizado ao
SQL Server quando uma conexão está disponível. Para obter mais informações, consulte Typical
Uses of SQL Server Mobile.
Observação
Você pode usar o Microsoft SQL Server 2005 Mobile Edition como os dados armazenamento dos
aplicativos Tablet PC, bem como para aplicativos do dispositivo. Você também pode ser
executado-em laptops e desktops fornecido o Visual Studio 2005 ou SQL Server 2005 é instalado.
Para obter mais informações, consulte Building a SQL Server Mobile Application for Tablet PCs.
Recursos do SQL Server Mobile

SQL Server Mobile fornece uma grande quantidade de recursos, como parte de um aplicativo
.NET Compact Framework ou como uma instalação independente em um dispositivo inteligente.
Dados podem ser maniuplated offline e sincronizados posteriormente a um servidor. Para obter
mais informações, consulte SQL Server Mobile Features.
Criando e gerenciando bancos de dados SQL Server
Para desenvolver aplicativos de dados eficaz para dispositivos, é necessário um entendimento do

design do banco de dados boa e do mecanismo de banco de dados do SQL Server. Você deve
mestre como manter bancos de dados, como torná-los seguros, como acessar e modificar os
dados neles, como eficiente consultá-los, e como maximizar seu desempenho. Para obter mais
informações, consulte Working with Databases (SQL Server Mobile) e Enhancing Performance
(SQL Server Mobile).
Conexões com um servidor
SQL Server Mobile aceita a replicação de mesclagem, acesso remoto de dados, e planejamento
de segurança e implementação para o servidor. Para obter mais informações, consulte Managing
Connectivity (SQL Server Mobile).
Implementar tarefas comuns Programatically
Para obter as etapas para implementar as tarefas comuns através de programação, consulte How
to (SQL Server Mobile).
Segurança local
O mecanismo SQL Server Mobile Database oferece proteção por senha e criptografia para
proteger bancos de dados em dispositivos locais. Ele também fornece conectividade opções de
segurança. Para obter mais informações, consulte Securing Databases (SQL Server Mobile).
Visão geral Solutions do dispositivo de embalagem

Implantação é o processo por que você transferir um aplicativo ou componente para o dispositivo
de destino ou dispositivos que ele é destinado a executar. Antes você pode implantar a solução,
você deve compactá-la em um arquivo CAB. Um arquivo CAB é um tipo de arquivo de arquivo
executável que pode conter seu aplicativo, dependências, como DLLs, recursos, arquivos da
Ajuda, e qualquer outro arquivos você deseja incluir nele. Quando você cria o projeto CAB,
Microsoft Visual Studio 2005 gera um arquivo INF que é usado para criar o CAB. O arquivo INF
descreve qual pasta cada arquivo está para ser instalado em, quais versões do Windows CE
destina a executar, se o aplicativo o aplicativo tem permissão para ser desinstalado, e assim por
diante. Um nativo personalizado, você também pode incluir em seu arquivo CAB, dll para executar
qualquer personalizado instalar etapas, como verificação de número de versão para Windows CE
e assim por diante. ou a .NET Compact Framework, determinar se outros componentes estão
presentes, Depois que o CAB é copiado para o dispositivo de destino, o usuário toques nele para
iniciar o processo de instalação. Isso é chamado exploding o CAB.
Observação
Fornece Microsoft Visual Studio 2005 ferramentas para compactar o arquivo CAB. Ele não fornece
qualquer ferramenta para implantar o arquivo cab em um dispositivo de destino. Para cenários
simples, você pode arrastar um arquivo CAB da sua máquina desktop para o dispositivo usando
uma conexão do ActiveSync. Várias soluções de implantação de terceiros estão disponíveis para
situações mais complexas. Para obter mais informações, visite o Mobile e Embedded Application

Developer Center.
Torna Visual Studio 2005 possível, na maioria dos casos, para executar todos os o trabalho
necessário de embalagem diretamente no ambiente de desenvolvimento integrado Visual Studio
(IDE). Criar um arquivo CAB pelo primeiro adicionar um projeto inteligente CAB dispositivo à sua
solução existente, e adiciona o arquivos, atalhos e entradas do Registro a ele usando a mesma
interface do usuário como com projetos da instalação desktop. Quando você cria o projeto de
instalação, você criar o arquivo CAB.
Existem algumas diferenças entre os arquivos CAB que você criou para um aplicativo Pocket PC e
os você criar para um aplicativo de Smartphone. PCs de bolso baseados em Windows Mobile
2003SE e anteriores não ofereçam suporte compactados arquivos CAB ou arquivos CAB
assinado. Arquivos CAB Smartphone deve ser compactados e o arquivo exe ou dll, e o arquivo
cab em si, deve ser assinados digitalmente para que possa ser instalado no dispositivo.
Após ter criado o arquivo CAB com Visual Studio, a próxima etapa é para transferi-lo para o
dispositivo de destino usando qualquer um do meio típico de transferência de arquivos: através do
dispositivo, solicitações de FTP ou HTTP manual copiando o desenvolvimento de mesa máquina
para uma pasta em um dispositivo conectado usando o Windows Explorer, sobre a transferência
do ar (OTA) para Smartphones, e assim por diante.
Alternar plataformas em projetos de dispositivo

Você pode facilmente alternar a plataforma de destino. Por exemplo destino uma plataforma
Pocket PC 2003 ou uma plataforma Smartphone usando o mesmo projeto.
Para criar um projeto direcionamento várias plataformas no Visual C++, consulte:
• Destino várias plataformas em Native projetos de dispositivo

• Configurações do Gerenciador de configuração, Assistente para projeto de dispositivo
inteligente.
Para obter informações sobre como definir a plataforma de destino no Gerenciador de

configuração, consulte:
• Como criar um projeto de dispositivo Multiplatform (Visual C++):

• Configurações do Gerenciador de configuração, Assistente para projeto de dispositivo
inteligente.
Para mais informações sobre como trabalhar com recursos várias plataformas em um projeto
Visual C++, consulte Usar recursos em várias plataformas.
Ferramentas Remotas para Projetos de Dispositivos

As ferramentas remotos listadas abaixo estavam disponíveis no Visual C++ 4.0 incorporado e vêm
com Visual Studio 2005 para ajudá-lo a desenvolver e depurar aplicativos do dispositivo.
Clique Start na área de trabalho do Windows para iniciar essas ferramentas autônomo, aponte
para All Programs, aponte para Microsoft Visual Studio 2005, clique em Visual Studio Remote
Tools e selecione uma das ferramentas remotos a partir do menu.

Para Uso
Exibir e gerenciar o sistema de arquivos em um dispositivo de destino Visualizador de arquivos

(incluindo exportar e importar) remoto
Exibir informações sobre identificadores da pilha e sinalizadores para Dependency Walker da

cada processo em execução em um dispositivo de destino pilha remoto
Exibir informações sobre cada processo em execução em um Visualizar do processo

dispositivo de destino remoto
Exibir e gerenciar o Registro para um dispositivo de destino Editor do Registro

remoto
Exibir mensagens recebidas pelo janelas associadas aplicativos Spy remoto

executados em um dispositivo de destino
Capturar uma imagem tela em formato bitmap (.bmp) de um dispositivo In Zoom-remoto

de destino
Consulte também
Visão geral sobre segurança (dispositivos)

Dispositivos restringir a instalação e execução de aplicativos e acesso a recursos do sistema, com
base em configurações de diretiva de segurança e funções de segurança. Para que os aplicativos
sejam executados corretamente em determinados dispositivos, eles devem ser digitalmente com o
certificado adequado, e esse certificado deve estar presente no armazenamento de certificados do
dispositivo.
Quais arquivos devem ser assinado?
Prática práticas requer que Arquivos EXE, DLL, CAB, e MUI (Multilingual User Interface) ser
assinados. Em projetos gerenciados, arquivos do conjunto também devem ser assinados.
Modelos de segurança
Há também vários modelos de segurança que pode ser definido para executar em um dispositivo.
Os modelos de segurança diferentes podem restringir o acesso a aplicativos que não têm a
autorização apropriada. Para obter mais informações sobre dispositivo modelos de segurança,
consulte Guia do Desenvolvedor Smartphone Based Mobile-do Windows e Como Prover um
Dispositivo com um Modelo de Segurança.
Assinatura após Post-Build alterações binário
Se você executar uma etapa Post-Build que altera um binário, você precisa assinar novamente o
binário; ou seja, você deverá desativar assinatura Authenticode nas propriedades do projeto, e
entrar em vez disso como uma etapa Post-build. Esta ação é necessária porque nada que altera o
binário após ele está assinado invalida a assinatura. Assim, o binário deve ser assinado
novamente.

Configuração
Configuração um dispositivo se refere ao adicionar certificados digitais a armazenamentos de

certificados do dispositivo. Quando é feita uma tentativa para instalar ou executar um aplicativo no
dispositivo, o sistema operacional do dispositivo verifica para verificar se o certificado com o qual o
aplicativo está assinado é em um armazenamento de certificados para o dispositivo. Para obter
mais informações sobre armazenamentos de certificados, consulte Um Practical guia para a
segurança de aplicativos do Smartphone e código modelo assinatura para desenvolvedores.
• Smartphones são Pre-provisioneds por operadores móveis.

• Pocket PCs Windows Mobile 5.0-com base são Pre-provisioneds por OEMs; anteriores
Pocket PCs não foram normalmente.
• Imagens para o emulador de Visual Studio dispositivo são Pre-provisioned.
Para obter mais informações sobre configuração, consulte a documentação Smartphone ou

Pocket PC SDK.
Arquivos de certificado
Para ajudar a desenvolver aplicativos para uma variedade de modelos de segurança, Visual
Studio 2005 Inclui os seguintes arquivos de certificado, localizados, por padrão em \Program
Files\Microsoft 8\SmartDevices\SDK\SDKTools\TestCertificates Visual Studio:
• TestCert_Privileged.pfx
• TestCert_UnPrivileged.pfx
Esses arquivos.pfx conter o certificado e a chave particular correspondente. (Assinatura falhará se

você tentar assinar um aplicativo com um certificado que não tenha uma chave particular
correspondente.) Eles têm nenhuma senha.
Importar esses arquivos.pfx para o armazenamento de certificados pessoal no computador de

mesa. Se você tentar se importá-los para outro armazenamento (tais como o armazenamento de
autoridades de certificação raiz confiáveis), Visual Studio exibirá um aviso de segurança
detalhadas. Para obter mais informações, consulte Como Importar e Aplicar Certificados em
Projetos de Dispositivos.
Seleção método de conexão

Durante o desenvolvimento, ele é essencial para ter uma conexão entre o Smart Device e o
computador de desenvolvimento rápido e confiável. Embora as emuladores de dispositivo
inteligente podem ser usados em quase todos os estágios de desenvolvimento, teste o aplicativo
em uma peça de hardware do mundo real é uma parte vital do ciclo de desenvolvimento.
Muitas opções de conexão estão disponíveis, como resumidos posteriormente neste artigo. As
configurações mais comuns são:
• A conexão com o emulador dispositivo usando o transporte de DMA. Este transporte

elimina problemas de conexão de rede, e normalmente fornecido como o transporte padrão. Se
tiver algum motivo para usar outro transporte, grave Sempre usar o transporte de DMA para o
emulador de dispositivo.
• Conectando-se a um dispositivo físico usando o ActiveSync 4.x e uma porta USB.

Você pode acessar essas e outras opções no menu Visual Studio Ferramentas. Para obter mais
informações, consulte Como Configurar Opções de Conexão (Dispositivos).
O ActiveSync 4.x
4.X ActiveSync fornece uma conexão segura entre o computador de desenvolvimento e um

dispositivo usando cabo, base, Bluetooth, ou conexões via infravermelho. Ele também fornece o
veículo pelo qual necessário arquivos conexão e de segurança serão baixados automaticamente
para o dispositivo. Quando você Cradle um dispositivo, o ActiveSync desativa a todas as outras
placas de rede, para que você saiba o dispositivo está se comunicando somente com o
computador de desenvolvimento. O ActiveSync é o mecanismo conexão padrão enquanto você
desenvolver o aplicativo de dispositivo.
Se suporte ActiveSync for não disponível para o dispositivo, consulte Como se Conectar ao
Device do Windows CE sem o ActiveSync.
Opções de conexão
PCs de bolso, Smartphones, e outro hardware baseado em Windows CE oferece várias maneiras
de vincular um dispositivo e um computador. Nesta seção, as várias opções de conexão e suas
vantagens e desvantagens são discutidas.
O dispositivo de hardware envolvido, dependendo um ou mais dos seguintes métodos de conexão

podem ser empregado.
Conexão USB
A forma mais simples de conexão, todos os Pocket PC e Smartphone dispositivos

compatíveis com uma conexão USB. Embora não como rápida / a simplicidade da conexão
USB torna conexão g, uma opção atraente. como Ethernet ou sem fio 802. 11b Muitos
dispositivos também será ser alimentados por meio da porta USB, que é uma conveniência
adicionada.
Rede Ethernet com fio
Pocket PC e Smartphone dispositivos por padrão não oferecerem suporte para conexões
Ethernet sem hardware adicional. No entanto, a velocidade da conexão padrão extra torna
a maneira preferida para executar operações muito dados-depuração e outros.
Sem fio 802. 11b / rede g
Placas de rede sem fio estão disponíveis para PCs de bolso, e vários modelos agora vêm
com redes sem fio como um recurso integral. Redes sem fio são tão rápida como uma
conexão de rede Ethernet com fio.
Bluetooth
Dispositivos Pocket PC e Smartphone muitos recurso redes sem fio Bluetooth. O Smart
Device depois pares adequados, pode conectar sobre ActiveSync, desde que ele seja no
intervalo do computador de mesa. BLUETOOTH é Não como rápido como 802. 11b /. g
sem fio, e não é recomendada para depuração
Conexão serial

Se nenhum USB ou opções de rede com ou sem fio estiverem disponíveis, uma porta
serial torna aceitável, se lenta, uma maneira de se conectar um dispositivo inteligente a um
Conexão de infravermelho
Conexões via infravermelho requerem sem cabeamento adicional, e dispositivos Pocket

PC e Smartphone tanto vêm com portas IrDA como padrão. No entanto, conexões via
infravermelho requerem de linha de portadores para operar confiável, e mesmo assim o
desempenho não for aceitável para depuração. No entanto, IrDA pode ser útil como uma
técnica última recurso para copiar arquivos para dispositivos.
Atualizando Projetos Criados com Ferramentas Anterior

Fornece Microsoft Visual Studio 2005 ferramentas de desenvolvimento sofisticado para o
desenvolvedor de dispositivo inteligente. Programadores usando C# e Visual Basic agora podem
tirar proveito das ferramentas aprimorados oferecidos por Visual Studio 2005, e agora é possível
para criar um projeto C++ para um dispositivo Pocket PC, Smartphone ou Windows CE usando o
mesmo ambiente de desenvolvimento como é usado para criar aplicativos desktop.
Os aperfeiçoamentos para o Visual Studio 2005 ambiente de desenvolvimento, incluem:
• C# Código Fonte refatoração ferramentas. Para obter mais informações, consulte

Refatoração.
• Aprimorado depuração. Para obter mais informações, consulte Depurando projetos de
dispositivo.
• Código trechos para C# e Visual Basic. Para obter mais informações, consulte Criando e
usando IntelliSense Code Snippets.
• Ferramentas de Implantação aprimorado. Para obter mais informações, consulte Visão
geral Solutions do dispositivo de embalagem.
• Aprimorado emuladores de dispositivo inteligente. Para obter mais informações, consulte
Como Iniciar o Emulador de Dispositivo no Visual Studio.
Migrando projetos de eMbedded Visual C++ para Visual Studio 2005
Você pode migrar projetos Embeddeds Visual C++ utilizando um assistente de migração. Para
obter mais informações, consulte eMbedded Visual C++ ao Assistente para atualização 2005
Studio Visual.
Migrando projetos do Visual Basic Embedded para Visual Studio 2005
Projetos criados no Visual Basic (eVB) Embedded automaticamente não são convertidos em
Visual Studio 2005 Projetos. Em vez disso, você deve adicionar a fonte existente e arquivos de
recurso a um novo projeto criado no Visual Studio 2005 Visual Basic Smart Device.
Observação
Dispositivos Windows Mobile 2003 não contêm os tempos de execução eMbedded Visual Basic
em ROM, e os tempos de execução podem ser baixado para o dispositivo como uma instalação
RAM, embora essa configuração não é suportada.

Para obter mais informações sobre como usar Visual Studio 2005 Para converter um projeto eVB,
consulte os seguintes tópicos:
• Migrando eVB controles Arquivo para Visual Basic .NET

• Migrando formulários eVB para Visual Basic .NET
Migrando Managed projetos do Visual Studio .NET 2003 para o Visual Studio 2005
Visual C# e Visual Basic projetos de dispositivo inteligente desenvolvidos no Visual Studio .NET
2003 pode ser importado para Visual Studio 2005. O Assistente para conversão Visual Studio
torna as alterações necessárias para os projetos.
Atualizando projetos de dispositivos 2002 para dispositivos 2003
Para obter mais informações sobre como atualizar projetos para o Windows Mobile 2003 do
Windows Mobile 2000, consulte Windows Mobile Platform FAQ migração para desenvolvedores.
Selecionando uma Linguagem de Desenvolvimento

Ao desenvolver um aplicativo, controle ou biblioteca para implantação em um dispositivo
inteligente, há três linguagens de programação para escolher em: Visual C#, Visual Basic e Visual
C++.
Visual C#
C# é uma linguagem modernos, orientated objeto-. Seus recursos coleção de lixo e suporte para
as classes .NET Compact Framework tornam mais um idioma ideal para desenvolver aplicativos
móveis confiáveis e seguros. Visual C# para dispositivos inteligente inclui um número dos
controles para rapidamente criar uma interface de gráfica do usuário (GUI), e os recursos de
suporte classes Compact Framework como GDI +, XML, e serviços da Web grande. Visual C#
também pode chamar funções Windows CE nativas para situações não ofereçam suporte a .NET
Compact Framework.
Para obter mais informações sobre desenvolvimento com Visual C# e acessar nativas funções
Windows CE, consulte:
• Guia de Introdução ao Visual Studio .NET e o Microsoft .NET Compact Framework

• Referência C#
• Uma introdução para P / Invoke e Marshaling no Microsoft .NET Compact Framework
• Criar uma biblioteca P / Invoke
• Avançado P / Invoke em Microsoft .NET Compact Framework
Visual Basic
Visual Basic para dispositivos inteligentes é uma implementação completa do Visual Basic, e é
consideravelmente mais potentes que a ferramenta de desenvolvimento anterior, eMbedded
Visual Basic. Visual Basic bastante simplifica a tarefa de portabilidade um aplicativo da área de
trabalho para um dispositivo móvel, ou criando um aplicativo cliente rico-rapidamente. Com Visual
C#, Visual Basic faz uso do .NET Compact Framework. Os desenvolvedores já familiarizados com
o Visual Basic será capaz para porta aplicativos existentes ou criar novos muito rapidamente.
Como com C#, Visual Basic pode acessar nativas funções Windows CE.
Para obter mais informações sobre como desenvolver no Visual Basic, consulte:

• Guia de Introdução ao Visual Studio .NET e o Microsoft .NET Compact Framework
• Referência do Visual Basic
Visual C++
Visual C++ é o idioma preferencial de desenvolvimento para dispositivos inteligentes quando

Desempenho é crítico, ou quando estiver desenvolvendo aplicativos no nível do sistema, drivers
de dispositivo ou hoje ou Home tela plug-ins. Visual C++ não oferece suporte .NET Compact
Framework, mas em vez disso, fornece um subconjunto do conjunto da API do Win32. Não é
possível para aplicativos escritos em gerenciado C# ou código do Visual Basic para acessar
código C++ contido em DLLs por meio do Interop.
Para obter mais informações sobre como desenvolver no Visual C++, consulte:
• C/C++ Languages
Passo-a-passo: Criando aplicativos do Windows Forms para um dispositivo
Nessa explicação passo a passo, você cria um aplicativo Windows Forms simples usando Visual
Basic ou Visual C#. e execute o aplicativo em um emulador Pocket PC Essa explicação passo a
passo demonstra a principal diferença entre Área de trabalho e dispositivo programação, ou seja,
que você deve selecionar um dispositivo. Neste passo-a-passo, o dispositivo é um emulador
interno do Pocket PC 2003.
Observação
Essa explicação passo a passo foi escrito usando configurações de desenvolvimento do Visual
Basic e Visual C# configurações Development.
Essa explicação passo a passo consiste de cinco tarefas principais:
• Criar um projeto de dispositivo que usa Windows Forms.

• Adicionando um controle ao formulário.
• Adicionando manipulação eventos ao controle.
• Selecionar um dispositivo no qual será executado o projeto.
• Criação e implantação o aplicativo para o dispositivo.
Escolher um dispositivo de destino
Para garantir que você será solicitado para selecionar um dispositivo quando você implantar a
solução, conclua o procedimento a seguir.
Para solicitar para opções do dispositivo no momento da implantação
1. Clique Options no menu Tools, e Device Tools Clique em General. (Está na parte inferior
da caixa Options de diálogo não visível, selecione Show all settings se Device Tools.)
2. Marque a Show device choices before deploying a device project caixa de seleção.

Criando o aplicativo
Criando um projeto do Windows Forms,, bem como adicionar controles e tratamento de eventos,
segue o mesmo processo para projetos de dispositivo como faz para projetos de mesa. A principal
diferença você encontrar é o menor número de classes disponíveis no .NET Compact Framework.
Para criar um projeto de dispositivo que usa Windows Forms
1. (Visual Basic) No menu File no Visual Studio 2005, clique em New Project.
ou ——
(Visual C#) No menu File do Visual Studio 2005, aponte para New, e clique em Project.
2. Project Types Na caixa New Project de diálogo, expanda Visual Basic ou Visual C#
expandir Smart Device, e clique em Pocket PC 2003.
Se não o idioma a ser exibido, não no primeiro expandir Other Languages. Esta tela é
regida por suas configurações de desenvolvimento.
3. Em Templates, clique em Device Application.
4. Na caixa Name, digite DeviceSample, e depois clique em OK.
5. (C Visual #) somente Na caixa Location, Verifique onde você deseja armazenar seus
arquivos de projeto, e clique em OK.
Aparece uma representação de um dispositivo Pocket PC no Windows Forms Designer.
Para adicionar um controle para o formulário
1. Do Toolbox, arraste um Button controle no formulário.

Se clique Toolbox no menu View. não estiver visível, o Toolbox
Se não esteja visível no Toolbox, clique com botão direito na Device Controls guia e clique
em Show All. o Toolbox,
2. Clique com o botão direito do mouse o Button controle e clique em Properties.
3. Na janela Properties, digite Say Hello, e pressione ENTER para definir a Text
propriedade.
Para adicionar tratamento de eventos para o controle Botão
1. Clique duas vezes no botão no formulário.

Abre o editor de códigos com o ponto de inserção posicionado do evento manipulador.
2. Insira o seguinte código Visual Basic:
MessageBox.Show("Hello, World!")
ou ——
Insira o seguinte código C#:
MessageBox.Show("Hello, World!");
Criação e teste o aplicativo
Nesse ponto, você encontrar uma diferença de projetos de mesa. Em um projeto de dispositivo,
você pode escolher entre vários destinos onde o projeto é para executar normalmente. Nessa
explicação passo a passo, você escolher um emulador Pocket PC. Se você tiver um dispositivo

físico com suporte já em parceria com o computador de desenvolvimento, você também poderá
escolher o dispositivo físico.
Para criar e testar o aplicativo
1. No menu Debug, clique em Start (ou Start Debugging).

2. Na caixa Deploy de diálogo, selecionar Pocket PC 2003 SE Emulator, e clique em
Deploy
Você pode exibir progresso na barra de status.
3. Quando o aplicativo é executado no emulador, toque no botão para garantir que " Hello,
World! " aparece.
Preparando para Walkthroughs adicionais
Se você pretende fazer orientações adicionais ou abrir outros projetos, você deseja desligar
completamente o emulador e sair desta solução.
Para fechar o emulador e a solução
1. No menu File do emulador, clique em Exit.

2. Na caixa Device Emulator de mensagem, clique em No para a mensagem Save State
Before Exiting?
3. No menu Visual Studio Debug, clique em Stop Debugging.
4. Se uma mensagem aparecer informando que a conexão foi perdida, clique em OK.
5. No menu File, clique em Close Solution.
Consulte também
Programação para Dispositivos usando o .NET Compact

Framework
Esta seção fornece informações sobre como desenvolver aplicativos de dispositivo inteligente
usando a linguagem Visual Basic ou C# e o .NET Compact Framework.
Nesta seção
O que há de novo no Managed projetos de dispositivo
Lista alterações importantes desde Visual Basic .NET 2003.
Diferenças do desktop no .NET Framework Development compacto
Descreve diferenças de desenvolver aplicativos desktop.
Compactar variações do .NET Framework versões
Descreve as várias versões do .NET Compact Framework, incluindo service packs.
Diferenças entre Pocket PC 2003 e controles Smartphone 2003
Apresenta um mostrando de tabela quais controles há suporte para desenvolvimento

Pocket PC 2003 e que há suporte para desenvolvimento Smartphone 2003.

Controles e Components em projetos de dispositivo gerenciado
Descreve controles adicionais e componentes disponíveis para o desenvolvimento de

dispositivo.
Personalizadas e controles de usuário em projetos de dispositivo
Descreve a funcionalidade disponível para projetos de dispositivo.
Interoperabilidade com para dispositivos
Descreve como criar conjuntos Interop COM em um projeto dispositivo gerenciado.
Criando e desenvolvendo Managed projetos de dispositivo
Fornece instruções passo a passo para dispositivo comum tarefas de desenvolvimento.
Dados em projetos de dispositivos gerenciados
Descreve como gerenciar dados para dispositivos no Visual Studio 2005.
Criando um aplicativo Simple Walkthrough:
Fornece instruções passo a passo sobre como criar um projeto de dispositivo Visual Basic
ou Visual C# simples
Referência do .NET Compact Framework para Projetos de

Dispositivos
O .NET Compact Framework é um subconjunto da biblioteca de classes do .NET Framework e
também contém classes exclusivamente criadas para ele. Ele herda a arquitetura completa do
.NET Framework com o Common Language Runtime e a execução de código gerenciada.
Como: Criar aplicativos de dispositivo usando o Visual Basic ou Visual C#
Criação Visual Basic e Visual C# gerenciados projetos para segue dispositivos o mesmo gerais
processa como criar projetos para área de trabalho, exceto que você deve selecionar um
plataforma de destino (por exemplo, Pocket PC 2003) e Versão .NET Compact Framework (v2.0
Por exemplo,) no qual o projeto é projetado para ser executado.
Uma caixa de diálogo Avançado New Project em Visual Studio 2005 substitui inteligente
dispositivo Assistente aplicativo Visual Studio .NET 2003. No Visual Studio 2005, você fazer todas
as escolhas sobre tipos de projeto e Modelos na caixa New Project de diálogo.
Observação
Opções disponíveis em caixas de diálogo e comandos de menu diferem dependendo as

configurações ativa, também conhecido como seu perfil. O procedimento a seguir foi escrito
usando configurações de desenvolvimento do Visual Basic e Visual C# configurações
Development. Para exibir ou alterar as configurações, escolha Import and Export Settings No
menu Tools.
Para criar um projeto de dispositivo

1. (Visual Basic) No menu File em Visual Studio 2005, clique em New Project.
ou ——
2. Project Types Na caixa New Project de diálogo, expanda Visual Basic Projects ou
Visual C# Projects expandir Smart Device, e a plataforma desejados, como, Pocket PC
2003 clique em.
regida pelo suas configurações de desenvolvimento. Para exibir ou alterar as configurações,
clique Import and Export Settings no menu Tools.
3. Em Templates, clique em qualquer modelo é adequado para o que você deseja, por
exemplo, Pocket PC 2003 Class Library.
Observação
Um modelo que tem (1.0) seu nome é desenvolvido para versão 1.0 do .NET Compact
Framework. acrescentado ao Outros modelos são criados para versão 2.0.
4. Na caixa Name, digite um nome para o projeto.

Se uma Location caixa for exibida, verifique onde você deseja armazenar os arquivos de
projeto, e, em seguida clique em OK.
Para adicionar um projeto a uma solução existente
• No menu File, aponte para Add, e clique em New Project ou Existing Project.
O New Project comando abre a New Project caixa de diálogo para que você possa criar um
novo projeto. O Existing Project comando abre a Add Existing Project caixa de diálogo para
que você possa selecionar um projeto já existente para inclusão à solução atual.
Para Porta projetos existentes
• As etapas para portabilidade projetos criados em uma versão anterior do Visual Studio são
descritas na documentação geral Visual Studio Para gerenciar projetos. Para obter mais
informações, consulte Projetos e a compatibilidade com versões anteriores e Trabalhando com
várias versões do .NET Framework.
Como Compartilhar Código Fonte Através de Plataformas (Dispositivos)
Você pode compartilhar código-fonte em plataformas usando constantes do compilador para

diferenciar essas seções de código que dependem do destino. Constantes permitidos são
PocketPC, Smartphone,. e WindowsCE As plataformas devem direcionar a mesma versão do
.NET Compact Framework.
As etapas a seguir fornecem um exemplo simples da técnica. Você criar um aplicativo do Visual
Basic Pocket PC, adicionar diretivas de compilador, executar o aplicativo, fechá-la, e alterar para
um aplicativo de Smartphone. Você executar o aplicativo Smartphone para ver essa o texto da
barra de título será alterado.
Observação

Para criar e executar a versão Pocket PC

1. No menu visual studio File, aponte para New, e clique em Project.
2. Expanda Visual Basic no painel Project types,, e Smart Device Clique em Pocket PC
2003.
3. No painel Templates, clique em Device Application (1.0), e clique em OK
O acrescentadas (1.0) indica que este é um projeto .NET Compact Framework versão 1.0.
4. No designer, clique com o botão direito do mouse no formulário e no menu de atalho,
clique em Properties
5. Desmarque o Text valor da propriedade do formulário — ou seja, facilitam em branco.
6. No Solution Explorer, clique com o botão direito do mouse Form1.vb e depois no menu
de atalho, clique em View Code.
7. Expanda a Windows Form Designer generate code região.
8. Após InitializeComponent() em pública New() Sub, insira o código a seguir:
#If PocketPC Then Me.Text = "PPC2003" #Else Me.Text = "Smartphone" #Endif
9. No menu Debug, clique em Start Debugging.

10. Na caixa Deploy <Projectname> de diálogo, clique em Pocket PC 2003 SE Emulator, e
clique em Deploy
O aplicativo Pocket PC é executado no emulador com PPC2003 na barra de título do
formulário.
Para criar e executar a versão Smartphone
1. Feche o emulador sem salvar estado.
Se uma mensagem for exibida indicando que a conexão foi perdida, clique em OK.
2. No menu Project, clique em Change Target Platform.
3. Na caixa Change to Na caixa Change Target Platform de diálogo, selecione
Smartphone2003, e depois clique em OK.
4. Na mensagem caixa avisando que o projeto será fechado e reaberto, clique em Yes.
Observe que a caixa Dispositivos de destino na barra de ferramentas agora exibe
Smartphone 2003 SE Emulator.
5. No menu Debug, clique em Start Debugging.
6. Na caixa Deploy <Projectname> de diálogo, clique em Smartphone 2003 SE Emulator,
e clique em Deploy
O aplicativo Smartphone é executado no emulador com Smartphone na barra de título do
formulário.
Como Alterar Plataformas em Projetos de Dispositivos
Você pode alternar constantemente entre plataformas no mesmo projeto. Por exemplo, se o
objetivo for uma plataforma Pocket PC, você pode alternar para direcionar uma plataforma
Windows CE,, desde que a nova plataforma atinge a mesma versão do .NET Compact Framework
como o destino original.
Para alterar plataformas de destino em um projeto de dispositivo

1. No menu Project, clique em Change Target Platform.
2. Na caixa Change to, selecione uma plataforma diferente, e clique em OK
Somente as plataformas disponíveis são aquelas que destino a mesma versão do .NET
Compact Framework como o projeto ativo.
Como Atualizar Projetos para Versões Posteriores do .NET Compact Framework
Este procedimento atualiza a versão .NET Compact Framework de um projeto existente se uma
versão posterior do .NET Compact Framework é instalado no computador do desenvolvimento.
Para atualizar um projeto para uma versão posterior do .NET Compact Framework
1. No menu Project, clique em Upgrade Project.
Observação
Se o Upgrade Project Comando não aparecer no menu, nenhuma versão posterior da plataforma
está instalado no computador de desenvolvimento, e o processo de atualização não está
disponível para o projeto atual.
2. Siga as instruções no prompt que aparece.
Gerenciando Trechos de Código em Projetos Dispositivos

Visual Basic inclui uma biblioteca de código do IntelliSense trechos de código que você pode
inserir com alguns cliques do mouse para o aplicativo. Cada trecho executa uma tarefa de
programação completa. Você pode também criar seus próprios trechos de código, adicioná-los
para a biblioteca, e então usá-las ao precisar deles.
adicionou Visual Studio trechos que pertencem exclusivamente para projetos de dispositivo. Os
atalhos para esses trechos todos começam com os caracteres SD. Para obter mais informações,
consulte Trechos de Código IntelliSense Visual Basic.
Como Verificar Suporte de Plataforma para Código em Projetos de Dispositivos
Sempre Visual Studio valida que seu código dá suporte para a plataforma de destino e gera
avisos se ele não estiver.
Você pode interromper código sem suporte de implantação por stipulating que todos os avisos
devem ser tratados como erros, para que a compilação falhar.
Mesmo que ela compila, por exemplo, o seguinte código Visual Basic, seria gerar um aviso ou erro
em um aplicativo Smartphone porque Smartphone não oferece suporte botões.
Dim btn as System.Windows.Forms.Button
btn = new System.Windows.Forms.Button()
btn.Caption = "MyButton"
Para tratar todos os avisos como erros no Visual Basic

1. No Solution Explorer, clique com o botão direito do mouse <Projectname> e depois no
menu de atalho, clique em Properties.
2. Na guia Compile, selecione Treat all warnings as errors.
Para tratar todos os avisos como erros no Visual C#
2. Na guia Build, selecione All na seção Treat warnings as errors.
Como Manipular Eventos do HardwareButton (Dispositivos)
Usar um HardwareButton controle para substituir as teclas do aplicativo em um PC de bolso.
Para atribuir um componente HardwareButton a uma chave aplicativo específico

1. Na guia Device Components da Toolbox, arraste um HardwareButton componente em
um formulário do Windows ou na bandeja componente no designer.
2. Na Bandeja de componente, clique com o botão direito do mouse no HardwareButton
controle e no menu de atalho, clique em Properties
3. Defina a AssociatedControl propriedade para o formulário, por exemplo, Form1.
4. Defina a HardwareKey propriedade para a chave você deseja substituir, por exemplo,
ApplicationKey1.
5. Clique no botão, por exemplo, Soft Key 1. na capa do designer
O editor de código abre no manipulador Form_KeyDown de eventos.
6. Insira o código a seguir:
if ((int) e.KeyCode == (int) Microsoft.WindowsCE.Forms.HardwareKeys.ApplicationKey1) { //TODO
}
Normalmente você deve usar a //TODO seção para iniciar um aplicativo.
Como: Alterar a orientação e resolução de formulários (Dispositivos)
Propriedades orientação (rotação) padrão já são definidas para plataformas instaladas com Visual
Studio. Use as etapas a seguir se você precisar alterar as propriedades ou se você tiver instalado
um SDK em que essas propriedades estão incorretas ou lacking.
Para alterar a orientação

1. Clique Options no menu Tools, e Device Tools Clique em Form Factors.
2. Selecione o fator — de formulário por exemplo, Pocket PC 2003 Portrait — para o
formulário no projeto, e depois clique em Properties.
3. Selecione Show skin in Windows Forms Designer e Enable rotation support.
4. Clique OK para fechar a Form Factor Properties caixa de diálogo e clique OK novamente
para fechar a Options caixa de diálogo.
Observação
Se o designer foi aberto quando você alterou opções, feche e reabri-la para as alterações sejam
efetivadas.

5. Clique com botão direito no designer, mouse o formulário ou a capa, e seguida, selecione
Rotate Left ou Rotate Right para girar a capa.
Se o formulário gira quando o dispositivo gira depende na plataforma atual e das definições
de propriedade de formulário, da seguinte maneira:
o Smartphone: O formulário sempre gira quando gira o dispositivo.
o Pocket PC: O formulário gira por padrão quando o dispositivo gira. Para impedir
que o formulário de girar com o dispositivo, defina a WindowState propriedade do
formulário para Normal e a FormBorderStyle propriedade None.
o O formulário Windows CE: Não não girar por padrão quando o dispositivo gira. Para
tornar o formulário giram com o dispositivo, defina a WindowState propriedade como
Maximized.
Para alterar resolução
1. Clique Options no menu Tools, e Device Tools Clique em Form Factors.
2. Selecione o fator — de formulário por exemplo, Pocket PC 2003 Portrait — para o
formulário no projeto, e depois clique em Properties.
3. Na caixa Form Factor Properties de diálogo, definir a resolução vertical e horizontal.
4. Clique OK para fechar a Form Factor Properties caixa de diálogo e clique OK novamente
para fechar a Options caixa de diálogo.
Observação
Se o designer foi aberto quando você alterou opções, feche e reabri-la para as alterações sejam
efetivadas.
Como Alterar o Dispositivo Padrão (Projetos Gerenciados)
Use as seguintes etapas para alterar o dispositivo de destino padrão em projetos gerenciados.
Para selecionar um novo dispositivo de destino padrão para um projeto gerenciado

1. No Solution Explorer, clique com o botão direito do mouse <Project name>.
2. No menu de atalho, clique em Properties e selecione o Devices painel.
3. Use a lista drop-down na caixa Target device Para selecionar um novo destino padrão.
Como Otimizar a Ajuda para o Desenvolvimento de Dispositivos Inteligentes
Se você selecionou Minimum ou Custom quando você instalou a Biblioteca MSDN para Visual
Studio, você não terá todos os Visual Studio 2005 arquivos da Ajuda que estão disponíveis para
os desenvolvedores de dispositivo inteligente. Especificamente, a Minimum instalação não inclui
seção Mobile e Embedded Development da biblioteca.
A seção Mobile and Embedded Development inclui esses materiais como Pocket PC e
Smartphone SDK documentação, informações Windows CE, e assim por diante. Tópicos na seção
geralmente são referenciados pela tópicos na seção Visual Studio inteligente Development
dispositivo, da qual está sempre instalado e concentra-se no uso do Visual Studio ambiente para
desenvolver aplicativos de dispositivo inteligente. Os procedimentos a seguir mostram como
determinar o que ajuda você instalou, como adicionar Mobile e Embedded Development ajuda, e
como filtrar ajuda.
Para verificar se a seção Mobile and Embedded Development ajuda está instalado

• Clique em Pocket Guia do Desenvolvedor PC.
Se o tópico é exibido, a seção Mobile and Embedded Development está instalada.
Se o tópico não for encontrado, você pode adicionar a seção Mobile and Embedded
Development, seguindo as etapas abaixo.
Para incluir tópicos Mobile e Embedded Development
1. No Painel de controle, Windows clique em Add or Remove Programs.
2. Selecionar MSDN Library for Visual Studio 2005, e, em seguida clique em Change.
3. Na página Welcome da clique Setup WizardNext,.
4. Na página Program Maintenance, clique em Modify.
5. Na página Custom Setup, selecione Mobile and Embedded Development.
6. No menu de atalho disponível a partir do botão drop-down, selecione This feature, and all
subfeatures, will be installed on local hard drive.
7. Clique em Next.
8. Na página Ready to Modify the Program, clique em Install.
Filtragem tópicos da Ajuda
Fornece Visual Studio um filtro inteligente Development dispositivo para o índice de Conteúdo e
índice. Quando você aplica esse filtro, os tópicos visíveis são reduzidos para incluir apenas
documentação considerada básica para os desenvolvedores de dispositivo inteligente. Mais
importante, aplicar este filtro é uma maneira excelente para exibir somente os subconjuntos de
dispositivo inteligente de tópicos de referência em tempo de execução, incluindo .NET Compact
Framework e as bibliotecas da MFC e ATL.
Se você aplicar um filtro de idioma (por exemplo, C Visual) #, tópicos de desenvolvimento de

dispositivo inteligente são excluídos dos tópicos visíveis. Por esse motivo é melhor para usar o
filtro inteligente Development dispositivo ou nenhum filtro em todos os. Observe também que um
filtro de idioma é atribuído pelo padrão caso você tenha efetuado logon para Visual Studio usar
uma configuração de desenvolvimento de idioma, como configurações Development Visual C#.
Para definir o filtro inteligente Development dispositivo
1. No menu visual studio Help, clique em Contents ou Index.

2. Na caixa Filtered by, selecione Smart Device Development.
Para alterar a configuração de desenvolvimento
1. No menu visual studio Tools, clique em Import and Export Settings.

2. Na página Welcome do assistente, clique em Reset all settings, e clique em Next
Se você não tiver certeza da suas opções, pressione F1 para abrir o tópico da Ajuda para o
assistente.
3. Na página Save Current Settings, selecione se deseja salvar as configurações atuais, e
clique em Next.
4. Na página Choose a Default Collection of Settings, selecionar General Development
Settings, e clique em Finish
Como se Conectar ao Emulador de Dispositivo a partir de uma Sessão de PC Virtual

Você não pode usar TCP / IP para conectar ao emulador de dispositivo durante uma sessão
virtual PC (VPC) porque VPC não oferece suporte o driver virtual chave de rede. O emulador
precisa esse driver para uma conexão TCP / IP. Em vez disso, use as etapas a seguir.
Observação
Para conectar-se para o emulador durante uma sessão Virtual PC

1. Instalar 4.x Microsoft ActiveSync na imagem Virtual PC.
2. No menu do ActiveSync File, clique em Connection Settings.
3. Na caixa Connection Settings de diálogo, altere o transporte de conexão para DMA.
4. Inicie o emulador.
6. Na caixa Available Emulators, clique com o botão direito do mouse o emulador desejado,
e clique Cradle no menu de atalho
7. Siga as instruções no Assistente do ActiveSync para estabelecer uma parceria.
Como Acessar o Sistema de Arquivos do Emulador do Smartphone
O emulador Smartphone tenha nenhum Explorer arquivo. Use a técnica a seguir para acessar o
sistema de arquivos Smartphone. Para concluir o processo, você deve ter o ActiveSync 4.0 ou
posterior instalado.
Antes de tentar usar o ActiveSync com um emulador, certifique-se de que nenhum dispositivo
esteja conectado ao computador de mesa e que conexões USB estão desativadas no ActiveSync.
Observação
Se você fechar o Gerenciador de emulador de dispositivo ou feche o emulador após concluir as

etapas a seguir, a conexão ActiveSync também fecha.
Para acessar o sistema de arquivos do emulador Smartphone

2. Na caixa Available Emulators, selecione o emulador cujo sistema arquivos você deseja
acessar.
3. No menu Gerenciador Actions de emulador de dispositivo, clique em Connect.
Um ícone aparece ao lado o emulador selecionado indicando que uma conexão foi feita.
4. Clique com o botão direito do mouse o emulador selecionado, e, em seguida clique em
Cradle.
As alterações ícone para mostrar o emulador está aninhado.
5. Abra o ActiveSync.

7. Marque a Allow connections to one of the following caixa de seleção.
8. Selecione DMA a partir da lista de portas, e depois clique em OK.
O ActiveSync agora inicia uma parceria com o emulador. Siga as instruções fornecidas pelo
New Partnership Wizard.
Observação
Se uma parceria não é iniciada automaticamente, clique Connect na caixa Connection Settings
de diálogo, e siga os prompts no Get Connected Wizard.
9. Depois você concluiu as etapas de parceria ActiveSync, clique em Explore Barra de

Ferramentas ActiveSync para acessar o sistema de arquivos do emulador Smartphone no.
Observação
Sempre que desejar para usar um emulador conectado com Visual Studio usando o ActiveSync,
usar o dispositivo, emulador, destino da plataforma correspondente não.
Como se Conectar Usando Bluetooth
As etapas a seguir descrevem como se conectar um dispositivo a seu computador de

desenvolvimento com o Bluetooth. Para concluir o processo, você deve ter o ActiveSync 4.0 ou
posterior instalado.
Para se conectar usando Bluetooth

1. No computador de desenvolvimento, verifique é que a antena Bluetooth corretamente
inserido e instalado.
2. Na caixa de diálogo Propriedades Bluetooth no computador de desenvolvimento, altere a
descoberta para ON.
3. No dispositivo, toque no ícone Bluetooth, e toque em Turn Bluetooth ON.
4. Toque Bluetooth Manager.
5. No menu Janela Bluetooth, clique New Para iniciar uma pesquisa por dispositivos
habilitados Bluetooth-.
6. Selecione o computador de desenvolvimento que você deseja se conectar usando o
ActiveSync.
7. Quando solicitado, digite uma chave de acesso temporário, e digite a mesma chave de
acesso no computador de desenvolvimento rapidamente.
Você agora ter uma conexão Bluetooth com o dispositivo. Para configurar o ActiveSync,
você criar uma porta COM Virtual para esta conexão Bluetooth. Use as etapas a seguir.
Para configurar ActiveSync
1. No computador de mesa, vá na configuração Bluetooth e adicione uma porta COM de
entrada para a conexão Bluetooth.
2. No ActiveSync, abrir a Connection Settings caixa de diálogo, e selecione Allow
connections to one of the following.
3. Selecione a porta COM do dispositivo Bluetooth, e clique em OK
4. No dispositivo, inicie o ActiveSync.

5. No menu do ActiveSync, toque Connect via Bluetooth.
Agora você deve ter uma conexão do ActiveSync.
Como se Conectar Usando Infravermelho
As etapas a seguir descrevem como se conectar um dispositivo a seu computador de

desenvolvimento com porta de infravermelho (IR). Para concluir o processo, você deve ter o
ActiveSync 4.0 ou posterior instalado.
Para configurar o computador de desenvolvimento

1. No computador de desenvolvimento, abra o Microsoft ActiveSync.
3. Selecione Allow connections to one of the following.
4. Selecionar Infrared Port (IR), e, em seguida clique em OK.
Para configurar o dispositivo
1. Verifique se o dispositivo Porta de INFRAVERMELHO está apontando para o computador
de desenvolvimento, porta de INFRAVERMELHO e está no intervalo boa.
2. No dispositivo, abra o ActiveSync.
3. No menu do ActiveSync Tools, toque Connect via IR.
A conexão é estabelecida.
Como se Conectar ao Device do Windows CE sem o ActiveSync
Não automaticamente quando não estiver disponível, Visual Studio 2005 o ActiveSync não copiar
arquivos de conectividade necessários, como um CEPC, para o dispositivo. Siga estas etapas
para instalar esses arquivos no dispositivo, modificar a Visual Studio configuração de conexão, e
estabelecer segurança do dispositivo.
As duas primeiras etapas preparação do dispositivo e Visual Studio, necessidade de ser feito
apenas uma vez. O último conjunto de etapas, configuração de segurança e estabelecer a
conexão, deve ser repetido sempre que você quer se conectar de uma nova instância do Visual
Studio.
Para preparar o dispositivo de conexão

1. Usando qualquer conexão com o dispositivo você possui, copie os seguintes arquivos para
a pasta \Windows\ no dispositivo. These files are located on the development computer by
default at \Program Files\Common Files\Microsoft
Shared\CoreCon\1.0\Target\wce400\<CPU>.
o Clientshutdown.exe
o ConmanClient2.exe
o CMaccept.exe
o eDbgTL.dll
o TcpConnectionA.dll
2. A partir do prompt de comando no dispositivo, execute conmanclient2.exe.
3. Determinar o endereço IP do dispositivo.
Para preparar Visual Studio para conectar
1. No menu visual studio Tools, clicar Options, clicar Device Tools, e clique em Devices.

2. Selecionar Windows CE Device, e, em seguida clique em Properties.
3. Para direita caixa Transport, clique em Configure.
4. Na caixa Configure TCP/IP Transport de diálogo, selecionar Use specific IP address, e
digite o endereço IP do dispositivo.
5. Feche as caixas de diálogo.
Uma caixa de mensagem pode exibida solicitando que você para redefinir o dispositivo.
Nesse caso, uma redefinição de disco é suficiente.
Para definir a segurança e estabelecer a conexão
1. No prompt de comando no dispositivo, execute cMaccept.exe.
2. Se em três minutos, conectar o dispositivo.
Se você estabelecer a sua primeira conexão em três minutos, você pode continuar
implantação e depuração indefinidamente, desde que você estiver usando a mesma Visual
Studio instância. Se você precisa se conectar de outra instância do Visual Studio, você
precisará executar essas etapas de segurança novamente.
Você pode eliminar a etapa cMaccept, desativando a segurança no dispositivo. Do Editor do

Registro remoto para fazer isso, use para definir HLKM\CoreConOverrideSecurity = 1. Desativar
segurança expõe seu dispositivo para ataques mal-intencionados e não é recomendado a menos
que você tiver fornecido proteções apropriadas.
Como Acessar Arquivos de Computador de Desenvolvimento a partir do Emulador
As etapas a seguir demonstram como usar Pasta compartilhamento para acessar arquivos no
computador de desenvolvimento do emulador de dispositivo.
Observação
Emuladores Smartphone normalmente não tem visualizadores de arquivo para o visualizador

arquivos remota é usado no Smartphone teste etapas a seguir. Para obter mais informações,
consulte Visualizador de arquivos remoto.
Para configurar uma pasta compartilhada

1. No computador de desenvolvimento, crie uma pasta a ser compartilhada entre o
computador de desenvolvimento e o emulador de dispositivo.
2. No menu emulador File de dispositivo, clique em Configure.
3. Na caixa Shared folder do guia General, digite ou navegue até a pasta compartilhada no
4. Clique em OK.
Para testar sua pasta compartilhada no emulador Pocket PC
1. No emulador Pocket PC, abra File Explorer.
2. Toque e selecione My Device.
A Storage Card entrada é a pasta compartilhada.
Para testar sua pasta compartilhada no emulador Smartphone

1. No menu Windows Start, aponte para All Programs, aponte para Microsoft Visual
Studio 2005, em seguida, aponte para Visual Studio Remote Tools, e clique em Remote
File Viewer.
2. No Select a Windows CE Device, selecione o emulador Smartphone, e, em seguida,
clique OK para abrir a Windows CE Remote File Viewer janela.
A Storage Card entrada é a pasta compartilhada.
Como Configurar Opções de Conexão (Dispositivos)
oferece Visual Studio 2005 várias opções para conectar o computador de desenvolvimento para
um dispositivo. Utilize a Device Properties caixa de diálogo para gerenciar essas conexões.
ships Visual Studio com conexões do emulador defaulted para o transporte de DMA e dispositivos
físicos defaulted ao TCP / IP.
Para definir opções de conexão

1. No menu visual studio Tools, clique em Options.
2. Expanda Device Tools, clique em Devices, selecione um dispositivo ou emulador, e clique
em Properties.
Use as caixas de diálogo associada para selecionar e configurar suas conexões.
Diferenças entre depuradores de dispositivos e de desktop

Área de trabalho debuggers suporte, com as seguintes exceções depuradores dispositivo oferecer
suporte a maioria dos mesmos recursos.
Editar e continuar sem suporte
Suporte não fazer depuradores dispositivo para a capacidade de editar a fonte e continuar
enquanto no modo de interrupção. Se você quiser modificar o seu código durante a depuração,
você precisa para interromper a depuração, editar seu código, e reinicie com as fontes
modificados. Se você tentar alterar seu código enquanto no modo de interrupção, o depurador
emite um aviso.
Função evaluation não aceita no depurador nativo
O depurador de dispositivo nativo não oferece suporte Função evaluation. Você não pode digitar
em uma expressão que contém uma função dentro dela e a função avaliada e o resultado ter
retornado.
Função evaluation não suporte o depurador dispositivo gerenciado.
Interoperabilidade limitações de depuração
Você não pode depurar código nativo e gerenciados em uma única instância do depurador.
Para depurar aplicativos que possui mistos código gerenciado e nativo (ou código que usa
pInvoke gerenciado), definir pontos de interrupção no cada seção onde você deseja começar
depuração através de seu código. Em seguida, anexar o depurador é necessário para uma
determinada seção (por exemplo, uma seção gerenciada). Desanexar que depurador e anexe a
outra quando o outro for necessária. Você pode repetir essas Detach / anexar etapas com
freqüência conforme necessário para percorrer o programa..

Não há suporte atualmente para usando as instâncias de depuração dois ao mesmo tempo no
mesmo processo.
Atributo-Based depuração sem suporte
O.NET Compact Framework não oferece suporte baseado no atributo-depuração. A capacidade

de definir atributos para visualizadores e assim por diante, portanto, não está disponível para
usuários dos depuradores do dispositivo.
Área de trabalho Depuração Não com suporte
Você não pode usar os depuradores do dispositivo para depurar aplicativos escritos para área de
trabalho. Use os depuradores de mesa.
Núcleo depuração sem suporte
Você não pode usar os depuradores do dispositivo para depuração do núcleo.
Apenas meus depuração não aceita do código
Não é possível usar apenas código meu depuração.
Adições depurador Runtime (Cordbg.exe)
O depurador Runtime ajuda fornecedores ferramentas e desenvolvedores localizar e corrigir erros

em programas que destino o Common Language Runtime (CLR).Net Framework. Projetos de
dispositivo adicionar um novo comando e um novo argumento de modo ao depurador Runtime. A
sintaxe para o novo comando e argumento de modo (dentro uma sessão Cordbg.exe) é descrita
na tabela abaixo.
Para obter mais informações e sintaxe completa, consulte Depurador Runtime (Cordbg.exe).
Comando Descrição
[mode EmbeddedCLR é um argumento de modo que define o depurador como

projetos de dispositivo de destino. Para controlar essa configuração,
especifique 1 para on ou 0 para off.
conn[ect] Conecta a um dispositivo CLR incorporado remoto.

machine_name port
Parâmetros:
Machine_name
Necessário. O nome ou endereço IP do computador remoto.
Port
Necessário. A porta para usar para conectar-se para o
computador remoto.
Problemas de Conexão
Desativando o dispositivo enquanto o depurador está sendo executado faz o depurador para
fechar por causa da falha de conexão. A falha de conexão ocorre porque o aplicativo ainda está
sendo executado em segundo plano para o dispositivo. O botão X no Pocket PC é um recurso

inteligente minimizar e não não fechar o aplicativo. Em vez dele define o aplicativo para executar
em segundo plano.
Para corretamente fechar um aplicativo executado em segundo plano em um PC de bolso, no

menu Start, toque Settings, toque na System guia e toque em Memory. Na guia Running
Programs, selecione o aplicativo que você deseja fechar, e toque Stop.
Como: Anexar a processos de dispositivo gerenciados
Você anexar a um processo em um dispositivo do muito o mesmo modo como você faria na área
de trabalho, exceto que você deve definir uma chave de Registro no dispositivo para ativar
depuração gerenciado se o processo está sendo executado sem o depurador já. A configuração
dessa chave persiste até você alterá-lo, ou, no caso de um emulador, até que o emulador seja
fechado sem salvar suas configurações.
Observação
Definição da chave de depuração do dispositivo reduz o desempenho. Quando você não está
depurando, redefinir a chave.
Uma mensagem de erro é exibida se você tentar se anexar dois depuradores ou tente se conectar
com um depurador gerenciado quando a chave registro dispositivo não tiver sido definida.
Você pode iniciar um processo de várias formas, incluindo Explorer arquivo, da linha de comando,
e assim por diante. Na etapa seguinte, você iniciar o processo por iniciar a partir do Debug menu.
Você pode também iniciar um processo sem o depurador gerenciado, e depois anexá-lo
posteriormente.
Se o objetivo for uma plataforma Windows CE gerada a partir construtor Platform, você precisará
ter a biblioteca toolhelp.dll para preencher o Available Processes painel. Esta biblioteca está
incluída no SDKs Windows Mobile.
Observação
Depurar um processo gerenciado
Para depurar um processo gerenciado
• No menu Debug, clique em Start.
Observação
Anexe se você desconectar-se de processos iniciados no menu Debug, você não pode
novamente sem executar as seguintes etapas para anexar após um processo está sendo
executado. Isto é, a chave do Registro para o dispositivo é a ser definido.

Anexar a um já está em execução Managed processo
Se você planeja fazer anexar a um processo que já está executando, por, por exemplo, clicando
Start Without Debugging e então anexar a processo gerenciado em execução, precisará
primeiro definir a chave registro dispositivo antes do início do processo e você tentar se conectar
usando a Attach to Process caixa de diálogo antes. As seguintes etapas detalham o processo.
Para definir a chave do Registro do dispositivo para ativar anexar a um processo em execução
1. No menu Windows Start, aponte para All Programs, aponte para Microsoft Visual
Studio 2005, aponte para Visual Studio Tools, e clique em Remote Registry Editor.
2. Usando o Editor do Registro remoto, se conectar o dispositivo.
3. Para navegar ou crie a seguinte chave: depurador
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\ .NETCompactFramework\Managed
4. Definir ou crie um valor DWORD nomeado AttachEnabled.
5. Definir os dados para o valor em 1.
Observação
Definição da chave de depuração do dispositivo significativamente reduz o desempenho. Quando

você não está depurando, desativar gerenciado anexar, redefinindo o valor de dados para 0 ou
excluir o AttachEnabled valor.
6. Feche o Editor do Registro remoto.

Gerenciado anexar. e você poderão para iniciar um processo sem o depurador e, em
seguida, anexar ao processo usando a Attach to Process caixa de diálogo está ativado,
Para anexar a processo gerenciado após o processo está sendo executado
1. Após definir a chave conforme descrito nas etapas anteriores, iniciar um processo sem o
depurador.
2. No menu Tools, clique em Attach to Process.
3. Na caixa Transport, clique em Smart Device.
4. Na caixa Qualifier, clique em Browse.
Observação
A Qualifier caixa é prepopulated com os dispositivos usados recentemente da sessão atual.
5. Na caixa Connect to Device de diálogo, marque a plataforma, o dispositivo, e clique em

Connect.
6. No painel Available Processes, selecione um ou mais processos para anexar a, e clique
em Attach.
Observação
Por padrão, Tipo de código é definido automaticamente para Managed (.NET Compact
Framework) se estiver disponível,. caso contrário para Native (Smart Device) Para substituir as
configurações padrão, clique Select para abrir a Select Code Type caixa de diálogo. Observe que

você não pode selecionar ambos.
Observação
Não há suporte para interoperabilidade depuração. Isto é, você não pode depurar os dois tipos
código gerenciado e nativo ao mesmo tempo.
Desanexar do ou Terminate um processo
Para desconectar-se de ou encerrar um processo
1. No menu Debug, aponte para Windows, e clique em Processes.

2. Clique com botão direito na janela Processes, mouse o processo você deseja desanexar
do ou terminar.
3. No menu de atalho, clique em Terminate Process ou Detach from Process.
Observação
Você pode reabri caixa Attach to Process de diálogo a partir neste mesmo menu de atalho.
Preencher o painel de processos disponíveis
Para preencher o painel processos disponíveis no Windows CE projetos
• Incluir o toolhelp.dll arquivo na imagem de sistema OPERACIONAL do Windows CE.

ou ——
O toolhelp.dll arquivo copiar manualmente para o dispositivo de destino.
Como Alterar as Configurações do Registro do Dispositivo:
Use o Editor do Registro Remoto para alterar configurações do Registro para o dispositivo.
Para alterar as configurações do Registro

1. No menu Windows Start, aponte para All Programs, aponte para Visual Studio 2005,
aponte para Visual Studio Remote Tools, e clique em Remote Registry Editor.
2. Na janela Select a Windows CE Device, clique no dispositivo de destino cujo Registro
você deseja editar.
Um nó que representa o registro do dispositivo de destino é exibido no painel esquerdo da
Registry Editor.
3. Expanda o nó para fazer as alterações.
Passo-a-passo: Depurando uma Solução que Inclui Código Código Gerenciado e Código Nativo
Essa explicação passo a passo Fornece as etapas para depuração uma solução que inclui ambas
gerenciado,.NET Compact Framework e componentes nativos. Não Visual Studio 2005 oferece
suporte interoperabilidade Depuração de aplicativos do dispositivo como tal. Isto é, você não pode
ter os depuradores nativos e gerenciados anexados ao mesmo tempo.

A técnica recomendada para depuração uma solução que incorpora elementos tanto nativos
quanto gerenciados é a anexar o depurador é necessário para uma determinada seção, por
exemplo, uma seção gerenciada, e desanexar que depurador e anexar a outra quando o outro for
necessária. Você pode repetir essas Detach / anexar etapas com freqüência conforme necessário
para percorrer o programa.
Observação
Essa explicação passo a passo foi escrito usando configurações Development Visual C#. Ele
contém as seções a seguir:
• Ativar anexo do depurador gerenciado

• Iniciar o aplicativo
• Definir um ponto de interrupção no código nativo
• Anexando com o depurador nativo
• Executando para o ponto de interrupção Native
• Anexando com o depurador gerenciado
• Definir um ponto de interrupção no código gerenciado
• Executando para o ponto de interrupção gerenciado
• Conclusão
Pré-requisitos
Essa explicação passo a passo depende da solução criada com outro explicação passo a passo,
Passo-a-passo: Hello World: Um exemplo de interoperabilidade COM para dispositivos
inteligentes. Certifique-se de que essa explicação passo a passo hello world possui com êxito
criado e executado foi.
Ativar anexo do depurador gerenciado
Por padrão, dispositivos, incluindo emuladores, não permitir o depurador gerenciado para anexar
a processos que já estão em execução. Anexar o depurador gerenciado a um processo já em
execução é uma situação que geralmente encontrados em soluções de dispositivo que incluir
código gerenciado e nativo.
A primeira etapa, em seguida, é para definir o dispositivo para permitir que o depurador
gerenciado para anexar a um processo já em execução. Faça isso definindo uma chave do
Registro para o dispositivo.
Observação
Definição da chave afeta somente anexando a processos gerenciados já-execução. Ele não afeta
iniciar um projeto usando Start with Debugging (F5). No entanto, se você desconectar após Start
with Debugging, será necessário este processo para anexe novamente e iniciar a depuração

novamente.
Para ativar o depurador gerenciado para anexar a um processo em execução
1. No menu Windows Start, aponte para All Programs, aponte para Visual Studio 2005,
aponte para Visual Studio Remote Tools, e clique em Remote Registry Editor.
2. Na janela Select a Windows CE Device, expandir Pocket PC 2003, e clique em Pocket
PC 2003 SE Emulator. Este é o dispositivo de destino para essa explicação passo a passo.
3. Clique em OK.
A Connecting to Device janela de andamento abre, seguido pela abertura do emulador de
dispositivo e CE Windows o Editor do Registro remoto.
4. No Editor do Registro, expandir Pocket PC 2003 SE Emulator, e crie a seguinte chave:
depurador HKEY_LOCAL_MACHINE\SOFTWARE\Microsot\
.NETCompactFramework\Managed.
Criar a chave, com o botão direito do mouse .NETCompactFramework, apontando para
New, e, em seguida, clicando em Key.
Observe que há um espaço entre " Managed " e " depurador ".
5. Criar uma DWORD chamado AttachEnabled.
Criar a DWORD clicando com o botão direito do mouse Managed Debugger, apontando
para New, e, em seguida, clicando em DWORD Value.
6. Definir como AttachEnabled o Name, e como 1 o Value.
Observação
Definir essa chave de depuração do dispositivo significativamente reduz o desempenho. Quando

você não está depurando, desativar essa funcionalidade, redefinindo o valor de dados para 0.
7. Deixe o emulador de dispositivo aberto para as etapas restantes para preservar a

configuração do Registro. Você pode fechar o Editor do Registro.
Iniciar o aplicativo
A próxima etapa é para iniciar o aplicativo InteropSolution.
Para iniciar o aplicativo
1. Abra a solução que você criou na Passo-a-passo: Hello World: Um exemplo de

interoperabilidade COM para dispositivos inteligentes.
Certifique-se que Pocket PC 2003 SE Emulator aparece na caixa Target Device Na barra
de ferramentas.
2. No menu visual studio Debug, clique em Start Debugging ou pressione F5.
Essa etapa imediatamente implanta o projeto nativo, HelloCOMObject, para o emulador sem
intervenção do usuário mais.
3. Quando a Deploy SayHello caixa de diálogo Abrir, selecione Pocket PC 2003 SE
Emulator, e depois clique em Deploy.
Essa etapa implanta o projeto gerenciado.
O aplicativo abre no emulador. Não clique o botão ainda.

Definir um ponto de interrupção no código nativo
A próxima etapa é configurar um ponto de interrupção no código nativo para preparar para anexar
o depurador nativo.
Para definir um ponto de interrupção no código nativo
1. No Solution Explorer, clique com o botão direito do mouse Hello.cpp e depois no menu
2. Insira um ponto de interrupção na linha que começa *text clicando na margem esquerda do
editor do código.
O símbolo ponto de interrupção aparece como um círculo vazio com um ponto de
exclamação, indicando que atualmente não é possível resolver o ponto de interrupção. Isso
ocorre porque não possui o símbolos corretos e fontes no momento.
3. No menu visual studio Debug, aponte para Windows, e clique em Modules.
A Modules janela exibe todos os módulos carregados até agora, por exemplo, o aplicativo
gerenciado SayHello.exe. Observe que o HelloCOMObject.dll nativo ainda não foram
carregada, porque você não tiver clicado no botão no aplicativo.
Anexando com o depurador nativo
A próxima etapa é para desanexar o depurador gerenciado para que você pode anexar com o
depurador nativo. Lembre-se que ambos os depuradores não podem ser anexados ao mesmo
tempo para projetos de dispositivo. Essas são as etapas você usaria qualquer tempo necessário
para alternar entre o gerenciado e o depurador nativo.
Para anexar com o depurador nativo
1. No menu visual studio Debug, clique em Detach All.

Essa etapa desanexa o depurador gerenciado mas permite que o aplicativo para continuar
sendo executado.
2. No menu Debug, clique em Attach to Process.
3. Na caixa Transport, selecione Smart Device.
4. Para preencher a Qualifier caixa, clique em Browse.
5. Na caixa Connect to Device de diálogo, selecionar Pocket PC 2003 SE Emulator, e
clique em Connect
6. Para preencher a Attach to caixa, clique em Select.
7. Na caixa Select Code Type de diálogo, marque Debug these code types e desmarque a
Managed caixa de seleção, a Native caixa de seleção e, em seguida, clique em OK.
8. Na caixa Available Processes Selecionar SayHello.exe, e clique em Attach
Você está agora conectado com o depurador nativo.
Executando para o ponto de interrupção Native
Você está pronto para avançar para o ponto de interrupção você definir no código nativo. Quando
você examine a Modules janela novamente, você vê nativo módulos agora apresentar. No
entanto, HelloCOMObject.DLL ainda não está carregado porque você ainda não clicou button1.
Observação

Se você executou essa explicação passo a passo anterior, símbolos de depuração já podem ser
carregados, e você pode ignorar essas etapas. Caso contrário, a seção a seguir fornece as etapas
para carregá-los.
Para avançar execução para o ponto de interrupção nativo
1. No formulário Emulador de dispositivo, clique em button1.

O mundo hello! mensagem aparece no formulário, e hellocomobject.dll aparece na janela
Modules.
Se a Symbol Status coluna de hellocomobject.dll apresentações No symbols loaded,
siga estas etapas:
1. Clique com o botão direito do mouse hellocomobject.dll e, em seguida no menu
de atalho, clique em Load Symbols.
2. Na caixa de diálogo da Find Symbols, navegue até
InteropSolution\HelloCOMObject\Pocket PC 2003
(ARMV4)\Debug\HelloCOMObject.pdb.
3. Clique em Open.
A Symbol Status coluna altera de No symbols loaded para Symbols loaded, e
agora o indicador ponto de interrupção mostre o ponto de interrupção como resolvido.
2. Sobre o formulário no emulador de dispositivo, clique OK da Hello World! janela, em
button1 novamente.
O indicador ponto de interrupção mostra que a execução parou no ponto de interrupção.
3. No menu Debug, clique em Step into OU pressione F11.
Observe que a execução movido para a linha seguinte. Isso mostra que você pode
percorrer a parte da sua solução nativa agora.
Anexando com o depurador gerenciado
A próxima etapa é para desanexar o depurador nativo para que você pode anexar com o
depurador gerenciado. Lembre-se que ambos os depuradores não podem ser anexados ao
mesmo tempo para projetos de dispositivo. Essas são as etapas você usaria qualquer tempo
necessário para alternar do nativo para o depurador gerenciado.
Para anexar com o depurador gerenciado
1. No menu visual studio Debug, clique em Detach All.

Essa etapa desanexa o depurador nativo, mas o aplicativo continua a executar.
2. No menu Debug, clique em Attach to Process e garantir que a Transport caixa contém
Smart Device.
3. Preencher a Qualifier caixa, clicando Select, selecionar Pocket PC 2003 SE Emulator,
clique em Connect.
4. Para preencher a Attach to caixa, clique em Select Selecionar Debug these code types,
e marque a Managed caixa, desmarque a Native caixa e, em seguida, clique em OK.
Se aparecer uma mensagem lembrá-lo que gerenciado e nativo depuração não são
compatíveis, clique em OK.
5. Na caixa Available Processes Selecionar SayHello.exe, e clique em Attach
Agora o depurador gerenciado está conectado.

Definir um ponto de interrupção no código gerenciado
A próxima etapa é para definir um ponto de interrupção no código gerenciado para preparar para
conectar o depurador gerenciado.
Para definir um ponto de interrupção no código gerenciado
1. No Solution Explorer, clique com o botão direito do mouse Form1.cs e depois no menu
2. Insira um ponto de interrupção na linha string text;.
Executando para o ponto de interrupção gerenciado
Você está pronto para avançar para o ponto de interrupção você definir no código gerenciado.
Para avançar execução para o ponto de interrupção gerenciado
• No emulador de dispositivos, clique em button1.

A execução pára no ponto de interrupção.
Conclusão
Por razões de desempenho, lembre-se redefinir a chave do Registro do dispositivo como 0

quando você não for mais necessário anexar o depurador gerenciado a um processo já em
execução.
Consulte também
Como Gerar Código SqlCeResultSet (Dispositivos)
As seguintes etapas presumem tiver um banco de dados do SQL Server Mobile disponível na
janela Data Sources. Para obter mais informações, consulte Como Criar um Banco de Dados
SQL Server Mobile (Dispositivos) ou Como Adicionar um Banco de Dados SQL Server Mobile a
um Projeto de Dispositivo.
Em um dispositivo projeto, Visual Studio por padrão gera código para somente um DataSet. Você
pode alterar esse valor padrão para gerar um resultset em vez disso, ou para gerar ambos. Para
obter mais informações sobre as diferenças entre os dois tipos, consulte Resultsets versus
DataSets (dispositivos).
As opções ResultSet e ResultSet / DataSet têm suporte somente para arquivos.xsd criados contra
conexões SQL Server Mobile. A opção DataSet tem suporte para todas as conexões, e é o código
gerado pelo padrão.
Observação
Se você desejar converter um aplicativo DataSet existente para um aplicativo resultset, defina a
Custom Tool propriedade para MSDataSetResultSetGenerator. Essa configuração gera os dois
tipos de classes de acesso a dados. Em seguida, você pode migrar seu código de uma rede para
a outra sem erros de compilação. Depois de migrar o código, defina a Custom Tool propriedade
para MSResultSetGenerator. Recrie para confirmar se todos os uso DataSet foi removido do
código.
Para gerar código para Resultsets somente

1. No Solution Explorer, clique com o botão direito do mouse no arquivo.xsd banco de
dados e clique Properties no menu de atalho
2. Definir o Custom Tool valor como MSResultSetGenerator.
3. Recrie a solução.
Para gerar código para DataSets somente
1. No Solution Explorer, clique com o botão direito do mouse no arquivo.xsd banco de dados
e clique Properties no menu de atalho
2. Definir o Custom Tool valor como MSDataSetGenerator.
Esse valor é o valor padrão.
Para gerar código para Resultsets e DataSets
1. No Solution Explorer, clique com o botão direito do mouse no arquivo.xsd banco de
dados e clique Properties no menu de atalho
2. Definir o Custom Tool valor como MSDataSetResultSetGenerator.
Como Alterar a Seqüência de Caracteres de Conexão do Tempo de Design (Dispositivos)
Uma seqüência de conexão Design-time é criada por padrão quando você cria uma fonte de
dados SQL Mobile para seu projeto. Usa Visual Studio esta seqüência para se conectar ao banco
de dados em tempo de criação para recuperar informações de esquema. Durante o curso de
desenvolvimento do projeto, talvez queira alterar essa seqüência.
Observação
Distinguir essa seqüência de seqüência de conexão em tempo de execução. Para obter mais
informações, consulte Propriedade Connection String Property, File Properties Dialog Box
(Devices).
Para alterar a seqüência de conexão Design-time

1. Duas no Solution Explorer, vezes no arquivo.xsd para abrir o DataSet Designer.
2. Clique com o botão direito do mouse e, em seguida clique Properties no menu de atalho.
o TableAdapter,
3. Expanda a Connection propriedade.
4. Digite um novo valor para ConnectionString.
Como Alterar a Seqüência de Caracteres de Conexão de Tempo de Execução (Dispositivos)
Quando você adiciona uma fonte de dados a um projeto, uma seqüência de conexão é gerada no
arquivo.xsd. Essa seqüência é considerada uma seqüência de conexão Design-time, adequada
para se conectar Visual Studio à fonte de dados em tempo de design. Essa mesma seqüência de
conexão serve como a seqüência de conexão em tempo de execução padrão.
Se você precisar uma seqüência de conexão diferentes quando o aplicativo é executado em um

dispositivo, você pode especificar a seqüência de tempo de execução usando as seguintes
etapas. Para obter mais informações, consulte Propriedade Connection String Property, File
Properties Dialog Box (Devices).

Para alterar a seqüência de conexão em tempo de execução
1. No Solution Explorer, selecione o arquivo.xsd.
2. No menu View, clique em Properties Window.
3. Digitar uma seqüência de conexão em tempo de execução para a Connection String
propriedade.
Como Adicionar Botões de Navegação (Dispositivos)
Usar estes procedimentos para fornecer botões de navegação para exibir linhas diferentes em
uma fonte de dados. Essa técnica funciona em torno a falta de suporte .NET Compact Framework
para a DataNavigator classe do .NET Framework.
As etapas abaixo, escrito em C# e contar com a tabela Clientes do banco de dados Northwind,
suponha que você tiver um DataSet ou resultset na janela Data Sources. Para obter mais
informações, consulte Como Adicionar um Banco de Dados SQL Server Mobile a um Projeto de
Dispositivo.Em um projeto real, você incluiria limites verificação, que não é exibido nos exemplos
de código aqui.
Para configurar o para adicionar navegação botões

1. Arrastar e soltar uma tabela da janela Data Sources para um formulário do Windows.
2. Arraste e solte um botão no formulário.
3. Defina a Text propriedade do botão apropriadamente (por exemplo, ' Avançar ').
4. Clique duas vezes no botão no formulário para abrir o Editor de Código no botão clique
manipulador de eventos.
5. Usar os exemplos de código a seguir ao código First, Next, Previous. e Last Botão
manipuladores de eventos
Para código um botão primeiro
• Tipo this.customersBindingSource.MoveFirst();
Para código um botão Avançar
• Tipo this.customersBindingSource.MoveNext();
Para código um botão anterior
• Tipo this.customersBindingSource.MovePrevious();
Para um botão Último código
• Tipo this.customersBindingSource.MoveLast();
Como Persistir Alterações de Dados no Banco de Dados (Dispositivos)
Usar estes procedimentos para manter as alterações feitas em dados em projetos de dispositivo.
As etapas abaixo, escrito em C# e contar com a tabela Clientes do banco de dados Northwind,
suponha que você tiver um DataSet (não qualquer outro tipo de fonte de dados) na Data Sources
janela. Para obter mais informações, consulte Como Adicionar um Banco de Dados SQL Server
Mobile a um Projeto de Dispositivo.
Para tornar dados alterações o banco de dados

1. Arraste uma tabela da janela Data Sources até um formulário do Windows.
2. Arraste um botão para o formulário.

3. Alterar a Text propriedade do botão para Save.
4. Clique duas vezes no botão no formulário para abrir o Editor de Código no botão clique
manipulador de eventos.
5. Digite o seguinte código:
this.customersBindingSource.EndEdit(); this.customersTableAdapter.Update(this.northwindDataSet.
Customers);
Como Criar um Banco de Dados SQL Server Mobile (Dispositivos)
Você pode criar um banco dados do SQL Server Mobile se você tiver um projeto abrir ou não. Se
o banco de dados está se torne parte de um projeto, considere criá-lo dentro do projeto como uma
fonte de dados para o projeto. Mesmo se você criar o banco de dados fora de um projeto, você
pode adicioná-lo a um projeto mais tarde. Para obter mais informações, consulte Como Adicionar
um Banco de Dados SQL Server Mobile a um Projeto de Dispositivo.
Observação
SQL Server Mobile não oferece suporte abrir arquivos de banco de dados em um
Para criar o banco de dados fora um projeto

2. Clique com o botão direito do mouse Data Connections e clique Add Connection para
abrir a Add Connection caixa de diálogo.
3. Clique Change para abrir a Change Data Source caixa de diálogo.
4. Na caixa Data source Selecionar Microsoft SQL Server Mobile Edition, e clique em OK
5. Selecionar Microsoft SQL Server Mobile Edition, e, em seguida clique em OK.
6. Continue com " para continuar o processo e configurar a conexão " abaixo.
Para criar o banco de dados em um projeto
1. Com um projeto aberto, clique Add New Data Source no menu Data.
O Data Source Configuration Wizard abre.
2. Na página Choose a Data Source Type, selecionar Database, e clique em Next
3. Na página Choose Your Data Connection, clique New Connection para abrir a Add
Connection caixa de diálogo.
4. Clique Change para abrir a Change Data Source caixa de diálogo.
5. Selecionar Microsoft SQL Server Mobile Edition, e, em seguida clique em OK.
6. Continue com " para continuar o processo e configurar a conexão " abaixo.
Para continuar o processo e configurar a conexão
1. Na caixa Add Connection de diálogo, selecione My Computer.
2. Clique em Create.
3. Na caixa Create New SQL Server 2005 Mobile Edition Database de diálogo, digite um
caminho totalmente qualificado para o novo banco de dados (por exemplo, c:\MyDB).
4. Do New Password em e Confirm Password caixas, digite uma senha (por exemplo,
MyPassword) como a senha para o novo banco de dados, e clique em OK.

Para projetos que serão usados em aplicativos do mundo real, escolha uma senha de alta
segurança.
5. Na caixa Add Connection de diálogo, clique Test Connection para garantir que a
conexão foi feita.
Uma mensagem aparece, indicando que a conexão de teste êxito.
Observação
SQL Server Mobile não oferece suporte abrir arquivos de banco de dados em um
6. Clique OK para retornar para a Add Connection caixa de diálogo e clique OK para fechá-
lo.
7. Na página Choose Your Data Connection, selecione Yes, include sensitive data in the
connection string.
Para projetos que serão usados em aplicativos do mundo real, você deve escolher a exclude
dados confidenciais da seqüência de conexão. No mínimo, você deve garantir que os dados
confidenciais são criptografados.
8. Clique em Next.
Será a Local database file caixa de mensagem exibida inquiring se você deseja incluir o
arquivo de dados no projeto atual.
Clique em Yes.
9. Na página Choose Your Database Objects, selecione as tabelas ou outros objetos que
deseja incluir no seu projeto.
Agora você pode exibir o novo banco de dados como um DataSet na janela Data Sources
clicando Show Data Sources no Data menu. Para adicionar tabelas, colunas, restrições, e
assim por diante para o banco de dados, consulte Gerenciar fontes de dados em projetos
de dispositivo.
Como Adicionar um Banco de Dados SQL Server Mobile a um Projeto de Dispositivo
janela Server Explorer. Para obter mais informações, consulte Como Criar um Banco de Dados
SQL Server Mobile (Dispositivos).
Para adicionar um banco de dados do SQL Server Mobile como uma fonte de dados
1. Com um projeto Smart Device aberto, clique Add New Data Source no menu Data.
3. Na página Choose Your Data Connection, selecione a seqüência de conexão de dados
que contém o nome do seu banco de dados, e clique em Next

Esta conexão deve ser exibida na caixa suspensa se seu banco de dados já estiver
disponível em Server Explorer. Se a conexão de banco de dados não aparecer na lista,
clique New Connection para abrir a Add Connection caixa de diálogo, clique Browse para
abrir a Select SQL Server Mobile Edition Database File caixa de diálogo, navegue para
seu banco de dados, e, em seguida clique em Open. Em seguida clique OK para fechar a
Add Connection caixa de diálogo.
4. Na página Choose Your Data Connection, clique em Next.
Será a Local database file caixa de mensagem exibida inquiring se você deseja incluir o
arquivo de dados no projeto atual.
Clique em Yes.
5. Na página Choose Your Database Objects, selecione os objetos que deseja usar como
fontes dados em seu projeto.
Objetos que você selecionou no SQL Server Mobile Database são exibidos como fontes de
dados para o projeto na janela Data Sources. Para abrir a janela, clique Show Data
Sources no Data menu.
Como: Adicionar um banco de dados do SQL Server como uma fonte de dados (Dispositivos)
Você pode usar bancos de dados do SQL Server como fontes de dados em seu projetos
dispositivo gerenciado.
Para adicionar uma conexão de dados SQL Server ao Explorer Server

2. Na janela Explorer Server, clique com o botão direito do mouse Data Connections e
clique Add Connection no menu de atalho.
3. Na caixa Add Connection de diálogo, clique em Change.
4. Na caixa Change Data Source de diálogo, selecionar Microsoft SQL Server, e clique em
OK Para reabrir a Add Connection caixa diálogo
5. Na caixa Server name, especifique o nome do servidor onde a fonte de dados está
localizada.
6. Faça logon no servidor.
Se o servidor usa a autenticação do SQL Server, você precisará fornecer um nome de
usuário e senha.
7. Na caixa Select or enter a database name, selecione ou digite o nome do banco de
dados, e, em seguida, clique em OK.
A nova conexão de dados é exibida no Server Explorer.
Para usar uma conexão de dados SQL Server como fonte de dados em um projeto
1. Pré-requisito: Você deve ter um Projeto de Dispositivo Inteligente .NET Compact
Framework já abrir no IDE Visual Studio.
2. No menu Data, clique em Add New Data Source Para abrir o Data Source Configuration
Wizard.
4. Na página Choose Your Data Connection, clique em New Connection.
5. Na caixa Add Connection de diálogo, clique em Change.

6. Na caixa Change Data Source de diálogo, selecionar Microsoft SQL Server, e clique em
OK Para reabrir a Add Connection caixa diálogo
7. Na caixa Server name, digite ou selecione o nome do servidor onde a fonte de dados está
localizada.
8. Faça logon no servidor.
Se o servidor usa a autenticação do SQL Server, você precisará fornecer um nome de
usuário e senha.
9. Na caixa Select or enter a database name, selecione ou digite o nome do banco de
dados, e, em seguida, clique em OK.
10. Na página Choose Your Data Connection, optar por excluir dados confidenciais da
seqüência de conexão, e clique em Next.
Incluindo dados confidenciais na seqüência de conexão representa um risco de segurança.
11. Na página Choose Your Database Objects, selecione os objetos você deseja usar como
fontes de dados, e clique em Finish.
A conexão de dados agora aparece como uma fonte de dados na Data Sources janela.
Como: Adicionar um objeto corporativo como uma fonte de dados (Dispositivos)
Você pode adicionar um objeto comercial como uma fonte de dados em seu projetos de
dispositivo inteligente. Para obter mais informações, consulte Ferramentas de Banco de Dados
Visual.
Para criar uma nova fonte de dados de um objeto

1. No menu Data, clique em Add New Data Source.
2. Na página Choose a Data Source Type, selecione Object.
3. Na página Select an Object you wish to bind to, selecione um objeto já em seu
aplicativo.
Observação
Talvez seja necessário criar o projeto que contém o objeto antes o objeto aparece no assistente.
Você também pode adicionar uma referência a um objeto não está em seu aplicativo, clicando
Add Reference e localizar o conjunto desejado no Caixa de diálogo Add Reference. O assembly é
adicionado ao modo de exibição de árvore.
4. Expanda o conjunto que contém o objeto ao qual deseja vincular a, e selecione o objeto no
modo de exibição de árvore.
A fonte de dados é adicionada à janela Data Sources.
Para adicionar uma fonte de dados ao seu formulário
1. No menu Data, clique Show Data Sources para abrir a Data Sources janela.
2. Selecionar itens na janela Data Sources, e arraste-os em um formulário do Windows para
criar controles acoplados às propriedades em seu objeto. Para obter mais informações,
consulte Visão Geral da Exibição dados.

Como: Adicionar um serviço da Web como uma fonte de dados (Dispositivos)
Você pode adicionar um serviço da Web como uma fonte de dados em seu projetos de dispositivo
inteligente.
Conectar seu aplicativo a um serviço da Web

2. Na página Choose a Data Source Type, selecionar Web Service, e clique em Next
3. Adicionar uma referência ao serviço da Web usando o desejado a Adicionar caixa de
diálogo Referência da Web.
A fonte de dados é adicionada à janela Data Sources.
Para adicionar uma fonte de dados ao seu formulário
• Selecionar itens na janela Data Sources e arraste-os em um formulário do Windows para
criar controles acoplados. Para obter mais informações, consulte Visão Geral da Exibição
dados.
Como Gerenciar Tabelas em um Banco de Dados SQL Server Mobile (Dispositivos)
Adicionar uma tabela

2. Na janela Server Explorer, expanda a conexão de dados ao qual você deseja adicionar
uma tabela.
3. Clique com o botão direito do mouse Tables e, em seguida clique em Create Table.
4. Na caixa New Table de diálogo, digite um nome na caixa Name de tabela.
5. Para a primeira coluna, insira valores para Column Name, Data Type, Length, Allow
Nulls, Unique, e Primary Key. Continuar para colunas adicionais.
6. Clique em OK.
A nova tabela for exibida na lista de tabelas para a conexão de dados.
Para editar um esquema da tabela existente
2. Na janela Server Explorer, expanda a conexão de dados em que o esquema da tabela a
ser editado for localizada.
3. Clique com o botão direito do mouse na tabela para ser editado, e no menu de atalho,
clique em Edit Table Schema.
4. Na caixa Edit Table <Tablename> de diálogo, faça as alterações e clique em OK
Para remover uma tabela
2. Na janela Server Explorer, expanda a conexão de dados do qual você deseja soltar uma
tabela.

3. Clique com botão direito em Tables, mouse a tabela você deseja excluir e, em seguida, no
menu de atalho, clique em Drop Table.
4. Na caixa Delete Objects de diálogo, clique em Remove, e clique em OK
Observação
Não é possível remover uma tabela até que todas as referências para a tabela sejam excluídas.
Como Gerenciar Colunas em um Banco de Dados SQL Server Mobile (Dispositivos)
Para adicionar uma coluna

2. Na janela Server Explorer, expanda a conexão dados para exibir suas tabelas.
3. Clique com o botão direito do mouse na tabela à qual você deseja adicionar uma coluna, e
depois clique Edit Table Schema no menu de atalho.
4. Na janela Edit Table, adicionar a coluna e suas propriedades, e clique em OK.
Para editar as propriedades da coluna
3. Clique com o botão direito do mouse na tabela que contém a coluna cujas propriedades
você deseja editar e, em seguida, clique Edit Table Schema no menu de atalho.
4. Tornar suas edições, e, em seguida clique em OK.
Observação
Você não pode fazer uma edição que violaria integridade referencial (por exemplo, tentando se
alterar a Primary Key propriedade para No quando essa coluna é referida por outra restrição).
Para remover uma coluna de uma tabela

3. Clique com o botão direito do mouse na tabela da qual você deseja remover a coluna, e
depois clique Edit Table Schema no menu de atalho.
4. Na janela Edit Table, selecione a coluna você deseja excluir e clique em Delete e clique
em OK.
Observação
Não é possível remover uma coluna até que todas as referências para a coluna sejam excluídas.
Como Gerenciar Índices em um Banco de Dados SQL Server Mobile (Dispositivos)

Para criar um índice para um banco de dados do SQL Server Mobile

2. Na janela Server Explorer, expanda a fonte de dados no qual você deseja criar um novo
índice.
3. Expandir a tabela para o qual você deseja o novo índice, e em seguida, clique com o botão
direito do mouse a Indexes pasta.
4. No menu de atalho, clique em Create Index.
5. Na caixa New Index de diálogo, digite um nome para o índice, e clique em Add.
6. Na caixa Select Columns from <Table> de diálogo, selecione as colunas a serem
adicionados à chave de índice, e clique em OK.
7. Clique OK para fechar a New Index caixa de diálogo.
Para editar propriedades do índice na ordem classificação-somente
2. Na janela Server Explorer, expanda a Conexão de Dados e Tabela que contêm o índice
cujas propriedades você deseja editar.
3. Clique com o botão direito do mouse o índice, e, em seguida clique Index Properties no
menu de atalho.
4. Você pode alterar a ordem de classificação na caixa de diálogo
Não é possível alterar outras propriedades do índice exceto, substituindo o índice existente
por um novo nome.
Para descartar um índice de um banco de dados do SQL Server Mobile
2. Na janela Server Explorer, expanda a conexão de dados do qual você deseja descartar
um índice.
3. Expandir tabela que possui o índice, expandir Indexes, e em seguida, clique com o botão
direito do mouse o índice para ser descartado.
4. No menu de atalho, clique em Drop Index.
5. Na caixa Delete Objects de diálogo, clique em Remove, e clique em OK
Como Gerenciar Senhas para um Banco de Dados SQL Server Mobile (Dispositivos)
Você pode definir uma senha quando você cria um banco de dados do SQL Server Mobile, e você
pode alterar a senha em um banco de dados existente.
Incluindo uma senha em uma seqüência de conexão representa um risco de segurança. Para
obter mais informações, consulte Securing Databases (SQL Server Mobile Edition).
As etapas de exemplo a seguir presumem você tiver um aplicativo Windows Forms Pocket PC
abrir.

Para definir uma senha ao criar um banco de dados SQL Server Mobile
3. Na página Choose Your Data Connection, clique New Connection para abrir a Add
Connection caixa de diálogo.
4. Clique em Change, selecione Microsoft SQL Server Mobile Edition, e clique em OK.
6. Clique em Create.
7. Na caixa Create New SQL Server 2005 Mobile Edition Database de diálogo, digite um
caminho qualificado fullly-para o novo banco de dados (por exemplo, c:\MyDatabase.sdf).
8. Do New Password em e Confirm Password caixas, digite uma senha para o novo banco
de dados, e clique em OK.
Se alterar uma senha através um SQL Server Mobile Database existente
2. Na Server Explorer janela, clique com botão direito a fonte de dados para que você
deseja alterar a senha.
3. No menu de atalho, clique em Database Properties.
4. Na caixa Database Properties de diálogo, clique em Set password.
5. Digite as senhas antiga e nova na conforme solicitado, e clique em OK.
Como Reduzir e Reparar um Banco de Dados SQL Server Mobile (Dispositivos)
Para reduzir e reparar um banco de dados

2. Clique com botão direito na janela do Server Explorer mouse na conexão de dados você
deseja reduzir e reparar, e seguida, no menu de atalho, clique em Database Properties.
3. No painel Select a page, clique Shrink & Repair.
4. Escolha entre as opções na página Shrink & Repair.
A parte inferior da página exibe uma explicação para a opção você selecionar.
5. Clique OK Para iniciar a redução selecionada e reparar opção, ou clique Cancel para
deixar o banco de dados em sua condição atual.
Como: Criar consultas parametrizadas (Dispositivos)
SQL Server Mobile (Dispositivos) ou Como Adicionar um Banco de Dados SQL Server Mobile a
um Projeto de Dispositivo.
Quando você desejar que os usuários sejam capazes para inserir valores diferentes para um
parâmetro, use um ponto de interrogação (. "? como o parâmetro quando você cria sua consulta) "
Se você criar sua consulta usando a marca inteligente no Windows Forms Designer, como
mostrado na seguinte conjunto de etapas, uma interface de usuário é gerado no formulário

Windows automaticamente. Do TableAdapter se você criar sua consulta de no criador DataSet,
como mostrado no último conjunto de etapas, nenhuma interface de usuário é gerado
automaticamente.
Para configurar para especificar um parâmetro usando o Windows Forms Designer

1. Arraste uma tabela no formato DataGrid ou Detalhes da janela Data Sources para o
formulário no designer.
Você pode selecionar o formato, clique na seta no canto direito do nome da tabela.
2. Clique na marca inteligente no componente arrastada, e no menu de atalho, clique em Add
Query
Se você não estiver usando um mouse, o atalho de teclado para abrir a Tasks caixa de
diálogo é SHIFT + ALT + F10.
3. Na caixa Search Criteria Builder de diálogo, selecione New query name.
Usar o nome padrão ou criar um nome de sua escolha.
4. Agora você pode especificar os parâmetros ou clicando Query Builder, alterando a
instrução SQL na caixa Query Text.
Para especificar um parâmetro usando a caixa Query Text
1. Adicionar uma WHERE cláusula ao final da instrução SELECT.
2. Clique OK para fechar a Search Criteria Builder caixa de diálogo.
Um botão vinculado consulta-é exibido no formulário no designer.
Para especificar um parâmetro usando Construtor de consultas
1. Na caixa Query Builder de diálogo, ambos:
o Adicione uma WHERE cláusula no painel da instrução SQL.
Ou-
o Insira seu parâmetro Filter na listagem apropriada Column.
Essa abordagem grava a WHERE cláusula para você no painel da instrução SQL.
2. Clique OK para fechar a Query Builder caixa de diálogo.
Um botão vinculado consulta-é exibido no formulário no designer.
Para especificar um parâmetro utilizando o criador DataSet
1. No Solution Explorer, clique com o botão direito do mouse no arquivo.xsd, e clique em
Open.
2. No Dataset Designer, clique com botão direito aponte para Add, e, no menu de atalho,
clique em Query. o TableAdapter,
3. No Assistente para configuração Query TableAdapter, selecionar Use SQL Statements, e
clique em Next
4. Na página Choose a Query Type, selecionar Select which returns a single value, e
clique em Next
5. Na página Specify a SQL SELECT statement, clique em Query Builder.
Se você desejar, você pode adicionar a WHERE cláusula aqui.
6. Use Construtor de Consultas conforme descrito anteriormente contidas neste tópico.
Observação

Há elementos da interface do usuário são gerados automaticamente quando você cria suas
consultas usando o TableAdapter Query Configuration Wizard.
Passo-a-passo: Um Aplicativo de Consulta Parametrizado do SQL Server Mobile
Essa explicação passo a passo mostra como usar o Visual Studio 2005 ambiente para
desenvolver um aplicativo simples consulta parametrizada. DataBinding e grande parte da
interface do usuário serão gerados automaticamente para você. Confiar no banco de dados
Northwind familiarizado, este aplicativo fornece para o cenário em que os usuários de dispositivo
inteligente precisam para determinar o país remessa quando eles sabem somente o número do
pedido. O aplicativo você criar aqui fornece para entrada de usuário do número do pedido e a
exibição de país correspondente remessa consequent.
Observação
Pré-requisitos
O banco de dados Northwind para SQL Server Mobile Edition, incluído no Visual Studio 2005.
Observação
Se você for um administrador não no seu computador de desenvolvimento, você não pode abrir o
Northwind.sdf arquivo no seu local padrão, \Program Files\Microsoft Server\Mobile\v3.0
8\SmartDevices\SDK\SQL Visual Studio. Copie o arquivo para a área de trabalho ou para My
Documents e abri-lo de lá quando você for solicitado.
1. Clique Options no menu Tools, e Device Tools Clique em General.

Isso é um aplicativo Windows Forms simples para hospedar a funcionalidade de dados dessa
Para criar um projeto de dispositivo Windows Forms

ou ——
Observação
Não selecione Device Application (1.0), que depende da versão 1,0 do .NET Compact
Framework e não é adequado para essa explicação passo a passo.
4. Na caixa Name, digite ParamQuerySample.

arquivos de projeto.
6. Clique em OK.
Adicionando funcionalidade de dados
Esta seção consiste das seguintes tarefas:
• Selecionar um tipo de fonte de dados.

• Selecionando e configurando uma conexão de dados.
• Selecionar objetos de banco de dados.
• Adicionando controles ligados a dados ao formulário.
Para selecionar um tipo de fonte de dados
Wizard.
Para selecionar e configurar uma conexão de dados

2. Na caixa Choose Data Source de diálogo, selecionar Microsoft SQL Server Mobile
Edition, e clique em Continue
Observação
Dependendo configurações e projetos anteriores, caixa Add Connection de diálogo pode

aparecer em vez da caixa Choose Data Source de diálogo. Se isso acontecer, clique Change na
caixa Add Connection de diálogo para abrir a Change Data Source caixa de diálogo. Selecione
Microsoft SQL Server Mobile Edition, e clique em OK.

4. Novamente na caixa Add Connection de diálogo, clique em Browse.
5. Na caixa Select SQL Server Mobile Edition Database File de diálogo, selecionar
Northwind.sdf, e clique em Open
6. Na caixa Add Connection de diálogo, deixe a Password caixa vazia.
Este banco de dados tem nenhuma senha.
7. Clique Test Connection para verificar a conexão.
Observação
Se o acesso para o Northwind.sdf arquivo for negado, copiar o arquivo para a área de trabalho, e
procure a essa cópia para abrir. Esta situação pode ocorrer se você não tem direitos suficientes
no computador de desenvolvimento para abrir o arquivo no seu local padrão, que é listado para o
início dessa explicação passo a passo.
8. Clique OK na caixa de mensagem que mostra a conexão bem-sucedida, e clique OK para

fechar a Add Connection caixa de diálogo.
9. Feche a Choose Your Data Connection página clicando Next.
10. Na caixa de mensagem que pergunta se você deseja copiar o arquivo para seu projeto,
clique em Yes.
Para selecionar objetos de banco de dados
1. Na página Choose Your Database Objects, expanda o Tables nó, e selecione a Orders
tabela.
O NorthwindDataset é criado. Você pode exibir esta fonte de dados, selecionando Show
Data Sources no menu Data.
Para criar a consulta
1. Na janela Data Sources, expanda a Orders tabela.

2. Clique na Ship Country coluna, e clique na seta suspensa e selecione a Label opção.
3. Arraste a Ship Country coluna para o formulário no designer.
4. Sobre o controle rótulo no designer, clique na marca inteligente, e no menu de atalho,
clique em Add Query
5. Na caixa Search Criteria Builder de diálogo, clique em Query Builder.
6. Na coluna Filter da linha Order ID, digite um ponto de interrogação (?).
Este símbolo indica que usuários do aplicativo será tem para inserir um valor para
identificação do pedido.
7. Clique em OK.
A WHERE cláusula na caixa Query Text deve ler ([Order ID]=@PARAM1) agora.
Um painel aparece no formulário no designer.
Para refinar a interface do usuário

1. Clique com o botão direito do mouse no PARAM1 controle rótulo no designer, e no menu
de atalho, clique em Properties
2. Alterar a Text propriedade para Order ID.
3. Selecionar o FillBy botão, e altere sua propriedade de texto como Show country.
4. Expanda Painel e controles para eliminar as barras de rolagem e mostrar todo o texto.
Cuidado principalmente que. e sua caixa de texto não estiver oculto atrás e seus controles o
Ship_CountryLabel o FillByPanel
Testar o aplicativo
Nesta seção você criar o aplicativo, baixá-lo para o emulador se Pocket PC 2003, e verifique se o
aplicativo funciona corretamente.
1. No menu Debug, clique em Start ou Start Debugging.

Deploy
Andamento implantação aparece na barra Status. Implantação para o emulador pode levar
algum tempo.
3. Quando o aplicativo está sendo executado no emulador, digite um número ordem, que
execute de 10000 para 11077 no banco de dados Northwind, e clique em Show country.
O país Navio para esse pedido aparece no controle rótulo.

2. Na caixa Device Emulator de mensagem, clique em No para a mensagem perguntando
se você deseja salvar o estado do emulador.
3. (Visual Basic) No menu File, clique em Close Project.
ou ——
(Visual C#) No menu File, clique em Close Solution.
Se você for solicitado para salvar o projeto ou solução, clique Save se você deseja usá-lo
novamente mais tarde; caso contrário, clique em Discard e os arquivos não serão salvas.
Como Criar Aplicativos Master-Detail (Dispositivos)
As seguintes etapas presumem tiver um banco de dados do SQL Server Mobile com
relacionamentos de tabelas disponíveis na janela fontes de dados. Para obter mais informações,
consulte Como Criar um Banco de Dados SQL Server Mobile (Dispositivos).
Ao arrastar tabelas de detalhes, considere arrastando somente as colunas que servem sua
finalidade, em vez da grade inteira. Você pode fazer essa opção, clique na seta no canto direito do
nome da tabela.
Para criar um aplicativo principal-detalhes

1. Arraste a tabela mestre da janela Data Sources para o formulário no designer.
2. Na janela Data Sources, expanda a tabela mestre para expor a tabela de detalhes.
3. Arraste a tabela de detalhes que você encontrará dentro do nó de tabela mestre para o
formulário.
Observação
Esta é a tabela de detalhes como ele aparece dentro da tabela mestre, não a tabela de detalhes
que está no mesmo nível de árvore como a tabela mestra.
4. O designer detecta automaticamente a Relação mestre-detalhes das restrições de chave

externas. Para obter mais informações, consulte Passo-a-passo: Um Aplicativo Master-
Detail do SQL Server Mobile.
5. Ajuste os controles no formulário para atender seu aplicativo.
Passo-a-passo: Um Aplicativo Master-Detail do SQL Server Mobile
Descreve como para usar o Visual Studio 2005 ambiente para conectar a um banco de dados,
selecione Objetos de banco de dados para inclusão em um projeto, e criar controles ligados a
dados para exibir os dados em um aplicativo de dispositivo inteligente essa explicação passo a
passo.
Observação
Pré-requisitos
O banco de dados Northwind para SQL Server Mobile Edition, incluído no Visual Studio 2005.
Observação
Se você for um administrador não no seu computador de desenvolvimento, você não pode abrir o
Northwind.sdf arquivo em sua localização padrão (\Program Files\Microsoft Server\Mobile\v3.0
8\SmartDevices\SDK\SQL Visual Studio). Copie o arquivo para a área de trabalho ou para Meus
documentos e abri-lo de lá quando você for solicitado.
1. Clique Options no menu Tools, e Device Tools Clique em General.

Isso é um aplicativo Windows Forms simples para hospedar a funcionalidade de dados dessa
Para criar um projeto de dispositivo Windows Forms
ou ——
Observação
Não selecione Device Application (1.0), que depende da versão 1 do .NET Compact Framework
e não é adequado para essa explicação passo a passo.
4. Na caixa Name, digite MasterDetailSample.

arquivos de projeto.
6. Clique em OK.
Adicionando funcionalidade de dados
Esta seção consiste das seguintes tarefas:
• Selecionando um tipo de origem de dados

• Selecionando e configurando uma conexão de dados
• Selecionar objetos de banco de dados
• Adicionando controles ligados a dados ao formulário
Para selecionar um tipo de fonte de dados
Wizard.
Para selecionar e configurar uma conexão de dados

2. Na caixa Choose Data Source de diálogo, selecionar Microsoft SQL Server Mobile
Edition, e clique em Continue

Observação
Dependendo configurações e projetos anteriores, caixa Add Connection de diálogo pode

aparecer em vez da caixa Choose Data Source de diálogo. Se isso acontecer, clique Change na
caixa Add Connection de diálogo para abrir a Change Data Source caixa de diálogo. Selecione
Microsoft SQL Server Mobile Edition e clique em OK.

4. Novamente na caixa Add Connection de diálogo, clique em Browse.
5. Na caixa Select SQL Server Mobile Edition Database File de diálogo, selecionar
Northwind.sdf, e clique em Open
6. Na caixa Add Connection de diálogo, deixe a Password caixa vazia.
Este banco de dados tem nenhuma senha.
7. Clique Test Connection para verificar a conexão.
Observação
Se o acesso para o Northwind.sdf arquivo for negado, copiar o arquivo para a área de trabalho, e
procure a essa cópia para abrir. Esta situação pode ocorrer se você não tem direitos suficientes
no computador de desenvolvimento para abrir o arquivo no seu local padrão, que é listada no
início dessa explicação passo a passo.
8. Clique OK na caixa de mensagem que mostra a conexão bem-sucedida, e clique OK para

fechar a Add Connection caixa de diálogo.
9. Feche a Choose Your Data Connection página clicando Next.
10. Na caixa de mensagem que pergunta se você deseja copiar o arquivo para seu projeto,
clique em Yes.
Para selecionar objetos de banco de dados
1. Do Customers na página Choose Your Database Objects, expanda o Tables nó, e

selecione e Orders tabelas.
O NorthwindDataset é criado. Você pode exibir esta fonte de dados, selecionando Show
Data Sources no menu Data.
Para adicionar controles ligados a dados ao formulário
1. Na Data Sources janela, selecione a Customers Tabela, e clique na seta suspensa, e

selecione a DataGrid opção.
2. Arraste a Customers tabela da janela Data Sources para o formulário no designer.
Localize a grade em direção à parte superior da janela.
3. Na janela Data Sources, expanda a Customers tabela para expor a Orders tabela.
Observação
Esta é a Orders tabela como ele aparece dentro da Customers tabela, não a Orders tabela que

está no mesmo nível de árvore como a Customers tabela.
4. Clique na seta suspensa para esta Orders Tabela, e selecione a DataGrid opção.
5. Arraste esta Orders tabela da janela Data Sources para o formulário no designer.
Localize a grade a parte inferior da janela.
Testar o aplicativo
Nesta seção você criar o aplicativo, baixá-lo para o emulador se Pocket PC 2003, e verifique se o
aplicativo funciona corretamente.
1. No menu Debug, clique em Start ou Start Debugging.

Deploy
Andamento implantação aparece na barra de status. Implantação para o emulador pode
levar algum tempo.
3. Quando o aplicativo é executado no emulador, use a cima e para baixo setas no seu
teclado ou no controle NAVIGATION no emulador para alterar os registros selecionados na
grade Customers. Verifique os registros selecionados alterar na grade Orders.

2. Na caixa Device Emulator de mensagem, clique em No para a mensagem perguntando
se você deseja salvar o estado do emulador.
3. Na mensagem caixa Que advises a conexão foi perdida, clique em OK.
4. (Visual Basic) No menu File, clique em Close Project.
Se você for solicitado para salvar o projeto ou solução, clique Save se você deseja usá-lo
novamente mais tarde; caso contrário, clique em Discard e os arquivos não serão salvas.
ou ——
(Visual C#) No menu File, clique em Close Solution.
Como Visualizar Dados em um Banco de Dados SQL Server Mobile (Dispositivos)
Você pode visualizar dados fora usando Server Explorer Um do projeto, ou dentro de um projeto
usando a Data Sources janela, onde você também pode parameterize a consulta que produz o
modo de exibição. Para obter mais informações, consulte Como: Criar consultas parametrizadas
(Dispositivos).
Para exibir dados usando Explorer Server

2. Na janela Server Explorer, expanda a conexão dados para expor a listagem de tabela.
3. Clique com o botão direito do mouse na tabela cujos dados você deseja exibir e, no menu
de atalho, clique em Open.
Para exibir dados usando a janela fontes de dados em um projeto
2. Na Data Sources janela, clique com botão direito a fonte de dados cujos dados você
deseja exibir (por exemplo, uma tabela).
3. No menu de atalho, clique em Preview Data.
4. Na caixa Data Preview de diálogo, clique em Preview.
Para exibir dados usando a marca inteligente sobre o controle DataGrid
1. No designer, clique na marca inteligente sobre o controle DataGrid.
2. No menu DataGrid Tasks de atalho, clique em Preview Data.
3. Na caixa Preview Data de diálogo, selecione o objeto para visualizar e clique em Preview.
Os dados aparecerão na caixa Results. O número de colunas e linhas na grade também é
exibido na parte inferior da caixa Preview Data de diálogo.
Como: Gerar resumo e modos de exibição de edição para aplicativos de dados (Dispositivos)
Usar formulários de dados para exibir e editar linhas de dados em um DataGrid única.
A interface do usuário de formulário de dados consiste de duas caixas de diálogo: caixa View de
diálogo exibe uma exibição de resumo de uma linha DataGrid selecionado, e a Edit caixa de
diálogo permite a edição de linha.
• Abrir a View caixa de diálogo em um aplicativo em execução clicando duas vezes uma
linha no DataGrid no emulador de dispositivo ou tocando em uma linha em um dispositivo.
• Você abrir a Edit caixa de diálogo ao clicar em (tocando) New quando o DataGrid é
exibida — Esta ação cria uma nova linha no DataGrid — ou clicando (tocando) Edit quando a
View caixa de diálogo é exibida.
Formulários de dados são criados como modelos para personalização. Você deve adicionar
código adequado para validar e confirmar alterações para o banco de dados como parte dessa
personalização.
Para gerar os formulários de dados

1. Arraste uma tabela no formato DataGrid da janela Data Sources para o formulário no
designer.
Você pode selecionar o formato, clique na seta no canto direito do nome da tabela.
2. Clique na marca inteligente no componente arrastada, e no menu de atalho, selecione
Generate Data Forms. (Se não estiver usando um mouse, o atalho do teclado para abrir a
Tasks caixa de diálogo é SHIFT + ALT + F10.)
Observação

As caixas de diálogo brevemente são exibidas como eles são gerados no designer. Para verificar
se as caixas de diálogo são agora parte do projeto, procure-los Solution Explorer.
Para modificar dados em um aplicativo em execução

1. Iniciar o aplicativo de dados.
O DataGrid é exibida, preenchida com dados.
2. Clique duas vezes uma linha de dados.
Uma exibição de linha de resumo aparece na caixa View de diálogo. Esta exibição consiste
em um rótulo e dados para cada coluna que possui conteúdo. Isto é, caixa View de diálogo
oculta qualquer coluna cujo valor é DBNULL.
3. No menu principal, clique Edit para abrir a Edit caixa de diálogo.
Usar a Edit caixa de diálogo que exibe todas as colunas, para modificar os dados, e clique
em OK.
Os dados revisados são exibidos no DataGrid.
Para criar uma nova linha no DataGrid em um aplicativo em execução
1. Com um aberto DataGrid, no menu principal, clique em New.
A Edit caixa de diálogo será exibida.Use esta caixa de diálogo para adicionar uma nova
linha de dados.
2. Clique em OK.
A nova linha será adicionada para o DataGrid.
Passo-a-passo: Empacotando uma Solução de um Dispositivo Inteligentes para Implantação
Essa explicação passo a passo demonstra como usar Visual Studio 2005 para compactar seu
aplicativo e seus recursos em um arquivo CAB para que ele pode ser implantado em Dispositivo
Inteligente uma usuário fim na.
Observação
Nessa explicação passo a passo, você começa com qualquer solução de dispositivo inteligente
escrita Visual Basic 2005, Visual C# 2005, ou Visual C++ 2005. Para obter mais informações,
consulte Criando um aplicativo Simple Walkthrough:.
Essa explicação passo a passo mostra como fazer o seguinte:
• Adicione um projeto CAB para a solução.

• Alterar o nome do produto.
• Alterar o caminho de saída.
• Preencher o arquivo CAB com a saída do aplicativo principal.
• Adicionar dependências se necessário.

• Criar um atalho para o aplicativo.
• Editar uma entrada do Registro.
Pré-requisitos
Uma solução Smart Device existente. Para fins dessa explicação passo a passo de embalagem,
considere criar e criar um projeto simples,, conforme o projeto descrito no Passo-a-passo: Criando
aplicativos do Windows Forms para um dispositivo.
Observação
Configurando o projeto CAB
Para adicionar um projeto CAB dispositivos inteligentes da solução
1. Abra o projeto de dispositivos inteligentes existente e verifique se que Solution Explorer

esteja visível.
2. No menu File, aponte para Add, e clique em New Project.
3. No painel Project Types no lado esquerdo, expanda o Other Project Types nó e clique
em Setup and Deployment.
4. No Templates painel à direita, selecione Smart Device CAB Project.
Isso é o único tipo de projeto CAB válido para dispositivos inteligentes. Os outros tipos de
projeto são para somente soluções de mesa.
5. Na caixa Name, digite CABProject, e depois clique em OK.
O projeto CAB é adicionado à sua solução e estará visível na Solution Explorer. Agora os
dois painéis do File System Editor são exibidas.
Personalizando o projeto CAB
Para alterar o nome do produto e outras propriedades do projeto
1. No Solution Explorer, selecionar CABProject caso ele já não esteja selecionado.

2. No menu View, clique Properties Window para abrir a Properties janela.
3. No campo ProductName da grade da propriedade, altere o valor para MyProduct.
O valor da propriedade ProductName determina o nome que é exibido para o aplicativo em
nomes Pasta e na caixa Add or Remove Programs de diálogo.
o Você também pode usar esta janela para alterar o nome do fabricante e para
especificar o mínimo e máximo permitido versões do sistema operacional.
o Você pode definir a OSVersionMin propriedade para 4.21 para indicar que o
aplicativo Pocket PC possui reconhecimento orientação da tela. No entanto, definindo essa
propriedade para 4.21 você impedirá o aplicativo de instalação em Pocket PCs baseados no
Windows Mobile 2003 e anteriormente. Para permitir instalação em dispositivos e também
indicar conscientização orientação de tela a dispositivos mais recentes você deve editar o

arquivo.inf para definir a BuildMax propriedade com um dos seguintes valores:
manualmente
0xA0000000 para indicar o aplicativo oferece suporte (pixels) 240x240 telas quadradas
0xC0000000 para indicar o aplicativo suporta Rotação da tela
Ou-
0xE0000000 para indicar o aplicativo suporta telas quadradas e Rotação da tela.
Para obter mais informações, consulte o informe oficial Desenvolvendo aplicativos Aware
Orientation-da tela MSDN.
o Para soluções Pocket PC baseadas em Windows Mobile 2003SE e anterior, a
Compress propriedade e a NoUninstall Device Deployment propriedade deve ser falsos.
Digite observe essa opção pode ser definida como true para dispositivos equipados com
Compact Framework 2.0. Para obter mais informações, consulte Janela Propriedades,
Project CAB de dispositivos inteligentes.
o Se você estiver usando uma configuração Windows CE DLL, usar essa grade
propriedade para especificar o nome e local do arquivo. Para obter mais informações sobre
instalação Windows CE DLLs, consulte a documentação Pocket PC ou Smartphone SDK.
Para alterar o nome do arquivo CAB e adicionar autenticação
1. Na Solution Explorer, clique com o botão direito do mouse CABProject e, em seguida

clique em Properties.
A Property Pages caixa de diálogo será exibida para o projeto CAB. Na caixa Output file
name, alterar o nome do arquivo CAB e caminho para Debug\MyApp.cab, e clique em OK.
2. Também pode usar esta página Propriedade para adicionar autenticação ao seu projeto.
Autenticação é necessário para soluções Smartphone, e não oferece suporte para soluções
Pocket PC baseadas em Windows Mobile 2003 se e anteriormente. Para obter mais
informações, consulte Segurança em projetos de dispositivos.
Para adicionar o aplicativo de projeto de dispositivo para o projeto CAB
1. No painel esquerdo da File System Editor, selecione o Application Folder nó para

especificar os arquivos que você selecione nas etapas a seguir será instalado para esta
pasta para o dispositivo de destino.
Se o File System Editor não estiver visível, clique com o botão direito do mouse o CAB
Nome do projeto no Solution Explorer, selecionar View, e clique em File System.
2. No menu Action do Visual Studio, aponte para Add, e clique em Project Output.
3. Na caixa Add Project Output Group de diálogo, selecione o Project dispositivos
inteligentes na lista Project drop-down.
4. A lista de saídas, selecionar Primary output e, em seguida clique em OK.
Observação
Ao criar um projeto CAB dispositivo inteligente para um aplicativo escrito em C++, você deve
adicionar dependências, tais como atl80.dll / mfc80U.dll, ou MSVCRT.dll, para o projeto CAB se
você estiver vinculando a essas DLLs dinamicamente manualmente. Vinculação estática é
altamente recomendável, entretanto, a fim de reduzir dependências nas DLLs MFC / ATL. Se você
estiver vinculando estaticamente, as DLLs não devem ser redistribuídas com o aplicativo. Se você
está vinculando, dinamicamente e precisar redistribuir as DLLs no CAB, não instale as DLLs para
a pasta do sistema, como \windows, para o dispositivo. Em vez disso, instale as DLLs no diretório

do aplicativo local. Se você estiver redistribuindo um conjunto de aplicativos, todos os quais
dinamicamente vincular a ATL / MFC executar vezes, é recomendável para instalar todos os
aplicativos, e as DLLs em tempo de execução, para um diretório único aplicativo, e fornecer
atalhos para os aplicativos que podem ser colocados em suas próprias pastas. Isso irá salvar
alguns tamanho Ao evitar o perigo das DLLs no diretório do sistema está sendo substituída
posteriormente e quebra os aplicativos que dinamicamente vincule a eles.
Para adicionar dependências para o CAB projeto somente (projetos C++)
1. No Solution Explorer, clique com o botão direito do mouse em seu nome de projeto CAB,
depois aponte para Add, e clique em File
2. Navigate to <Visual Studio installation folder>\VC\ce\dll\armv4.
3. Selecione os arquivos para adicionar.
o Para um projeto MFC, pressione CTRL e clique MFC80U.DLL, atl80.dll, e
msvcrt80.dll. Talvez também precise Clique em uma ou mais das DLLs específicos do
idioma se seu aplicativo exigir recursos específicos do idioma MFC.
o Para um Projeto ATL, pressione CTRL e clique atl80.dll e msvcrt80.dll. Se sua
solução ATL suporta MFC, clique em MFC80U.DLL também.
o Para um projeto Win32, clique em msvcrt80.dll.
4. Clique Open na caixa Add Files de diálogo para adicionar os arquivos no seu projeto
CAB.
5. No painel esquerdo do File System Editor, clique com botão direito File System on
Target Machine.
6. Clique em Add Special Folder e, clique em Windows Folder.
7. No painel esquerdo de File System Editor, clique na pasta que contém a saída principal.
As DLLs tenham sido adicionadas por padrão para a mesma pasta como a Saída principal.
Para movê-los para a pasta Windows, selecione os arquivos no painel central da File
System Editor, arraste.-los sobre para o Windows Folder ícone
8. Use o mesmo procedimento para adicionar qualquer outras dependências exigidas pela
sua solução. Você pode adicionar dependências em qualquer pasta; não é necessário para
adicioná-los à pasta Windows.
Para criar um atalho para o aplicativo de projeto de dispositivo
1. No painel direito da File System Editor, selecione Primary output from <your
application project name>.
2. No menu Action, selecione Create Shortcut to Primary output from <your application
project name>.
Este comando adiciona um item atalho abaixo do item de saída.
3. Clique com o botão direito do mouse o item atalho, clique Rename, e renomear o atalho
para algo adequado para um atalho.
Para adicionar uma entrada de Registro
1. No Solution Explorer, selecione o projeto CAB.

2. No menu View, aponte para Editor, e clique em Registry.
3. Na Registry Editor, HKEY_CURRENT_USER, clique com o botão direito do mouse e, em
seguida clique New Key no menu de atalho.

4. Quando a New Key entrada for exibida na, a Registry Editor renomeação-lo
SOFTWARE.
5. Clique com o botão direito do mouse essa nova chave, aponte para New, e clique em Key
6. Quando a New Key entrada for exibida na, a Registry Editor renomeação-lo
MyCompany.
7. Clique com o botão direito do mouse na MyCompany entrada, e clique em Janela de
Propriedades no menu de atalho
O Name valor foi alterado para MyCompany.
Criando e Implantando o arquivo CAB
Para criar o arquivo CAB
1. No menu Build, clique em Build CABProject.

Ou-
Clique com o botão direito do mouse CABProject no Solution Explorer, e clique em Build.
Arquivos CAB para soluções Smartphone devem ser assinados digitalmente antes que são
implantados para dispositivo uma usuário fim na. Não há suporte para assinatura digital
sobre soluções Pocket PC baseadas em Windows Mobile 2003SE e anteriormente. Para
obter mais informações, consulte Como Assinar um Arquivo CAB (Dispositivos).
Para implantar o arquivo CAB para o dispositivo
1. No Windows Explorer, navegue até a pasta onde você armazenados nesta solução. Você
encontrará o arquivo cab na pasta CABProject\Release da sua solução.
2. Copie o arquivo CAB para um dispositivo que esteja conectado com o ActiveSync 4.0 ou
posterior.
Quando um usuário toques no nome de arquivo CAB File Explorer no dispositivo, Windows
CE explodir o CAB, e instalar o aplicativo no dispositivo.
Para obter mais informações, consulte a documentação e Smartphone Pocket PC SDK.
Consulte também
Como Importar e Aplicar Certificados em Projetos de Dispositivos
A Select Certificate caixa de diálogo está o portal central para assinar projetos de dispositivo. Ele
fornece uma entrada à caixa Manage Certificates de diálogo caixa e a Certificate Import Wizard
como descritos nas etapas a seguir.
Observação
Exibindo a caixa de diálogo Selecionar de certificados

Como você acessar a Select Certificate caixa de diálogo depende do tipo de projeto que você
deseja assinar.
Para exibir a caixa de diálogo Selecionar certificado

2. Continuar usando um dos seguintes procedimentos:
o Para projetos do Visual Basic e Visual C# selecione Authenticode Signature, e
clique em Select Certificate.: a Project Designer, clique Devices em
o Em projetos Visual C++, selecionar Authenticode Signing, e clique no botão de
reticências na linha Certificate propriedade
o Em projetos inteligente CAB dispositivo, selecione Authenticode Signing, e depois
clique em Select from Store.
Selecionar um certificado para um projeto de dispositivo
Após você ter exibido caixa Select Certificate de diálogo conforme descrito em etapas anteriores,
você pode selecionar o certificado a ser.
Para selecionar um certificado para o projeto usando a caixa de diálogo Selecionar certificado
• Se a Select Certificate caixa de diálogo exibe o certificado a ser para o projeto, selecione
o certificado, e clique em OK
O projeto está assinado com esse certificado quando o projeto é criado.
• Se a Select Certificate caixa de diálogo não exibir o certificado a ser para o projeto, você
pode importar um certificado usando o Certificate Import Wizard.
Importar um certificado para um projeto de dispositivo
As etapas a seguir mostram como preencher a Select Certificate caixa de diálogo ao importar os
certificados de teste fornecidos pelo Visual Studio e aplicação da um projeto. Você pode seguir
esse mesmo procedimento se você desejar aplicar um certificado diferente.
Fornece Visual Studio três elementos da interface do usuário para a tarefa de importar um
certificado para aplicar a um projeto:
• A Select Certificate caixa de diálogo que especifica quais certificados são a serem
aplicadas ao projeto atual.
• A Manage Certificates caixa de diálogo que lista o certificado arquivos disponível no
• O Assistente para importação de certificados que guiará você selecionar o arquivo de
certificado e especificar onde deseja armazená-lo.
Para importar um certificado de teste usando o Assistente para importação de certificados
1. Na caixa Select Certificate de diálogo, clique em Manage Certificates.

Caixa Manage Certificates de diálogo exibe uma lista de certificados armazenados no
2. Clique Import para abrir o Certificate Import Wizard.
3. Clique Next para abrir a File to Import página do assistente.

4. Clique Browse para navegar para a TestCertificates pasta no Visual Studio.
Por padrão, esta pasta está localizada em \Program Files\Microsoft
8\SmartDevices\SDK\SDKTools Visual Studio.
5. Alterar a Files of Type seleção para All Files (*.*), selecionar TestCert_Privileged.pfx ou
TestCert_Unprivileged.pfx. e, em seguida clique em Open
6. Na página File to Import do assistente, clique Next para abrir a Password página.
Deixe a Passwod caixa em branco. Esses teste certificados não tem uma senha.
7. Clique Next para abrir a Certificate Store página. Certifique-se de que Personal está
marcada na caixa Certificate store.
8. Clique Next para exibir a página de conclusão, e clique em Finish.
A mensagem Import was successful é exibida.
9. Clique OK para ignorar a mensagem.
O certificado agora aparece na lista Manage Certificates. Clique Close para retornar à
caixa Select Certificate de diálogo.
10. Selecione o certificado que desejar e clique em OK.
O certificado agora é listado na página de propriedades é iniciado a partir.
Como Iniciar Signtool.exe como um Evento Post-Build (Dispositivos)
Executar signtool.EXE como um evento Post-Build quando outros eventos Post-Build alterar os
binários originais. Alterações binários assinados invalida a assinatura original.
Observação
Para iniciar signtool.EXE como um evento Post-Build em projetos do dispositivo Visual Basic e
Visual C#
1. No Solution Explorer, clique com o projeto, e no menu de atalho, clique em Properties
2. Da Build Events página (Visual C#) ou a Compile página (Visual Basic), clique em Edit
Post-build.
3. Na caixa Post-build Event Command Line de diálogo, digite a linha de comando signtool
com as opções selecionadas.
Para obter mais informações sobre como executar signtool a partir da linha de comando,
consulte SignTool.
Para iniciar signtool.EXE como um evento Post-Build em projetos de dispositivo Visual C++
1. No Solution Explorer, clique com o projeto, e no menu de atalho, clique em Properties
2. Em Configuration Properties, expanda o Build Events nó.
3. Clique em Post-Build Event.
4. Selecione a Command Line propriedade, e clique no ellipsis botão. Para abrir a
Command Line caixa de diálogo (…)
5. Digite a linha de comando signtool com as opções selecionadas.

Para obter mais informações sobre como executar signtool a partir da linha de comando,
consulte SignTool.
Como Consultar um Dispositivo por seu Modelo de Segurança
Você pode consultar um dispositivo para ver quais certificados já estão instalados no
armazenamento de certificados do dispositivo. Você pode usar essas informações para determinar
qual certificado desejado para assinar seu aplicativo COM.
Consultando é feito pelo executando RapiConfig.exe e passando em um arquivo XML StoreQuery,

que contém a consulta de armazenamento de certificado. RapiConfig.exe depois envia um arquivo
XML que contém o resultado da consulta.
RapiConfig.exe, CertStoreQuery.xml, e vários arquivos de consulta XML de exemplo estão

localizados por padrão no \Program Files\Microsoft 8\SmartDevices\SDK\SDKTools Visual Studio.
Os seguintes componentes são necessários para consultar o armazenamento de certificados do

dispositivo:
• O ActiveSync.
• RapiConfig.exe.
• Consulta armazenamento certificado XML arquivo (CertStoreQuery.xml).
Para consultar um dispositivo para seu modelo de segurança
1. Estabelecer uma conexão do ActiveSync para o dispositivo.
2. Digite o seguinte comando no prompt de comando, onde certstorequery.xml é
armazenamento de certificado o arquivo XML de consulta:
Rapiconfig.exe /P /M <certstorequery.xml>
3. Exibir o arquivo RapiConfigOut.XML gerado.
Como: Assinar um aplicativo Visual Basic ou Visual C# (Dispositivos)
As seguintes etapas presumem você tiver um dispositivo inteligente Visual Basic ou Projeto Visual
C# na sua solução. Para obter mais informações, consulte Programação para Dispositivos usando
o .NET Compact Framework.
Essas etapas são os mesmos para projetos tanto EXE e DLL.
Observação
Para assinar um projeto Visual Basic ou Visual C# dispositivo

1. No Solution Explorer, clique com o projeto Visual Basic ou Visual C#, e seguida, no menu
de atalho, clique em Properties.
2. Na página Devices, clique em Authenticode Signature.
3. Clique em Select Certificate.

4. Na caixa Select Certificate de diálogo:
o Se o certificado a ser é exibido na lista, selecione-, e clique OK para fechar a caixa
de diálogo.
o Se o certificado a ser não aparecer na lista, clique Manage Certificates para abrir
a Manage Certificates caixa de diálogo. Para obter mais informações, consulte Como
Importar e Aplicar Certificados em Projetos de Dispositivos.
Quando você tiver terminado adquirir o certificado, clique OK na caixa Select Certificate de
diálogo. Detalhes do Certificado aparecem na janela Application Signing da página
Devices.
Como Assinar um Assembly Visual Basic ou Visual C# (Dispositivos)
As etapas abaixo presumem é ter um dispositivo inteligente Visual Basic ou Visual C# projeto na
solução. Para obter mais informações sobre como criar esses projetos, consulte Programação
para Dispositivos usando o .NET Compact Framework.
Essas etapas são os mesmos para projetos tanto EXE e DLL.
Observação
Para assinar um conjunto em um projeto de dispositivo Visual Basic ou Visual C#

2. Na página Signing, clique em Sign the assembly.
3. Na caixa Choose a strong name key file:
o Se você desejar usar um arquivo de chave de nome de alta segurança já existente,
clique <Browse…> para abrir caixa Select File de diálogo.
o Se você desejar criar um novo arquivo de chave de nome de alta segurança, clique
New para abrir a Create Strong Name Key caixa de diálogo.
Para atrasar uma assinatura de Assembly
• Após completar as etapas acima, clique em Delay sign only.
Use este recurso quando você não tem acesso a uma chave particular é necessário. Atraso
assinatura fornece a chave pública e adia adicionando a chave particular até o conjunto é
enviado a. Para obter mais informações, consulte Como: Assinar com atraso um Assembly
(Visual Studio).
Como Assinar um Arquivo CAB (Dispositivos)
As etapas abaixo presumem você tiver um projeto CAB dispositivos inteligentes em sua solução.
Para obter mais informações, consulte Visão geral Solutions do dispositivo de embalagem.
Observação

Para assinar um arquivo.cab de Dispositivo Inteligente

1. No Solution Explorer, clique com o projeto CAB dispositivo inteligente, e clique
Properties no menu de atalho
2. Na página Build, selecione Authenticode Signature.
3. Clique em Select from Store.
4. Na caixa Select Certificate de diálogo:
o Se o certificado a ser é exibido na lista, selecione-, e clique OK para fechar a caixa
de diálogo.
o Se o certificado a ser não aparecer na lista, clique Manage Certificates para abrir
a Manage Certificates caixa de diálogo. Para obter mais informações, consulte Como
Importar e Aplicar Certificados em Projetos de Dispositivos.
Quando você tiver terminado adquirir o certificado, clique OK na caixa Select Certificate de
diálogo. O certificado aparecerá na caixa Certificate da página Build.
5. Na página Build, clique em OK.
Como Prover um Dispositivo em um Projeto Visual Basic ou Visual C#
Configuração um dispositivo se refere ao adicionar certificados digitais a armazenamentos de

certificados do dispositivo. Para obter mais informações, consulte Um Practical guia para a
segurança do Smartphone e código modelo assinatura para desenvolvedores.
Pressuponha as seguintes etapas:
• Você ter um projeto de dispositivos inteligentes Visual Basic ou Visual C# em sua solução.
Para obter mais informações, consulte Programação para Dispositivos usando o .NET
Compact Framework.
• Você entrou o aplicativo. Para obter mais informações, consulte Como: Assinar um
aplicativo Visual Basic ou Visual C# (Dispositivos).
Observação
Para configurar um dispositivo em um projeto de dispositivo gerenciado

2. Abra a Devices página.
3. Na caixa Device provisioning, selecione uma das opções a seguir:
o O dispositivo de destino não Provision
o Configurar o armazenamento Privileged

o Configurar o armazenamento Unprivileged
Como Prover um Dispositivo com um Modelo de Segurança
Você pode definir o modelo de segurança do dispositivo explicitamente para testar um aplicativo
em vários modelos de segurança. Depois configuração um modelo de segurança diferente se o
dispositivo já está bloqueado por fabricante do equipamento original (OEM), talvez não possível.
No entanto, se o dispositivo não estiver protegido, você pode prover ele com qualquer modelo de
segurança.
Os seguintes arquivos XML de modelo de segurança estão incluídos no Visual Studio 2005. O
local padrão é \Program Files\Microsoft 8\SmartDevices\SDK\SDKTools\SecurityModels Visual
Studio.
• Locked.XML define o seguinte modelo de segurança em duas camadas:

o Notifique-o antes de executar aplicativos.
o Não execute aplicativos não assinados.
• Prompt.XML define o seguinte modelo de segurança em duas camadas:
o Notifique-o antes de executar aplicativos.
o Executar aplicativos sem assinatura como sem privilégios.
• Open.XML define o modelo de segurança-uma camada a seguir:
o Não solicitar.
o Executar todos os aplicativos, incluindo não assinados, como privilegiado.
Os seguintes componentes serão necessárias a fim de configurar o dispositivo com um modelo de

segurança:
• O ActiveSync.
• RapiConfig.exe, localizado, por padrão em \Program Files\Microsoft
8\SmartDevices\SDK\SDKTools Visual Studio.
• Arquivo XML de segurança.
Para configurar um dispositivo com um modelo de segurança
1. Estabelecer uma conexão do ActiveSync para o dispositivo.
2. Digite o seguinte comando no prompt de comando, onde securityfile.xml é o arquivo XML
de modelo de segurança:
RapiConfig.exe /P /M <securityfile.xml>

Implantação (Como fazer em C#)
Os links desta página ajudam nas tarefas de implantação mais comuns. Para ver outras
categorias de tarefas populares abordadas na Ajuda, consulte Como fazer em C#.
ClickOnce
COMO: Publicar um aplicativo ClickOnce
Demonstra como tornar um aplicativo ClickOnce disponível aos usuários publicando-o em

um servidor Web, compartilhamento de arquivo, ou mídia removível.
COMO: Especificar uma publicação local
Demonstra como especificar o local onde os arquivos de aplicativo e manifesto serão

colocados.
COMO: Especificar uma URL de Instalação
Demonstra como utilizar a propriedade URL de Instalação para especificar o servidor Web
onde os usuários irão fazer download do aplicativo.
COMO: Especificar uma URL de Suporte
Demonstra como utilizar a propriedade URL de Suporte para identificar uma página da
Web ou compartilhamento de arquivo onde usuários podem ir para obter informações
sobre o aplicativo.
COMO: Especificar o modo de instalação ClickOnce
Demonstra como definir o modo de instalação para especificar se o aplicativo será

disponível off-line ou on-line.
COMO: Ativar AutoIniciar para instalações a partir de CD
Demonstra como ativar AutoIniciar para que o aplicativo ClickOnce seja automaticamente
iniciado quando a mídia for inserida.
COMO: Definir o Versão de Publicação do ClickOnce
Demonstra como definir a propriedade Versão de Publicação, que determina se o

aplicativo que você está publicando será tratado como uma atualização.
COMO: Automaticamente incrementar a Versão de Publicação do ClickOnce
Demonstra como alterar a propriedade Versão de Publicação para fazer com que o
aplicativo seja publicado como uma atualização.
COMO: Especificar qual arquivo foi publicado via ClickOnce
Demonstra como excluir arquivos, marcar os arquivos como arquivos de dados ou pré-
requisitos, e criar grupos de arquivos para instalação condicional.
COMO: Instalar pré-requisitos com um aplicativo ClickOnce

Demonstra como especificar um conjunto de componentes de pré-requisito para ser
empacotado junto com seu aplicativo.
COMO: Gerenciar atualizações para um aplicativo ClickOnce
Demonstra como especificar quando e como verificações de atualização são executadas,

se as atualizações são obrigatórias, e onde o aplicativo deve verificar por atualizações.
COMO: Incluir um arquivo de dados em um aplicativo ClickOnce
Fornece procedimentos que mostram como adicionar um arquivo de dados de qualquer

tipo em um aplicativo ClickOnce.
COMO: Implantar o .NET Framework usando o Systems Management Server
Fornece tarefas que devem ser executadas no servidor que executa o Systems
Management Server.
COMO: Adicionar um Publisher confiável a um computador cliente para aplicativos ClickOnce
Mostra como usar a ferramenta de linha de comando CertMgr.exe para adicionar um

certificado de editor aos editores de confiança armazenados no computador cliente.
COMO: Especificar um local alternativo para implantação de atualizações
Mostra como especificar um local alternativo para atualizações em seu manifesto de

implantação para que o aplicativo possa atualizar a si próprio a partir da Web após sua
instalação inicial.
COMO: Implantar o .NET Framework usando o Active Directory
Fornece um procedimento para implantar o .NET Framework usando o Active Directory.
COMO: Recuperar informações de seqüência de consulta em um aplicativo ClickOnce
Fornece procedimento para mostrar como usar um aplicativo ClickOnce para obter
informações de seqüência de consulta. Ele também mostra como seu aplicativo ClickOnce
pode usar um pedaço pequeno de código para ler esses valores na primeira vez que inicia
o aplicativo.
COMO: Ativar configurações de segurança ClickOnce
Demonstra como desabilitar temporariamente as configurações de segurança durante o

desenvolvimento.
COMO: Definir uma Zona de Segurança para um aplicativo ClickOnce
Demonstra como definir uma zona de segurança para preencher as permissões exigidas
pela tabela de aplicativo.
COMO: Definir permissões personalizadas para um aplicativo ClickOnce
Demonstra como restringir o aplicativo às permissões específicas que ele precisa para
operar corretamente.

COMO: Determinar as permissões para um aplicativo ClickOnce
Demonstra como analisar o aplicativo para determinar as permissões necessárias,

executando a ferramenta Permission Calculator.
COMO: Depurar um aplicativo ClickOnce com permissões restritas
Demonstra como depurar o aplicativo com as mesmas permissões que o usuário final.
O Windows Installer
Implantação do Windows Installer
Links para artigos sobre como usar a implantação do Windows Installer para criar pacotes
instaladores a serem distribuídos aos usuários.
Passo a passo: Distribuindo um aplicativo baseado no Windows
Demonstra o processo de criação de um instalador para um aplicativo do Windows que

inicia o bloco de notas.
Passo a passo: Instalando componentes compartilhados usando módulos de mesclagem
Como usar módulos de mesclagem para garantir que componentes compartilhados são
empacotados e entregues para implantação consistente.
Passo a passo: Criando uma ação personalizada
Demonstra o processo de criação de uma DLL de ação personalizada para direcionar um

usuário a uma página da Web no final de uma instalação.
Passo a passo: Usando uma ação personalizada para exibir uma mensagem na instalação
Demonstra como usar uma ação personalizada para tirar a entrada do usuário e passá-la a
uma caixa de mensagem que aparece durante a instalação.
Passo a passo: Usando uma ação personalizada para pré-compilar um assembly na instalação
Demonstra como passar o caminho de uma DLL para a propriedade CustomActionData

para pré-compilar o assembly para código nativo durante a instalação.
Passo a passo: Usando uma ação personalizada para criar um banco de dados na instalação
Demonstra o uso de uma ação personalizada e a propriedade CustomActionData para

criar um banco de dados e tabela de banco de dados durante a instalação.
Passo a passo: Redirecionando um aplicativo para alcançar um XML Web Service diferente na
instalação
Demonstra como criar um aplicativo da Web que pode ser redirecionado para alcançar um
XML Web Service diferente usando a propriedade Comportamento da URL, uma classe de
instalador, e um projeto de Configuração Web.
COMO: Instalar pré-requisitos na implantação do Windows Installer

Demonstra como detectar a existência de componentes durante a instalação e instala um
conjunto pré-determinado de pré-requisitos, um processo conhecido como inicialização.
COMO: Criar ou adicionar projetos de implantação
Demonstra como especificar onde e como sua solução será implantada durante e depois
do desenvolvimento.
COMO: Criar ou adicionar um instalador de projeto
Demonstra como criar arquivos do Windows Installer (.msi), que são usados para distribuir
seu aplicativo para instalação em outro computador ou servidor Web.
COMO: Criar ou adicionar um projeto de módulo de mesclagem
Demonstra como criar um projeto de módulo de mesclagem para arquivos de pacote ou

componentes que serão compartilhados entre vários aplicativos.
COMO: Criar ou adicionar um projeto CAB
Demonstra como criar um projeto CAB para criar arquivos de gabinete (.CAB) que podem
ser usados por componentes baixados em um navegador da Web.
COMO: Definir propriedades do projeto de implantação
Demonstra como definir propriedades dependentes de configuração usando a caixa de

diálogo de Propriedades de Implantação.
COMO: Adicionar itens a um projeto de implantação
Demonstra como especificar o que precisa ser incluído no instalador e onde instalá-lo no
computador de destino.
COMO: Adicionar módulos de mesclagem a um projeto de implantação
Demonstra como usar módulos de mesclagem (arquivos .msm) para compartilhar

componentes entre vários projetos de implantação.
COMO: Adicionar e remover ícones
Demonstra como instalar e associar ícones a seu aplicativo em um computador de destino

durante a instalação.
COMO: Excluir itens do Projeto de Implantação
Demonstra como excluir um arquivo ou arquivos de um projeto de implantação.
COMO: Definir instalação condicional com base em versões do sistema operacional
Demonstra como definir a propriedade Condição para adicionar lógica condicional a um

instalador, por exemplo, instalando diferentes arquivos ou definindo valores diferentes de
registro para versões diferentes do sistema operacional.

Apostila Visual C# (Consolidada) - PT-BR

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apostila Visual C# (Consolidada) - PT-BR

Hochgeladen von

Copyright:

Verfügbare Formate

Nível I - Iniciante

Autor: Elzevir Jr.

Guia de Introdução ao Visual C#

Guia da Documentação do Visual C#

O que há de novo no Visual C# 2005

O que há de novo na C# 2.0 idioma e Compiler

Atualizando Aplicativos Visual C# para Visual Studio 2005

Criando Seu Primeiro Aplicativo C#

Usando Starter Kits C#

Recursos de Ajuda Adicionais (Visual C#)

Introdução à IDE (Visual C#)

Criando um Projeto (Visual C#)

Outros arquivos de código fonte

Projetando uma interface de usuário (Visual C#)

Quando você adiciona um manipulador de eventos através da janela Properties, o designer

O Visual C# fornece as seguintes ferramentas para ajudá-lo a navegar e pesquisar o

Configurações Versão vs. Depuração

Para mais informações, consulte Pesquisador de Objetos

Recursos do Code Editor do Visual C#

Trechos de códigos (C#)

Brace Colorization correspondência

"" Uma seqüência

Metadados como fonte

Configurações do IDE Visual C#

Recurso Exibido por padrão? Observações

Atalhos de Teclado Visual C#

Name (Nome) Teclas de Descrição

Usando a Biblioteca de Classe do .NET Framework (Visual C#)

Criando Aplicativos de Console (Visual C#)

Acessar e exibir dados (Visual C#)

Criando Aplicativos Móveis e Incorporados (Visual C#)

Desenvolvendo na Plataforma do Office (Visual C#)

Programação do Office (Como Fazer em C#)

Como: Atualizar soluções das Ferramentas do Visual Studio

Coleta de dados usando um formulário do Windows

Criando um novo projeto

Alterando planilha formatação usando controles CheckBox

Propriedade Value (Valor)

5. Arraste uma segunda caixa de seleção ou próxima célula B4 e alterar as seguintes

Propriedade Value (Valor)

6. Arraste uma caixa de seleção terceira ou próxima célula B6 e alterar as seguintes

Propriedade Value (Valor)

7. Selecione todos os controles caixa de seleção três mantendo a tecla CTRL.

Propriedade Value (Valor)

Exibindo texto em uma caixa de texto em uma planilha usando

Propriedade Value (Valor)

Agora Escreva o código a ser executado quando o botão é clicado.

Programação contra eventos de um controle NamedRange

Adicionar código para responder ao evento SelectionChange

Passo-a-passo: Concedendo e removendo permissões para uma

Passo-a-passo: Ligando uma célula de planilha a um campo de

A próxima etapa é para adicionar texto para os botões, e em C# Adicionar manipuladores de

Walkthrough: vinculação células para várias colunas em uma

CódigoDoFuncionário Sobrenome FirstName Título

Para excluir linhas

Criando uma relação mestre / detalhes usando um DataSet em

Walkthrough: atualizando um gráfico em uma planilha usando botões de

Em seguida, adicione o gráfico para a primeira planilha.

Propriedade Value (Valor)

Adicionar um controle de usuário ao projeto

Propriedade Value (Valor)

3. Adicionar um botão de opção segundo para o controle de usuário, e alterar as

Propriedade Value (Valor)